]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _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 bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3825 #if wxUSE_HOTKEY
3826 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3827 #else
3828 return false;
3829 #endif
3830 }
3831 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3832
3833
3834
3835 return false;
3836
3837 }
3838 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3839 return wxPyGetWinHandle(self);
3840 }
3841 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3842 self->AssociateHandle((WXWidget)handle);
3843 }
3844 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3845
3846 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3847 return wxWindow::FindWindowById(id, parent);
3848 }
3849
3850 wxWindow* wxFindWindowByName( const wxString& name,
3851 const wxWindow *parent = NULL ) {
3852 return wxWindow::FindWindowByName(name, parent);
3853 }
3854
3855 wxWindow* wxFindWindowByLabel( const wxString& label,
3856 const wxWindow *parent = NULL ) {
3857 return wxWindow::FindWindowByLabel(label, parent);
3858 }
3859
3860
3861 #ifdef __WXMSW__
3862 #include <wx/msw/private.h> // to get wxGetWindowId
3863 #endif
3864
3865
3866 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3867 #ifdef __WXMSW__
3868 WXHWND hWnd = (WXHWND)_hWnd;
3869 long id = wxGetWindowId(hWnd);
3870 wxWindow* win = new wxWindow;
3871 if (parent)
3872 parent->AddChild(win);
3873 win->SetEventHandler(win);
3874 win->SetHWND(hWnd);
3875 win->SetId(id);
3876 win->SubclassWin(hWnd);
3877 win->AdoptAttributesFromHWND();
3878 win->SetupColours();
3879 return win;
3880 #else
3881 wxPyRaiseNotImplemented();
3882 return NULL;
3883 #endif
3884 }
3885
3886
3887 PyObject* GetTopLevelWindows() {
3888 return wxPy_ConvertList(&wxTopLevelWindows);
3889 }
3890
3891
3892 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3893 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3894 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3895
3896 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3897
3898
3899 SWIGINTERNINLINE int
3900 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3901 {
3902 unsigned long v;
3903 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3904 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3905 return res;
3906 }
3907
3908 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3909 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3910 wxMenuItemList& list = self->GetMenuItems();
3911 return wxPy_ConvertList(&list);
3912 }
3913 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3914 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3915 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3916 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3917 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3918 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3919 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3920 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3921 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3922 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3923 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3924 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3925 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3926 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3927 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3928 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3929 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3930 static const wxString wxPyControlNameStr(wxControlNameStr);
3931 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3932 if (clientData) {
3933 wxPyClientData* data = new wxPyClientData(clientData);
3934 return self->Append(item, data);
3935 } else
3936 return self->Append(item);
3937 }
3938 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3939 if (clientData) {
3940 wxPyClientData* data = new wxPyClientData(clientData);
3941 return self->Insert(item, pos, data);
3942 } else
3943 return self->Insert(item, pos);
3944 }
3945 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3946 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3947 if (data) {
3948 Py_INCREF(data->m_obj);
3949 return data->m_obj;
3950 } else {
3951 Py_INCREF(Py_None);
3952 return Py_None;
3953 }
3954 }
3955 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3956 wxPyClientData* data = new wxPyClientData(clientData);
3957 self->SetClientObject(n, data);
3958 }
3959
3960
3961 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3962 wxPyUserData* data = NULL;
3963 if ( userData ) {
3964 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3965 data = new wxPyUserData(userData);
3966 wxPyEndBlockThreads(blocked);
3967 }
3968 return new wxSizerItem(window, proportion, flag, border, data);
3969 }
3970 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3971 wxPyUserData* data = NULL;
3972 if ( userData ) {
3973 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3974 data = new wxPyUserData(userData);
3975 wxPyEndBlockThreads(blocked);
3976 }
3977 return new wxSizerItem(width, height, proportion, flag, border, data);
3978 }
3979 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3980 wxPyUserData* data = NULL;
3981 if ( userData ) {
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 data = new wxPyUserData(userData);
3984 wxPyEndBlockThreads(blocked);
3985 }
3986 return new wxSizerItem(sizer, proportion, flag, border, data);
3987 }
3988
3989 SWIGINTERNINLINE PyObject *
3990 SWIG_From_float (float value)
3991 {
3992 return SWIG_From_double (value);
3993 }
3994
3995 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3996 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3997 if (data) {
3998 Py_INCREF(data->m_obj);
3999 return data->m_obj;
4000 } else {
4001 Py_INCREF(Py_None);
4002 return Py_None;
4003 }
4004 }
4005 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4006 wxPyUserData* data = NULL;
4007 if ( userData ) {
4008 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4009 data = new wxPyUserData(userData);
4010 wxPyEndBlockThreads(blocked);
4011 }
4012 self->SetUserData(data);
4013 }
4014
4015 // Figure out the type of the sizer item
4016
4017 struct wxPySizerItemInfo {
4018 wxPySizerItemInfo()
4019 : window(NULL), sizer(NULL), gotSize(false),
4020 size(wxDefaultSize), gotPos(false), pos(-1)
4021 {}
4022
4023 wxWindow* window;
4024 wxSizer* sizer;
4025 bool gotSize;
4026 wxSize size;
4027 bool gotPos;
4028 int pos;
4029 };
4030
4031 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4032
4033 wxPySizerItemInfo info;
4034 wxSize size;
4035 wxSize* sizePtr = &size;
4036
4037 // Find out what the type of the item is
4038 // try wxWindow
4039 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4040 PyErr_Clear();
4041 info.window = NULL;
4042
4043 // try wxSizer
4044 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4045 PyErr_Clear();
4046 info.sizer = NULL;
4047
4048 // try wxSize or (w,h)
4049 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4050 info.size = *sizePtr;
4051 info.gotSize = true;
4052 }
4053
4054 // or a single int
4055 if (checkIdx && PyInt_Check(item)) {
4056 info.pos = PyInt_AsLong(item);
4057 info.gotPos = true;
4058 }
4059 }
4060 }
4061
4062 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4063 // no expected type, figure out what kind of error message to generate
4064 if ( !checkSize && !checkIdx )
4065 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4066 else if ( checkSize && !checkIdx )
4067 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4068 else if ( !checkSize && checkIdx)
4069 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4070 else
4071 // can this one happen?
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4073 }
4074
4075 return info;
4076 }
4077
4078 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4079 if (!self->GetClientObject())
4080 self->SetClientObject(new wxPyOORClientData(_self));
4081 }
4082 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4083
4084 wxPyUserData* data = NULL;
4085 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4087 if ( userData && (info.window || info.sizer || info.gotSize) )
4088 data = new wxPyUserData(userData);
4089 if ( info.sizer )
4090 PyObject_SetAttrString(item,"thisown",Py_False);
4091 wxPyEndBlockThreads(blocked);
4092
4093 // Now call the real Add method if a valid item type was found
4094 if ( info.window )
4095 return self->Add(info.window, proportion, flag, border, data);
4096 else if ( info.sizer )
4097 return self->Add(info.sizer, proportion, flag, border, data);
4098 else if (info.gotSize)
4099 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4100 proportion, flag, border, data);
4101 else
4102 return NULL;
4103 }
4104 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4105
4106 wxPyUserData* data = NULL;
4107 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4108 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4109 if ( userData && (info.window || info.sizer || info.gotSize) )
4110 data = new wxPyUserData(userData);
4111 if ( info.sizer )
4112 PyObject_SetAttrString(item,"thisown",Py_False);
4113 wxPyEndBlockThreads(blocked);
4114
4115 // Now call the real Insert method if a valid item type was found
4116 if ( info.window )
4117 return self->Insert(before, info.window, proportion, flag, border, data);
4118 else if ( info.sizer )
4119 return self->Insert(before, info.sizer, proportion, flag, border, data);
4120 else if (info.gotSize)
4121 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4122 proportion, flag, border, data);
4123 else
4124 return NULL;
4125 }
4126 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4127
4128 wxPyUserData* data = NULL;
4129 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4130 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4131 if ( userData && (info.window || info.sizer || info.gotSize) )
4132 data = new wxPyUserData(userData);
4133 if ( info.sizer )
4134 PyObject_SetAttrString(item,"thisown",Py_False);
4135 wxPyEndBlockThreads(blocked);
4136
4137 // Now call the real Prepend method if a valid item type was found
4138 if ( info.window )
4139 return self->Prepend(info.window, proportion, flag, border, data);
4140 else if ( info.sizer )
4141 return self->Prepend(info.sizer, proportion, flag, border, data);
4142 else if (info.gotSize)
4143 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4144 proportion, flag, border, data);
4145 else
4146 return NULL;
4147 }
4148 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4151 wxPyEndBlockThreads(blocked);
4152 if ( info.window )
4153 return self->Remove(info.window);
4154 else if ( info.sizer )
4155 return self->Remove(info.sizer);
4156 else if ( info.gotPos )
4157 return self->Remove(info.pos);
4158 else
4159 return false;
4160 }
4161 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4163 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4164 wxPyEndBlockThreads(blocked);
4165 if ( info.window )
4166 return self->Detach(info.window);
4167 else if ( info.sizer )
4168 return self->Detach(info.sizer);
4169 else if ( info.gotPos )
4170 return self->Detach(info.pos);
4171 else
4172 return false;
4173 }
4174 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4175 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4176 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4177 wxPyEndBlockThreads(blocked);
4178 if ( info.window )
4179 return self->GetItem(info.window);
4180 else if ( info.sizer )
4181 return self->GetItem(info.sizer);
4182 else if ( info.gotPos )
4183 return self->GetItem(info.pos);
4184 else
4185 return NULL;
4186 }
4187 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4190 wxPyEndBlockThreads(blocked);
4191 if ( info.window )
4192 self->SetItemMinSize(info.window, size);
4193 else if ( info.sizer )
4194 self->SetItemMinSize(info.sizer, size);
4195 else if ( info.gotPos )
4196 self->SetItemMinSize(info.pos, size);
4197 }
4198 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4199 wxSizerItemList& list = self->GetChildren();
4200 return wxPy_ConvertList(&list);
4201 }
4202 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4204 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4205 wxPyEndBlockThreads(blocked);
4206 if ( info.window )
4207 return self->Show(info.window, show, recursive);
4208 else if ( info.sizer )
4209 return self->Show(info.sizer, show, recursive);
4210 else if ( info.gotPos )
4211 return self->Show(info.pos, show);
4212 else
4213 return false;
4214 }
4215 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4217 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4218 wxPyEndBlockThreads(blocked);
4219 if ( info.window )
4220 return self->IsShown(info.window);
4221 else if ( info.sizer )
4222 return self->IsShown(info.sizer);
4223 else if ( info.gotPos )
4224 return self->IsShown(info.pos);
4225 else
4226 return false;
4227 }
4228
4229 // See pyclasses.h
4230 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4231 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4232 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4233
4234
4235
4236
4237 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4238 {
4239 if (source == Py_None) {
4240 **obj = wxGBPosition(-1,-1);
4241 return true;
4242 }
4243 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4244 }
4245
4246 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4247 {
4248 if (source == Py_None) {
4249 **obj = wxGBSpan(-1,-1);
4250 return true;
4251 }
4252 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4253 }
4254
4255
4256 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4257 wxGBPosition temp, *obj = &temp;
4258 if ( other == Py_None ) return false;
4259 if ( ! wxGBPosition_helper(other, &obj) ) {
4260 PyErr_Clear();
4261 return false;
4262 }
4263 return self->operator==(*obj);
4264 }
4265 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4266 wxGBPosition temp, *obj = &temp;
4267 if ( other == Py_None ) return true;
4268 if ( ! wxGBPosition_helper(other, &obj)) {
4269 PyErr_Clear();
4270 return true;
4271 }
4272 return self->operator!=(*obj);
4273 }
4274 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4275 self->SetRow(row);
4276 self->SetCol(col);
4277 }
4278 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 PyObject* tup = PyTuple_New(2);
4281 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4282 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4283 wxPyEndBlockThreads(blocked);
4284 return tup;
4285 }
4286 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4287 wxGBSpan temp, *obj = &temp;
4288 if ( other == Py_None ) return false;
4289 if ( ! wxGBSpan_helper(other, &obj) ) {
4290 PyErr_Clear();
4291 return false;
4292 }
4293 return self->operator==(*obj);
4294 }
4295 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4296 wxGBSpan temp, *obj = &temp;
4297 if ( other == Py_None ) return true;
4298 if ( ! wxGBSpan_helper(other, &obj)) {
4299 PyErr_Clear();
4300 return true;
4301 }
4302 return self->operator!=(*obj);
4303 }
4304 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4305 self->SetRowspan(rowspan);
4306 self->SetColspan(colspan);
4307 }
4308 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4309 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4310 PyObject* tup = PyTuple_New(2);
4311 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4312 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4313 wxPyEndBlockThreads(blocked);
4314 return tup;
4315 }
4316 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4317 wxPyUserData* data = NULL;
4318 if ( userData ) {
4319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4320 data = new wxPyUserData(userData);
4321 wxPyEndBlockThreads(blocked);
4322 }
4323 return new wxGBSizerItem(window, pos, span, flag, border, data);
4324 }
4325 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4326 wxPyUserData* data = NULL;
4327 if ( userData ) {
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 data = new wxPyUserData(userData);
4330 wxPyEndBlockThreads(blocked);
4331 }
4332 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4333 }
4334 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4335 wxPyUserData* data = NULL;
4336 if ( userData ) {
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 data = new wxPyUserData(userData);
4339 wxPyEndBlockThreads(blocked);
4340 }
4341 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4342 }
4343 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4344 int row, col;
4345 self->GetEndPos(row, col);
4346 return wxGBPosition(row, col);
4347 }
4348 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4349
4350 wxPyUserData* data = NULL;
4351 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4352 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4353 if ( userData && (info.window || info.sizer || info.gotSize) )
4354 data = new wxPyUserData(userData);
4355 if ( info.sizer )
4356 PyObject_SetAttrString(item,"thisown",Py_False);
4357 wxPyEndBlockThreads(blocked);
4358
4359 // Now call the real Add method if a valid item type was found
4360 if ( info.window )
4361 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4362 else if ( info.sizer )
4363 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4364 else if (info.gotSize)
4365 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4366 pos, span, flag, border, data);
4367 return NULL;
4368 }
4369
4370
4371 #ifdef __cplusplus
4372 extern "C" {
4373 #endif
4374 SWIGINTERN int EmptyString_set(PyObject *) {
4375 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4376 return 1;
4377 }
4378
4379
4380 SWIGINTERN PyObject *EmptyString_get(void) {
4381 PyObject *pyobj = 0;
4382
4383 {
4384 #if wxUSE_UNICODE
4385 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4386 #else
4387 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4388 #endif
4389 }
4390 return pyobj;
4391 }
4392
4393
4394 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4395 PyObject *resultobj = 0;
4396 wxObject *arg1 = (wxObject *) 0 ;
4397 wxString result;
4398 void *argp1 = 0 ;
4399 int res1 = 0 ;
4400 PyObject *swig_obj[1] ;
4401
4402 if (!args) SWIG_fail;
4403 swig_obj[0] = args;
4404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4405 if (!SWIG_IsOK(res1)) {
4406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4407 }
4408 arg1 = reinterpret_cast< wxObject * >(argp1);
4409 {
4410 PyThreadState* __tstate = wxPyBeginAllowThreads();
4411 result = wxObject_GetClassName(arg1);
4412 wxPyEndAllowThreads(__tstate);
4413 if (PyErr_Occurred()) SWIG_fail;
4414 }
4415 {
4416 #if wxUSE_UNICODE
4417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4418 #else
4419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4420 #endif
4421 }
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4429 PyObject *resultobj = 0;
4430 wxObject *arg1 = (wxObject *) 0 ;
4431 void *argp1 = 0 ;
4432 int res1 = 0 ;
4433 PyObject *swig_obj[1] ;
4434
4435 if (!args) SWIG_fail;
4436 swig_obj[0] = args;
4437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4438 if (!SWIG_IsOK(res1)) {
4439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4440 }
4441 arg1 = reinterpret_cast< wxObject * >(argp1);
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 wxObject_Destroy(arg1);
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 resultobj = SWIG_Py_Void();
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4456 PyObject *obj;
4457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4458 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4459 return SWIG_Py_Void();
4460 }
4461
4462 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463 PyObject *resultobj = 0;
4464 wxSize *arg1 = (wxSize *) 0 ;
4465 int arg2 ;
4466 void *argp1 = 0 ;
4467 int res1 = 0 ;
4468 int val2 ;
4469 int ecode2 = 0 ;
4470 PyObject *swig_obj[2] ;
4471
4472 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4474 if (!SWIG_IsOK(res1)) {
4475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4476 }
4477 arg1 = reinterpret_cast< wxSize * >(argp1);
4478 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4479 if (!SWIG_IsOK(ecode2)) {
4480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4481 }
4482 arg2 = static_cast< int >(val2);
4483 if (arg1) (arg1)->x = arg2;
4484
4485 resultobj = SWIG_Py_Void();
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4493 PyObject *resultobj = 0;
4494 wxSize *arg1 = (wxSize *) 0 ;
4495 int result;
4496 void *argp1 = 0 ;
4497 int res1 = 0 ;
4498 PyObject *swig_obj[1] ;
4499
4500 if (!args) SWIG_fail;
4501 swig_obj[0] = args;
4502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4503 if (!SWIG_IsOK(res1)) {
4504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4505 }
4506 arg1 = reinterpret_cast< wxSize * >(argp1);
4507 result = (int) ((arg1)->x);
4508 resultobj = SWIG_From_int(static_cast< int >(result));
4509 return resultobj;
4510 fail:
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4516 PyObject *resultobj = 0;
4517 wxSize *arg1 = (wxSize *) 0 ;
4518 int arg2 ;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 int val2 ;
4522 int ecode2 = 0 ;
4523 PyObject *swig_obj[2] ;
4524
4525 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4527 if (!SWIG_IsOK(res1)) {
4528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4529 }
4530 arg1 = reinterpret_cast< wxSize * >(argp1);
4531 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4532 if (!SWIG_IsOK(ecode2)) {
4533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4534 }
4535 arg2 = static_cast< int >(val2);
4536 if (arg1) (arg1)->y = arg2;
4537
4538 resultobj = SWIG_Py_Void();
4539 return resultobj;
4540 fail:
4541 return NULL;
4542 }
4543
4544
4545 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4546 PyObject *resultobj = 0;
4547 wxSize *arg1 = (wxSize *) 0 ;
4548 int result;
4549 void *argp1 = 0 ;
4550 int res1 = 0 ;
4551 PyObject *swig_obj[1] ;
4552
4553 if (!args) SWIG_fail;
4554 swig_obj[0] = args;
4555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4556 if (!SWIG_IsOK(res1)) {
4557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4558 }
4559 arg1 = reinterpret_cast< wxSize * >(argp1);
4560 result = (int) ((arg1)->y);
4561 resultobj = SWIG_From_int(static_cast< int >(result));
4562 return resultobj;
4563 fail:
4564 return NULL;
4565 }
4566
4567
4568 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj = 0;
4570 int arg1 = (int) 0 ;
4571 int arg2 = (int) 0 ;
4572 wxSize *result = 0 ;
4573 int val1 ;
4574 int ecode1 = 0 ;
4575 int val2 ;
4576 int ecode2 = 0 ;
4577 PyObject * obj0 = 0 ;
4578 PyObject * obj1 = 0 ;
4579 char * kwnames[] = {
4580 (char *) "w",(char *) "h", NULL
4581 };
4582
4583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4584 if (obj0) {
4585 ecode1 = SWIG_AsVal_int(obj0, &val1);
4586 if (!SWIG_IsOK(ecode1)) {
4587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4588 }
4589 arg1 = static_cast< int >(val1);
4590 }
4591 if (obj1) {
4592 ecode2 = SWIG_AsVal_int(obj1, &val2);
4593 if (!SWIG_IsOK(ecode2)) {
4594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4595 }
4596 arg2 = static_cast< int >(val2);
4597 }
4598 {
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 result = (wxSize *)new wxSize(arg1,arg2);
4601 wxPyEndAllowThreads(__tstate);
4602 if (PyErr_Occurred()) SWIG_fail;
4603 }
4604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4605 return resultobj;
4606 fail:
4607 return NULL;
4608 }
4609
4610
4611 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4612 PyObject *resultobj = 0;
4613 wxSize *arg1 = (wxSize *) 0 ;
4614 void *argp1 = 0 ;
4615 int res1 = 0 ;
4616 PyObject *swig_obj[1] ;
4617
4618 if (!args) SWIG_fail;
4619 swig_obj[0] = args;
4620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4621 if (!SWIG_IsOK(res1)) {
4622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4623 }
4624 arg1 = reinterpret_cast< wxSize * >(argp1);
4625 {
4626 PyThreadState* __tstate = wxPyBeginAllowThreads();
4627 delete arg1;
4628
4629 wxPyEndAllowThreads(__tstate);
4630 if (PyErr_Occurred()) SWIG_fail;
4631 }
4632 resultobj = SWIG_Py_Void();
4633 return resultobj;
4634 fail:
4635 return NULL;
4636 }
4637
4638
4639 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4640 PyObject *resultobj = 0;
4641 wxSize *arg1 = (wxSize *) 0 ;
4642 PyObject *arg2 = (PyObject *) 0 ;
4643 bool result;
4644 void *argp1 = 0 ;
4645 int res1 = 0 ;
4646 PyObject * obj0 = 0 ;
4647 PyObject * obj1 = 0 ;
4648 char * kwnames[] = {
4649 (char *) "self",(char *) "other", NULL
4650 };
4651
4652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4654 if (!SWIG_IsOK(res1)) {
4655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4656 }
4657 arg1 = reinterpret_cast< wxSize * >(argp1);
4658 arg2 = obj1;
4659 {
4660 result = (bool)wxSize___eq__(arg1,arg2);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 {
4664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4665 }
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj = 0;
4674 wxSize *arg1 = (wxSize *) 0 ;
4675 PyObject *arg2 = (PyObject *) 0 ;
4676 bool result;
4677 void *argp1 = 0 ;
4678 int res1 = 0 ;
4679 PyObject * obj0 = 0 ;
4680 PyObject * obj1 = 0 ;
4681 char * kwnames[] = {
4682 (char *) "self",(char *) "other", NULL
4683 };
4684
4685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4687 if (!SWIG_IsOK(res1)) {
4688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4689 }
4690 arg1 = reinterpret_cast< wxSize * >(argp1);
4691 arg2 = obj1;
4692 {
4693 result = (bool)wxSize___ne__(arg1,arg2);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 {
4697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4698 }
4699 return resultobj;
4700 fail:
4701 return NULL;
4702 }
4703
4704
4705 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4706 PyObject *resultobj = 0;
4707 wxSize *arg1 = (wxSize *) 0 ;
4708 wxSize *arg2 = 0 ;
4709 wxSize result;
4710 void *argp1 = 0 ;
4711 int res1 = 0 ;
4712 wxSize temp2 ;
4713 PyObject * obj0 = 0 ;
4714 PyObject * obj1 = 0 ;
4715 char * kwnames[] = {
4716 (char *) "self",(char *) "sz", NULL
4717 };
4718
4719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4721 if (!SWIG_IsOK(res1)) {
4722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4723 }
4724 arg1 = reinterpret_cast< wxSize * >(argp1);
4725 {
4726 arg2 = &temp2;
4727 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4728 }
4729 {
4730 PyThreadState* __tstate = wxPyBeginAllowThreads();
4731 result = (arg1)->operator +((wxSize const &)*arg2);
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj = 0;
4744 wxSize *arg1 = (wxSize *) 0 ;
4745 wxSize *arg2 = 0 ;
4746 wxSize result;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 wxSize temp2 ;
4750 PyObject * obj0 = 0 ;
4751 PyObject * obj1 = 0 ;
4752 char * kwnames[] = {
4753 (char *) "self",(char *) "sz", NULL
4754 };
4755
4756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4758 if (!SWIG_IsOK(res1)) {
4759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4760 }
4761 arg1 = reinterpret_cast< wxSize * >(argp1);
4762 {
4763 arg2 = &temp2;
4764 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4765 }
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (arg1)->operator -((wxSize const &)*arg2);
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4773 return resultobj;
4774 fail:
4775 return NULL;
4776 }
4777
4778
4779 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4780 PyObject *resultobj = 0;
4781 wxSize *arg1 = (wxSize *) 0 ;
4782 wxSize *arg2 = 0 ;
4783 void *argp1 = 0 ;
4784 int res1 = 0 ;
4785 wxSize temp2 ;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 char * kwnames[] = {
4789 (char *) "self",(char *) "sz", NULL
4790 };
4791
4792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4794 if (!SWIG_IsOK(res1)) {
4795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4796 }
4797 arg1 = reinterpret_cast< wxSize * >(argp1);
4798 {
4799 arg2 = &temp2;
4800 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4801 }
4802 {
4803 PyThreadState* __tstate = wxPyBeginAllowThreads();
4804 (arg1)->IncTo((wxSize const &)*arg2);
4805 wxPyEndAllowThreads(__tstate);
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 resultobj = SWIG_Py_Void();
4809 return resultobj;
4810 fail:
4811 return NULL;
4812 }
4813
4814
4815 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4816 PyObject *resultobj = 0;
4817 wxSize *arg1 = (wxSize *) 0 ;
4818 wxSize *arg2 = 0 ;
4819 void *argp1 = 0 ;
4820 int res1 = 0 ;
4821 wxSize temp2 ;
4822 PyObject * obj0 = 0 ;
4823 PyObject * obj1 = 0 ;
4824 char * kwnames[] = {
4825 (char *) "self",(char *) "sz", NULL
4826 };
4827
4828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4830 if (!SWIG_IsOK(res1)) {
4831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4832 }
4833 arg1 = reinterpret_cast< wxSize * >(argp1);
4834 {
4835 arg2 = &temp2;
4836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4837 }
4838 {
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 (arg1)->DecTo((wxSize const &)*arg2);
4841 wxPyEndAllowThreads(__tstate);
4842 if (PyErr_Occurred()) SWIG_fail;
4843 }
4844 resultobj = SWIG_Py_Void();
4845 return resultobj;
4846 fail:
4847 return NULL;
4848 }
4849
4850
4851 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4852 PyObject *resultobj = 0;
4853 wxSize *arg1 = (wxSize *) 0 ;
4854 float arg2 ;
4855 float arg3 ;
4856 void *argp1 = 0 ;
4857 int res1 = 0 ;
4858 float val2 ;
4859 int ecode2 = 0 ;
4860 float val3 ;
4861 int ecode3 = 0 ;
4862 PyObject * obj0 = 0 ;
4863 PyObject * obj1 = 0 ;
4864 PyObject * obj2 = 0 ;
4865 char * kwnames[] = {
4866 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4867 };
4868
4869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4871 if (!SWIG_IsOK(res1)) {
4872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4873 }
4874 arg1 = reinterpret_cast< wxSize * >(argp1);
4875 ecode2 = SWIG_AsVal_float(obj1, &val2);
4876 if (!SWIG_IsOK(ecode2)) {
4877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4878 }
4879 arg2 = static_cast< float >(val2);
4880 ecode3 = SWIG_AsVal_float(obj2, &val3);
4881 if (!SWIG_IsOK(ecode3)) {
4882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4883 }
4884 arg3 = static_cast< float >(val3);
4885 {
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 (arg1)->Scale(arg2,arg3);
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 resultobj = SWIG_Py_Void();
4892 return resultobj;
4893 fail:
4894 return NULL;
4895 }
4896
4897
4898 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4899 PyObject *resultobj = 0;
4900 wxSize *arg1 = (wxSize *) 0 ;
4901 int arg2 ;
4902 int arg3 ;
4903 void *argp1 = 0 ;
4904 int res1 = 0 ;
4905 int val2 ;
4906 int ecode2 = 0 ;
4907 int val3 ;
4908 int ecode3 = 0 ;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 PyObject * obj2 = 0 ;
4912 char * kwnames[] = {
4913 (char *) "self",(char *) "w",(char *) "h", NULL
4914 };
4915
4916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4918 if (!SWIG_IsOK(res1)) {
4919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4920 }
4921 arg1 = reinterpret_cast< wxSize * >(argp1);
4922 ecode2 = SWIG_AsVal_int(obj1, &val2);
4923 if (!SWIG_IsOK(ecode2)) {
4924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4925 }
4926 arg2 = static_cast< int >(val2);
4927 ecode3 = SWIG_AsVal_int(obj2, &val3);
4928 if (!SWIG_IsOK(ecode3)) {
4929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4930 }
4931 arg3 = static_cast< int >(val3);
4932 {
4933 PyThreadState* __tstate = wxPyBeginAllowThreads();
4934 (arg1)->Set(arg2,arg3);
4935 wxPyEndAllowThreads(__tstate);
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 resultobj = SWIG_Py_Void();
4939 return resultobj;
4940 fail:
4941 return NULL;
4942 }
4943
4944
4945 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4946 PyObject *resultobj = 0;
4947 wxSize *arg1 = (wxSize *) 0 ;
4948 int arg2 ;
4949 void *argp1 = 0 ;
4950 int res1 = 0 ;
4951 int val2 ;
4952 int ecode2 = 0 ;
4953 PyObject * obj0 = 0 ;
4954 PyObject * obj1 = 0 ;
4955 char * kwnames[] = {
4956 (char *) "self",(char *) "w", NULL
4957 };
4958
4959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4961 if (!SWIG_IsOK(res1)) {
4962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4963 }
4964 arg1 = reinterpret_cast< wxSize * >(argp1);
4965 ecode2 = SWIG_AsVal_int(obj1, &val2);
4966 if (!SWIG_IsOK(ecode2)) {
4967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4968 }
4969 arg2 = static_cast< int >(val2);
4970 {
4971 PyThreadState* __tstate = wxPyBeginAllowThreads();
4972 (arg1)->SetWidth(arg2);
4973 wxPyEndAllowThreads(__tstate);
4974 if (PyErr_Occurred()) SWIG_fail;
4975 }
4976 resultobj = SWIG_Py_Void();
4977 return resultobj;
4978 fail:
4979 return NULL;
4980 }
4981
4982
4983 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4984 PyObject *resultobj = 0;
4985 wxSize *arg1 = (wxSize *) 0 ;
4986 int arg2 ;
4987 void *argp1 = 0 ;
4988 int res1 = 0 ;
4989 int val2 ;
4990 int ecode2 = 0 ;
4991 PyObject * obj0 = 0 ;
4992 PyObject * obj1 = 0 ;
4993 char * kwnames[] = {
4994 (char *) "self",(char *) "h", NULL
4995 };
4996
4997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4999 if (!SWIG_IsOK(res1)) {
5000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5001 }
5002 arg1 = reinterpret_cast< wxSize * >(argp1);
5003 ecode2 = SWIG_AsVal_int(obj1, &val2);
5004 if (!SWIG_IsOK(ecode2)) {
5005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5006 }
5007 arg2 = static_cast< int >(val2);
5008 {
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 (arg1)->SetHeight(arg2);
5011 wxPyEndAllowThreads(__tstate);
5012 if (PyErr_Occurred()) SWIG_fail;
5013 }
5014 resultobj = SWIG_Py_Void();
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5022 PyObject *resultobj = 0;
5023 wxSize *arg1 = (wxSize *) 0 ;
5024 int result;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 PyObject *swig_obj[1] ;
5028
5029 if (!args) SWIG_fail;
5030 swig_obj[0] = args;
5031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5034 }
5035 arg1 = reinterpret_cast< wxSize * >(argp1);
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (int)((wxSize const *)arg1)->GetWidth();
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 resultobj = SWIG_From_int(static_cast< int >(result));
5043 return resultobj;
5044 fail:
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5050 PyObject *resultobj = 0;
5051 wxSize *arg1 = (wxSize *) 0 ;
5052 int result;
5053 void *argp1 = 0 ;
5054 int res1 = 0 ;
5055 PyObject *swig_obj[1] ;
5056
5057 if (!args) SWIG_fail;
5058 swig_obj[0] = args;
5059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5062 }
5063 arg1 = reinterpret_cast< wxSize * >(argp1);
5064 {
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 result = (int)((wxSize const *)arg1)->GetHeight();
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 resultobj = SWIG_From_int(static_cast< int >(result));
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5078 PyObject *resultobj = 0;
5079 wxSize *arg1 = (wxSize *) 0 ;
5080 bool result;
5081 void *argp1 = 0 ;
5082 int res1 = 0 ;
5083 PyObject *swig_obj[1] ;
5084
5085 if (!args) SWIG_fail;
5086 swig_obj[0] = args;
5087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5088 if (!SWIG_IsOK(res1)) {
5089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5090 }
5091 arg1 = reinterpret_cast< wxSize * >(argp1);
5092 {
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 {
5099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5100 }
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5108 PyObject *resultobj = 0;
5109 wxSize *arg1 = (wxSize *) 0 ;
5110 wxSize *arg2 = 0 ;
5111 void *argp1 = 0 ;
5112 int res1 = 0 ;
5113 wxSize temp2 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char * kwnames[] = {
5117 (char *) "self",(char *) "size", NULL
5118 };
5119
5120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5122 if (!SWIG_IsOK(res1)) {
5123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5124 }
5125 arg1 = reinterpret_cast< wxSize * >(argp1);
5126 {
5127 arg2 = &temp2;
5128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5129 }
5130 {
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 (arg1)->SetDefaults((wxSize const &)*arg2);
5133 wxPyEndAllowThreads(__tstate);
5134 if (PyErr_Occurred()) SWIG_fail;
5135 }
5136 resultobj = SWIG_Py_Void();
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5144 PyObject *resultobj = 0;
5145 wxSize *arg1 = (wxSize *) 0 ;
5146 PyObject *result = 0 ;
5147 void *argp1 = 0 ;
5148 int res1 = 0 ;
5149 PyObject *swig_obj[1] ;
5150
5151 if (!args) SWIG_fail;
5152 swig_obj[0] = args;
5153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5154 if (!SWIG_IsOK(res1)) {
5155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5156 }
5157 arg1 = reinterpret_cast< wxSize * >(argp1);
5158 {
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 result = (PyObject *)wxSize_Get(arg1);
5161 wxPyEndAllowThreads(__tstate);
5162 if (PyErr_Occurred()) SWIG_fail;
5163 }
5164 resultobj = result;
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5172 PyObject *obj;
5173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5174 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5175 return SWIG_Py_Void();
5176 }
5177
5178 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5179 return SWIG_Python_InitShadowInstance(args);
5180 }
5181
5182 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 PyObject *resultobj = 0;
5184 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5185 double arg2 ;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 double val2 ;
5189 int ecode2 = 0 ;
5190 PyObject *swig_obj[2] ;
5191
5192 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5194 if (!SWIG_IsOK(res1)) {
5195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5196 }
5197 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5198 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5199 if (!SWIG_IsOK(ecode2)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5201 }
5202 arg2 = static_cast< double >(val2);
5203 if (arg1) (arg1)->x = arg2;
5204
5205 resultobj = SWIG_Py_Void();
5206 return resultobj;
5207 fail:
5208 return NULL;
5209 }
5210
5211
5212 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5213 PyObject *resultobj = 0;
5214 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5215 double result;
5216 void *argp1 = 0 ;
5217 int res1 = 0 ;
5218 PyObject *swig_obj[1] ;
5219
5220 if (!args) SWIG_fail;
5221 swig_obj[0] = args;
5222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5225 }
5226 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5227 result = (double) ((arg1)->x);
5228 resultobj = SWIG_From_double(static_cast< double >(result));
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5236 PyObject *resultobj = 0;
5237 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5238 double arg2 ;
5239 void *argp1 = 0 ;
5240 int res1 = 0 ;
5241 double val2 ;
5242 int ecode2 = 0 ;
5243 PyObject *swig_obj[2] ;
5244
5245 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5247 if (!SWIG_IsOK(res1)) {
5248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5249 }
5250 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5251 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5252 if (!SWIG_IsOK(ecode2)) {
5253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5254 }
5255 arg2 = static_cast< double >(val2);
5256 if (arg1) (arg1)->y = arg2;
5257
5258 resultobj = SWIG_Py_Void();
5259 return resultobj;
5260 fail:
5261 return NULL;
5262 }
5263
5264
5265 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5266 PyObject *resultobj = 0;
5267 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5268 double result;
5269 void *argp1 = 0 ;
5270 int res1 = 0 ;
5271 PyObject *swig_obj[1] ;
5272
5273 if (!args) SWIG_fail;
5274 swig_obj[0] = args;
5275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5276 if (!SWIG_IsOK(res1)) {
5277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5278 }
5279 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5280 result = (double) ((arg1)->y);
5281 resultobj = SWIG_From_double(static_cast< double >(result));
5282 return resultobj;
5283 fail:
5284 return NULL;
5285 }
5286
5287
5288 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5289 PyObject *resultobj = 0;
5290 double arg1 = (double) 0.0 ;
5291 double arg2 = (double) 0.0 ;
5292 wxRealPoint *result = 0 ;
5293 double val1 ;
5294 int ecode1 = 0 ;
5295 double val2 ;
5296 int ecode2 = 0 ;
5297 PyObject * obj0 = 0 ;
5298 PyObject * obj1 = 0 ;
5299 char * kwnames[] = {
5300 (char *) "x",(char *) "y", NULL
5301 };
5302
5303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5304 if (obj0) {
5305 ecode1 = SWIG_AsVal_double(obj0, &val1);
5306 if (!SWIG_IsOK(ecode1)) {
5307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5308 }
5309 arg1 = static_cast< double >(val1);
5310 }
5311 if (obj1) {
5312 ecode2 = SWIG_AsVal_double(obj1, &val2);
5313 if (!SWIG_IsOK(ecode2)) {
5314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5315 }
5316 arg2 = static_cast< double >(val2);
5317 }
5318 {
5319 PyThreadState* __tstate = wxPyBeginAllowThreads();
5320 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5321 wxPyEndAllowThreads(__tstate);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332 PyObject *resultobj = 0;
5333 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5334 void *argp1 = 0 ;
5335 int res1 = 0 ;
5336 PyObject *swig_obj[1] ;
5337
5338 if (!args) SWIG_fail;
5339 swig_obj[0] = args;
5340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5341 if (!SWIG_IsOK(res1)) {
5342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5343 }
5344 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 delete arg1;
5348
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 resultobj = SWIG_Py_Void();
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5360 PyObject *resultobj = 0;
5361 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5362 PyObject *arg2 = (PyObject *) 0 ;
5363 bool result;
5364 void *argp1 = 0 ;
5365 int res1 = 0 ;
5366 PyObject * obj0 = 0 ;
5367 PyObject * obj1 = 0 ;
5368 char * kwnames[] = {
5369 (char *) "self",(char *) "other", NULL
5370 };
5371
5372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5374 if (!SWIG_IsOK(res1)) {
5375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5376 }
5377 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5378 arg2 = obj1;
5379 {
5380 result = (bool)wxRealPoint___eq__(arg1,arg2);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 {
5384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5385 }
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5393 PyObject *resultobj = 0;
5394 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5395 PyObject *arg2 = (PyObject *) 0 ;
5396 bool result;
5397 void *argp1 = 0 ;
5398 int res1 = 0 ;
5399 PyObject * obj0 = 0 ;
5400 PyObject * obj1 = 0 ;
5401 char * kwnames[] = {
5402 (char *) "self",(char *) "other", NULL
5403 };
5404
5405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5407 if (!SWIG_IsOK(res1)) {
5408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5409 }
5410 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5411 arg2 = obj1;
5412 {
5413 result = (bool)wxRealPoint___ne__(arg1,arg2);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 {
5417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5418 }
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5426 PyObject *resultobj = 0;
5427 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5428 wxRealPoint *arg2 = 0 ;
5429 wxRealPoint result;
5430 void *argp1 = 0 ;
5431 int res1 = 0 ;
5432 wxRealPoint temp2 ;
5433 PyObject * obj0 = 0 ;
5434 PyObject * obj1 = 0 ;
5435 char * kwnames[] = {
5436 (char *) "self",(char *) "pt", NULL
5437 };
5438
5439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5441 if (!SWIG_IsOK(res1)) {
5442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5443 }
5444 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5445 {
5446 arg2 = &temp2;
5447 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5448 }
5449 {
5450 PyThreadState* __tstate = wxPyBeginAllowThreads();
5451 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5452 wxPyEndAllowThreads(__tstate);
5453 if (PyErr_Occurred()) SWIG_fail;
5454 }
5455 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5456 return resultobj;
5457 fail:
5458 return NULL;
5459 }
5460
5461
5462 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj = 0;
5464 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5465 wxRealPoint *arg2 = 0 ;
5466 wxRealPoint result;
5467 void *argp1 = 0 ;
5468 int res1 = 0 ;
5469 wxRealPoint temp2 ;
5470 PyObject * obj0 = 0 ;
5471 PyObject * obj1 = 0 ;
5472 char * kwnames[] = {
5473 (char *) "self",(char *) "pt", NULL
5474 };
5475
5476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5478 if (!SWIG_IsOK(res1)) {
5479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5480 }
5481 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5482 {
5483 arg2 = &temp2;
5484 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5485 }
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5500 PyObject *resultobj = 0;
5501 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5502 double arg2 ;
5503 double arg3 ;
5504 void *argp1 = 0 ;
5505 int res1 = 0 ;
5506 double val2 ;
5507 int ecode2 = 0 ;
5508 double val3 ;
5509 int ecode3 = 0 ;
5510 PyObject * obj0 = 0 ;
5511 PyObject * obj1 = 0 ;
5512 PyObject * obj2 = 0 ;
5513 char * kwnames[] = {
5514 (char *) "self",(char *) "x",(char *) "y", NULL
5515 };
5516
5517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5519 if (!SWIG_IsOK(res1)) {
5520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5521 }
5522 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5523 ecode2 = SWIG_AsVal_double(obj1, &val2);
5524 if (!SWIG_IsOK(ecode2)) {
5525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5526 }
5527 arg2 = static_cast< double >(val2);
5528 ecode3 = SWIG_AsVal_double(obj2, &val3);
5529 if (!SWIG_IsOK(ecode3)) {
5530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5531 }
5532 arg3 = static_cast< double >(val3);
5533 {
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 wxRealPoint_Set(arg1,arg2,arg3);
5536 wxPyEndAllowThreads(__tstate);
5537 if (PyErr_Occurred()) SWIG_fail;
5538 }
5539 resultobj = SWIG_Py_Void();
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
5546 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5547 PyObject *resultobj = 0;
5548 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5549 PyObject *result = 0 ;
5550 void *argp1 = 0 ;
5551 int res1 = 0 ;
5552 PyObject *swig_obj[1] ;
5553
5554 if (!args) SWIG_fail;
5555 swig_obj[0] = args;
5556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5557 if (!SWIG_IsOK(res1)) {
5558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5559 }
5560 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5561 {
5562 PyThreadState* __tstate = wxPyBeginAllowThreads();
5563 result = (PyObject *)wxRealPoint_Get(arg1);
5564 wxPyEndAllowThreads(__tstate);
5565 if (PyErr_Occurred()) SWIG_fail;
5566 }
5567 resultobj = result;
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *obj;
5576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5577 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5578 return SWIG_Py_Void();
5579 }
5580
5581 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5582 return SWIG_Python_InitShadowInstance(args);
5583 }
5584
5585 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 PyObject *resultobj = 0;
5587 wxPoint *arg1 = (wxPoint *) 0 ;
5588 int arg2 ;
5589 void *argp1 = 0 ;
5590 int res1 = 0 ;
5591 int val2 ;
5592 int ecode2 = 0 ;
5593 PyObject *swig_obj[2] ;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5597 if (!SWIG_IsOK(res1)) {
5598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5599 }
5600 arg1 = reinterpret_cast< wxPoint * >(argp1);
5601 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5602 if (!SWIG_IsOK(ecode2)) {
5603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5604 }
5605 arg2 = static_cast< int >(val2);
5606 if (arg1) (arg1)->x = arg2;
5607
5608 resultobj = SWIG_Py_Void();
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616 PyObject *resultobj = 0;
5617 wxPoint *arg1 = (wxPoint *) 0 ;
5618 int result;
5619 void *argp1 = 0 ;
5620 int res1 = 0 ;
5621 PyObject *swig_obj[1] ;
5622
5623 if (!args) SWIG_fail;
5624 swig_obj[0] = args;
5625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5626 if (!SWIG_IsOK(res1)) {
5627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5628 }
5629 arg1 = reinterpret_cast< wxPoint * >(argp1);
5630 result = (int) ((arg1)->x);
5631 resultobj = SWIG_From_int(static_cast< int >(result));
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5639 PyObject *resultobj = 0;
5640 wxPoint *arg1 = (wxPoint *) 0 ;
5641 int arg2 ;
5642 void *argp1 = 0 ;
5643 int res1 = 0 ;
5644 int val2 ;
5645 int ecode2 = 0 ;
5646 PyObject *swig_obj[2] ;
5647
5648 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5650 if (!SWIG_IsOK(res1)) {
5651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5652 }
5653 arg1 = reinterpret_cast< wxPoint * >(argp1);
5654 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5655 if (!SWIG_IsOK(ecode2)) {
5656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5657 }
5658 arg2 = static_cast< int >(val2);
5659 if (arg1) (arg1)->y = arg2;
5660
5661 resultobj = SWIG_Py_Void();
5662 return resultobj;
5663 fail:
5664 return NULL;
5665 }
5666
5667
5668 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5669 PyObject *resultobj = 0;
5670 wxPoint *arg1 = (wxPoint *) 0 ;
5671 int result;
5672 void *argp1 = 0 ;
5673 int res1 = 0 ;
5674 PyObject *swig_obj[1] ;
5675
5676 if (!args) SWIG_fail;
5677 swig_obj[0] = args;
5678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5679 if (!SWIG_IsOK(res1)) {
5680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5681 }
5682 arg1 = reinterpret_cast< wxPoint * >(argp1);
5683 result = (int) ((arg1)->y);
5684 resultobj = SWIG_From_int(static_cast< int >(result));
5685 return resultobj;
5686 fail:
5687 return NULL;
5688 }
5689
5690
5691 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5692 PyObject *resultobj = 0;
5693 int arg1 = (int) 0 ;
5694 int arg2 = (int) 0 ;
5695 wxPoint *result = 0 ;
5696 int val1 ;
5697 int ecode1 = 0 ;
5698 int val2 ;
5699 int ecode2 = 0 ;
5700 PyObject * obj0 = 0 ;
5701 PyObject * obj1 = 0 ;
5702 char * kwnames[] = {
5703 (char *) "x",(char *) "y", NULL
5704 };
5705
5706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5707 if (obj0) {
5708 ecode1 = SWIG_AsVal_int(obj0, &val1);
5709 if (!SWIG_IsOK(ecode1)) {
5710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5711 }
5712 arg1 = static_cast< int >(val1);
5713 }
5714 if (obj1) {
5715 ecode2 = SWIG_AsVal_int(obj1, &val2);
5716 if (!SWIG_IsOK(ecode2)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5718 }
5719 arg2 = static_cast< int >(val2);
5720 }
5721 {
5722 PyThreadState* __tstate = wxPyBeginAllowThreads();
5723 result = (wxPoint *)new wxPoint(arg1,arg2);
5724 wxPyEndAllowThreads(__tstate);
5725 if (PyErr_Occurred()) SWIG_fail;
5726 }
5727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5728 return resultobj;
5729 fail:
5730 return NULL;
5731 }
5732
5733
5734 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5735 PyObject *resultobj = 0;
5736 wxPoint *arg1 = (wxPoint *) 0 ;
5737 void *argp1 = 0 ;
5738 int res1 = 0 ;
5739 PyObject *swig_obj[1] ;
5740
5741 if (!args) SWIG_fail;
5742 swig_obj[0] = args;
5743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5744 if (!SWIG_IsOK(res1)) {
5745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5746 }
5747 arg1 = reinterpret_cast< wxPoint * >(argp1);
5748 {
5749 PyThreadState* __tstate = wxPyBeginAllowThreads();
5750 delete arg1;
5751
5752 wxPyEndAllowThreads(__tstate);
5753 if (PyErr_Occurred()) SWIG_fail;
5754 }
5755 resultobj = SWIG_Py_Void();
5756 return resultobj;
5757 fail:
5758 return NULL;
5759 }
5760
5761
5762 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5763 PyObject *resultobj = 0;
5764 wxPoint *arg1 = (wxPoint *) 0 ;
5765 PyObject *arg2 = (PyObject *) 0 ;
5766 bool result;
5767 void *argp1 = 0 ;
5768 int res1 = 0 ;
5769 PyObject * obj0 = 0 ;
5770 PyObject * obj1 = 0 ;
5771 char * kwnames[] = {
5772 (char *) "self",(char *) "other", NULL
5773 };
5774
5775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5777 if (!SWIG_IsOK(res1)) {
5778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5779 }
5780 arg1 = reinterpret_cast< wxPoint * >(argp1);
5781 arg2 = obj1;
5782 {
5783 result = (bool)wxPoint___eq__(arg1,arg2);
5784 if (PyErr_Occurred()) SWIG_fail;
5785 }
5786 {
5787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5788 }
5789 return resultobj;
5790 fail:
5791 return NULL;
5792 }
5793
5794
5795 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5796 PyObject *resultobj = 0;
5797 wxPoint *arg1 = (wxPoint *) 0 ;
5798 PyObject *arg2 = (PyObject *) 0 ;
5799 bool result;
5800 void *argp1 = 0 ;
5801 int res1 = 0 ;
5802 PyObject * obj0 = 0 ;
5803 PyObject * obj1 = 0 ;
5804 char * kwnames[] = {
5805 (char *) "self",(char *) "other", NULL
5806 };
5807
5808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5810 if (!SWIG_IsOK(res1)) {
5811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5812 }
5813 arg1 = reinterpret_cast< wxPoint * >(argp1);
5814 arg2 = obj1;
5815 {
5816 result = (bool)wxPoint___ne__(arg1,arg2);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 {
5820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5821 }
5822 return resultobj;
5823 fail:
5824 return NULL;
5825 }
5826
5827
5828 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5829 PyObject *resultobj = 0;
5830 wxPoint *arg1 = (wxPoint *) 0 ;
5831 wxPoint *arg2 = 0 ;
5832 wxPoint result;
5833 void *argp1 = 0 ;
5834 int res1 = 0 ;
5835 wxPoint temp2 ;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 char * kwnames[] = {
5839 (char *) "self",(char *) "pt", NULL
5840 };
5841
5842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5844 if (!SWIG_IsOK(res1)) {
5845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5846 }
5847 arg1 = reinterpret_cast< wxPoint * >(argp1);
5848 {
5849 arg2 = &temp2;
5850 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5851 }
5852 {
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 result = (arg1)->operator +((wxPoint const &)*arg2);
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj = 0;
5867 wxPoint *arg1 = (wxPoint *) 0 ;
5868 wxPoint *arg2 = 0 ;
5869 wxPoint result;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 wxPoint temp2 ;
5873 PyObject * obj0 = 0 ;
5874 PyObject * obj1 = 0 ;
5875 char * kwnames[] = {
5876 (char *) "self",(char *) "pt", NULL
5877 };
5878
5879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5881 if (!SWIG_IsOK(res1)) {
5882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5883 }
5884 arg1 = reinterpret_cast< wxPoint * >(argp1);
5885 {
5886 arg2 = &temp2;
5887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5888 }
5889 {
5890 PyThreadState* __tstate = wxPyBeginAllowThreads();
5891 result = (arg1)->operator -((wxPoint const &)*arg2);
5892 wxPyEndAllowThreads(__tstate);
5893 if (PyErr_Occurred()) SWIG_fail;
5894 }
5895 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj = 0;
5904 wxPoint *arg1 = (wxPoint *) 0 ;
5905 wxPoint *arg2 = 0 ;
5906 wxPoint *result = 0 ;
5907 void *argp1 = 0 ;
5908 int res1 = 0 ;
5909 wxPoint temp2 ;
5910 PyObject * obj0 = 0 ;
5911 PyObject * obj1 = 0 ;
5912 char * kwnames[] = {
5913 (char *) "self",(char *) "pt", NULL
5914 };
5915
5916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5918 if (!SWIG_IsOK(res1)) {
5919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5920 }
5921 arg1 = reinterpret_cast< wxPoint * >(argp1);
5922 {
5923 arg2 = &temp2;
5924 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5925 }
5926 {
5927 PyThreadState* __tstate = wxPyBeginAllowThreads();
5928 {
5929 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5930 result = (wxPoint *) &_result_ref;
5931 }
5932 wxPyEndAllowThreads(__tstate);
5933 if (PyErr_Occurred()) SWIG_fail;
5934 }
5935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5936 return resultobj;
5937 fail:
5938 return NULL;
5939 }
5940
5941
5942 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj = 0;
5944 wxPoint *arg1 = (wxPoint *) 0 ;
5945 wxPoint *arg2 = 0 ;
5946 wxPoint *result = 0 ;
5947 void *argp1 = 0 ;
5948 int res1 = 0 ;
5949 wxPoint temp2 ;
5950 PyObject * obj0 = 0 ;
5951 PyObject * obj1 = 0 ;
5952 char * kwnames[] = {
5953 (char *) "self",(char *) "pt", NULL
5954 };
5955
5956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5958 if (!SWIG_IsOK(res1)) {
5959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5960 }
5961 arg1 = reinterpret_cast< wxPoint * >(argp1);
5962 {
5963 arg2 = &temp2;
5964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5965 }
5966 {
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 {
5969 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5970 result = (wxPoint *) &_result_ref;
5971 }
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5983 PyObject *resultobj = 0;
5984 wxPoint *arg1 = (wxPoint *) 0 ;
5985 long arg2 ;
5986 long arg3 ;
5987 void *argp1 = 0 ;
5988 int res1 = 0 ;
5989 long val2 ;
5990 int ecode2 = 0 ;
5991 long val3 ;
5992 int ecode3 = 0 ;
5993 PyObject * obj0 = 0 ;
5994 PyObject * obj1 = 0 ;
5995 PyObject * obj2 = 0 ;
5996 char * kwnames[] = {
5997 (char *) "self",(char *) "x",(char *) "y", NULL
5998 };
5999
6000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6002 if (!SWIG_IsOK(res1)) {
6003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6004 }
6005 arg1 = reinterpret_cast< wxPoint * >(argp1);
6006 ecode2 = SWIG_AsVal_long(obj1, &val2);
6007 if (!SWIG_IsOK(ecode2)) {
6008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6009 }
6010 arg2 = static_cast< long >(val2);
6011 ecode3 = SWIG_AsVal_long(obj2, &val3);
6012 if (!SWIG_IsOK(ecode3)) {
6013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6014 }
6015 arg3 = static_cast< long >(val3);
6016 {
6017 PyThreadState* __tstate = wxPyBeginAllowThreads();
6018 wxPoint_Set(arg1,arg2,arg3);
6019 wxPyEndAllowThreads(__tstate);
6020 if (PyErr_Occurred()) SWIG_fail;
6021 }
6022 resultobj = SWIG_Py_Void();
6023 return resultobj;
6024 fail:
6025 return NULL;
6026 }
6027
6028
6029 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6030 PyObject *resultobj = 0;
6031 wxPoint *arg1 = (wxPoint *) 0 ;
6032 PyObject *result = 0 ;
6033 void *argp1 = 0 ;
6034 int res1 = 0 ;
6035 PyObject *swig_obj[1] ;
6036
6037 if (!args) SWIG_fail;
6038 swig_obj[0] = args;
6039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6040 if (!SWIG_IsOK(res1)) {
6041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6042 }
6043 arg1 = reinterpret_cast< wxPoint * >(argp1);
6044 {
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 result = (PyObject *)wxPoint_Get(arg1);
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 resultobj = result;
6051 return resultobj;
6052 fail:
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6058 PyObject *obj;
6059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6060 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6061 return SWIG_Py_Void();
6062 }
6063
6064 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6065 return SWIG_Python_InitShadowInstance(args);
6066 }
6067
6068 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6069 PyObject *resultobj = 0;
6070 int arg1 = (int) 0 ;
6071 int arg2 = (int) 0 ;
6072 int arg3 = (int) 0 ;
6073 int arg4 = (int) 0 ;
6074 wxRect *result = 0 ;
6075 int val1 ;
6076 int ecode1 = 0 ;
6077 int val2 ;
6078 int ecode2 = 0 ;
6079 int val3 ;
6080 int ecode3 = 0 ;
6081 int val4 ;
6082 int ecode4 = 0 ;
6083 PyObject * obj0 = 0 ;
6084 PyObject * obj1 = 0 ;
6085 PyObject * obj2 = 0 ;
6086 PyObject * obj3 = 0 ;
6087 char * kwnames[] = {
6088 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6089 };
6090
6091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6092 if (obj0) {
6093 ecode1 = SWIG_AsVal_int(obj0, &val1);
6094 if (!SWIG_IsOK(ecode1)) {
6095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6096 }
6097 arg1 = static_cast< int >(val1);
6098 }
6099 if (obj1) {
6100 ecode2 = SWIG_AsVal_int(obj1, &val2);
6101 if (!SWIG_IsOK(ecode2)) {
6102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6103 }
6104 arg2 = static_cast< int >(val2);
6105 }
6106 if (obj2) {
6107 ecode3 = SWIG_AsVal_int(obj2, &val3);
6108 if (!SWIG_IsOK(ecode3)) {
6109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6110 }
6111 arg3 = static_cast< int >(val3);
6112 }
6113 if (obj3) {
6114 ecode4 = SWIG_AsVal_int(obj3, &val4);
6115 if (!SWIG_IsOK(ecode4)) {
6116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6117 }
6118 arg4 = static_cast< int >(val4);
6119 }
6120 {
6121 PyThreadState* __tstate = wxPyBeginAllowThreads();
6122 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6123 wxPyEndAllowThreads(__tstate);
6124 if (PyErr_Occurred()) SWIG_fail;
6125 }
6126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6127 return resultobj;
6128 fail:
6129 return NULL;
6130 }
6131
6132
6133 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6134 PyObject *resultobj = 0;
6135 wxPoint *arg1 = 0 ;
6136 wxPoint *arg2 = 0 ;
6137 wxRect *result = 0 ;
6138 wxPoint temp1 ;
6139 wxPoint temp2 ;
6140 PyObject * obj0 = 0 ;
6141 PyObject * obj1 = 0 ;
6142 char * kwnames[] = {
6143 (char *) "topLeft",(char *) "bottomRight", NULL
6144 };
6145
6146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6147 {
6148 arg1 = &temp1;
6149 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6150 }
6151 {
6152 arg2 = &temp2;
6153 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6154 }
6155 {
6156 PyThreadState* __tstate = wxPyBeginAllowThreads();
6157 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6158 wxPyEndAllowThreads(__tstate);
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxPoint *arg1 = 0 ;
6171 wxSize *arg2 = 0 ;
6172 wxRect *result = 0 ;
6173 wxPoint temp1 ;
6174 wxSize temp2 ;
6175 PyObject * obj0 = 0 ;
6176 PyObject * obj1 = 0 ;
6177 char * kwnames[] = {
6178 (char *) "pos",(char *) "size", NULL
6179 };
6180
6181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6182 {
6183 arg1 = &temp1;
6184 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6185 }
6186 {
6187 arg2 = &temp2;
6188 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6189 }
6190 {
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj = 0;
6205 wxSize *arg1 = 0 ;
6206 wxRect *result = 0 ;
6207 wxSize temp1 ;
6208 PyObject * obj0 = 0 ;
6209 char * kwnames[] = {
6210 (char *) "size", NULL
6211 };
6212
6213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6214 {
6215 arg1 = &temp1;
6216 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6217 }
6218 {
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6225 return resultobj;
6226 fail:
6227 return NULL;
6228 }
6229
6230
6231 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6232 PyObject *resultobj = 0;
6233 wxRect *arg1 = (wxRect *) 0 ;
6234 void *argp1 = 0 ;
6235 int res1 = 0 ;
6236 PyObject *swig_obj[1] ;
6237
6238 if (!args) SWIG_fail;
6239 swig_obj[0] = args;
6240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6241 if (!SWIG_IsOK(res1)) {
6242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6243 }
6244 arg1 = reinterpret_cast< wxRect * >(argp1);
6245 {
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 delete arg1;
6248
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 resultobj = SWIG_Py_Void();
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6260 PyObject *resultobj = 0;
6261 wxRect *arg1 = (wxRect *) 0 ;
6262 int result;
6263 void *argp1 = 0 ;
6264 int res1 = 0 ;
6265 PyObject *swig_obj[1] ;
6266
6267 if (!args) SWIG_fail;
6268 swig_obj[0] = args;
6269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6270 if (!SWIG_IsOK(res1)) {
6271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6272 }
6273 arg1 = reinterpret_cast< wxRect * >(argp1);
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 result = (int)((wxRect const *)arg1)->GetX();
6277 wxPyEndAllowThreads(__tstate);
6278 if (PyErr_Occurred()) SWIG_fail;
6279 }
6280 resultobj = SWIG_From_int(static_cast< int >(result));
6281 return resultobj;
6282 fail:
6283 return NULL;
6284 }
6285
6286
6287 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj = 0;
6289 wxRect *arg1 = (wxRect *) 0 ;
6290 int arg2 ;
6291 void *argp1 = 0 ;
6292 int res1 = 0 ;
6293 int val2 ;
6294 int ecode2 = 0 ;
6295 PyObject * obj0 = 0 ;
6296 PyObject * obj1 = 0 ;
6297 char * kwnames[] = {
6298 (char *) "self",(char *) "x", NULL
6299 };
6300
6301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6303 if (!SWIG_IsOK(res1)) {
6304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6305 }
6306 arg1 = reinterpret_cast< wxRect * >(argp1);
6307 ecode2 = SWIG_AsVal_int(obj1, &val2);
6308 if (!SWIG_IsOK(ecode2)) {
6309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6310 }
6311 arg2 = static_cast< int >(val2);
6312 {
6313 PyThreadState* __tstate = wxPyBeginAllowThreads();
6314 (arg1)->SetX(arg2);
6315 wxPyEndAllowThreads(__tstate);
6316 if (PyErr_Occurred()) SWIG_fail;
6317 }
6318 resultobj = SWIG_Py_Void();
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6326 PyObject *resultobj = 0;
6327 wxRect *arg1 = (wxRect *) 0 ;
6328 int result;
6329 void *argp1 = 0 ;
6330 int res1 = 0 ;
6331 PyObject *swig_obj[1] ;
6332
6333 if (!args) SWIG_fail;
6334 swig_obj[0] = args;
6335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6336 if (!SWIG_IsOK(res1)) {
6337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6338 }
6339 arg1 = reinterpret_cast< wxRect * >(argp1);
6340 {
6341 PyThreadState* __tstate = wxPyBeginAllowThreads();
6342 result = (int)(arg1)->GetY();
6343 wxPyEndAllowThreads(__tstate);
6344 if (PyErr_Occurred()) SWIG_fail;
6345 }
6346 resultobj = SWIG_From_int(static_cast< int >(result));
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj = 0;
6355 wxRect *arg1 = (wxRect *) 0 ;
6356 int arg2 ;
6357 void *argp1 = 0 ;
6358 int res1 = 0 ;
6359 int val2 ;
6360 int ecode2 = 0 ;
6361 PyObject * obj0 = 0 ;
6362 PyObject * obj1 = 0 ;
6363 char * kwnames[] = {
6364 (char *) "self",(char *) "y", NULL
6365 };
6366
6367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6369 if (!SWIG_IsOK(res1)) {
6370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6371 }
6372 arg1 = reinterpret_cast< wxRect * >(argp1);
6373 ecode2 = SWIG_AsVal_int(obj1, &val2);
6374 if (!SWIG_IsOK(ecode2)) {
6375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6376 }
6377 arg2 = static_cast< int >(val2);
6378 {
6379 PyThreadState* __tstate = wxPyBeginAllowThreads();
6380 (arg1)->SetY(arg2);
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 resultobj = SWIG_Py_Void();
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6392 PyObject *resultobj = 0;
6393 wxRect *arg1 = (wxRect *) 0 ;
6394 int result;
6395 void *argp1 = 0 ;
6396 int res1 = 0 ;
6397 PyObject *swig_obj[1] ;
6398
6399 if (!args) SWIG_fail;
6400 swig_obj[0] = args;
6401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6402 if (!SWIG_IsOK(res1)) {
6403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6404 }
6405 arg1 = reinterpret_cast< wxRect * >(argp1);
6406 {
6407 PyThreadState* __tstate = wxPyBeginAllowThreads();
6408 result = (int)((wxRect const *)arg1)->GetWidth();
6409 wxPyEndAllowThreads(__tstate);
6410 if (PyErr_Occurred()) SWIG_fail;
6411 }
6412 resultobj = SWIG_From_int(static_cast< int >(result));
6413 return resultobj;
6414 fail:
6415 return NULL;
6416 }
6417
6418
6419 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6420 PyObject *resultobj = 0;
6421 wxRect *arg1 = (wxRect *) 0 ;
6422 int arg2 ;
6423 void *argp1 = 0 ;
6424 int res1 = 0 ;
6425 int val2 ;
6426 int ecode2 = 0 ;
6427 PyObject * obj0 = 0 ;
6428 PyObject * obj1 = 0 ;
6429 char * kwnames[] = {
6430 (char *) "self",(char *) "w", NULL
6431 };
6432
6433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6437 }
6438 arg1 = reinterpret_cast< wxRect * >(argp1);
6439 ecode2 = SWIG_AsVal_int(obj1, &val2);
6440 if (!SWIG_IsOK(ecode2)) {
6441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6442 }
6443 arg2 = static_cast< int >(val2);
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 (arg1)->SetWidth(arg2);
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 resultobj = SWIG_Py_Void();
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6458 PyObject *resultobj = 0;
6459 wxRect *arg1 = (wxRect *) 0 ;
6460 int result;
6461 void *argp1 = 0 ;
6462 int res1 = 0 ;
6463 PyObject *swig_obj[1] ;
6464
6465 if (!args) SWIG_fail;
6466 swig_obj[0] = args;
6467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6468 if (!SWIG_IsOK(res1)) {
6469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6470 }
6471 arg1 = reinterpret_cast< wxRect * >(argp1);
6472 {
6473 PyThreadState* __tstate = wxPyBeginAllowThreads();
6474 result = (int)((wxRect const *)arg1)->GetHeight();
6475 wxPyEndAllowThreads(__tstate);
6476 if (PyErr_Occurred()) SWIG_fail;
6477 }
6478 resultobj = SWIG_From_int(static_cast< int >(result));
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6486 PyObject *resultobj = 0;
6487 wxRect *arg1 = (wxRect *) 0 ;
6488 int arg2 ;
6489 void *argp1 = 0 ;
6490 int res1 = 0 ;
6491 int val2 ;
6492 int ecode2 = 0 ;
6493 PyObject * obj0 = 0 ;
6494 PyObject * obj1 = 0 ;
6495 char * kwnames[] = {
6496 (char *) "self",(char *) "h", NULL
6497 };
6498
6499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6501 if (!SWIG_IsOK(res1)) {
6502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6503 }
6504 arg1 = reinterpret_cast< wxRect * >(argp1);
6505 ecode2 = SWIG_AsVal_int(obj1, &val2);
6506 if (!SWIG_IsOK(ecode2)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6508 }
6509 arg2 = static_cast< int >(val2);
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 (arg1)->SetHeight(arg2);
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_Py_Void();
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6524 PyObject *resultobj = 0;
6525 wxRect *arg1 = (wxRect *) 0 ;
6526 wxPoint result;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 PyObject *swig_obj[1] ;
6530
6531 if (!args) SWIG_fail;
6532 swig_obj[0] = args;
6533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 result = ((wxRect const *)arg1)->GetPosition();
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj = 0;
6553 wxRect *arg1 = (wxRect *) 0 ;
6554 wxPoint *arg2 = 0 ;
6555 void *argp1 = 0 ;
6556 int res1 = 0 ;
6557 wxPoint temp2 ;
6558 PyObject * obj0 = 0 ;
6559 PyObject * obj1 = 0 ;
6560 char * kwnames[] = {
6561 (char *) "self",(char *) "p", NULL
6562 };
6563
6564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6566 if (!SWIG_IsOK(res1)) {
6567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6568 }
6569 arg1 = reinterpret_cast< wxRect * >(argp1);
6570 {
6571 arg2 = &temp2;
6572 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6573 }
6574 {
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 (arg1)->SetPosition((wxPoint const &)*arg2);
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 resultobj = SWIG_Py_Void();
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6588 PyObject *resultobj = 0;
6589 wxRect *arg1 = (wxRect *) 0 ;
6590 wxSize result;
6591 void *argp1 = 0 ;
6592 int res1 = 0 ;
6593 PyObject *swig_obj[1] ;
6594
6595 if (!args) SWIG_fail;
6596 swig_obj[0] = args;
6597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6598 if (!SWIG_IsOK(res1)) {
6599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6600 }
6601 arg1 = reinterpret_cast< wxRect * >(argp1);
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 result = ((wxRect const *)arg1)->GetSize();
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6609 return resultobj;
6610 fail:
6611 return NULL;
6612 }
6613
6614
6615 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6616 PyObject *resultobj = 0;
6617 wxRect *arg1 = (wxRect *) 0 ;
6618 wxSize *arg2 = 0 ;
6619 void *argp1 = 0 ;
6620 int res1 = 0 ;
6621 wxSize temp2 ;
6622 PyObject * obj0 = 0 ;
6623 PyObject * obj1 = 0 ;
6624 char * kwnames[] = {
6625 (char *) "self",(char *) "s", NULL
6626 };
6627
6628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6630 if (!SWIG_IsOK(res1)) {
6631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6632 }
6633 arg1 = reinterpret_cast< wxRect * >(argp1);
6634 {
6635 arg2 = &temp2;
6636 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6637 }
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 (arg1)->SetSize((wxSize const &)*arg2);
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 resultobj = SWIG_Py_Void();
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6652 PyObject *resultobj = 0;
6653 wxRect *arg1 = (wxRect *) 0 ;
6654 bool result;
6655 void *argp1 = 0 ;
6656 int res1 = 0 ;
6657 PyObject *swig_obj[1] ;
6658
6659 if (!args) SWIG_fail;
6660 swig_obj[0] = args;
6661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6662 if (!SWIG_IsOK(res1)) {
6663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6664 }
6665 arg1 = reinterpret_cast< wxRect * >(argp1);
6666 {
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 result = (bool)((wxRect const *)arg1)->IsEmpty();
6669 wxPyEndAllowThreads(__tstate);
6670 if (PyErr_Occurred()) SWIG_fail;
6671 }
6672 {
6673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6674 }
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6682 PyObject *resultobj = 0;
6683 wxRect *arg1 = (wxRect *) 0 ;
6684 wxPoint result;
6685 void *argp1 = 0 ;
6686 int res1 = 0 ;
6687 PyObject *swig_obj[1] ;
6688
6689 if (!args) SWIG_fail;
6690 swig_obj[0] = args;
6691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6692 if (!SWIG_IsOK(res1)) {
6693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6694 }
6695 arg1 = reinterpret_cast< wxRect * >(argp1);
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 result = ((wxRect const *)arg1)->GetTopLeft();
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj = 0;
6711 wxRect *arg1 = (wxRect *) 0 ;
6712 wxPoint *arg2 = 0 ;
6713 void *argp1 = 0 ;
6714 int res1 = 0 ;
6715 wxPoint temp2 ;
6716 PyObject * obj0 = 0 ;
6717 PyObject * obj1 = 0 ;
6718 char * kwnames[] = {
6719 (char *) "self",(char *) "p", NULL
6720 };
6721
6722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6726 }
6727 arg1 = reinterpret_cast< wxRect * >(argp1);
6728 {
6729 arg2 = &temp2;
6730 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6731 }
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6735 wxPyEndAllowThreads(__tstate);
6736 if (PyErr_Occurred()) SWIG_fail;
6737 }
6738 resultobj = SWIG_Py_Void();
6739 return resultobj;
6740 fail:
6741 return NULL;
6742 }
6743
6744
6745 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6746 PyObject *resultobj = 0;
6747 wxRect *arg1 = (wxRect *) 0 ;
6748 wxPoint result;
6749 void *argp1 = 0 ;
6750 int res1 = 0 ;
6751 PyObject *swig_obj[1] ;
6752
6753 if (!args) SWIG_fail;
6754 swig_obj[0] = args;
6755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6756 if (!SWIG_IsOK(res1)) {
6757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6758 }
6759 arg1 = reinterpret_cast< wxRect * >(argp1);
6760 {
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 result = ((wxRect const *)arg1)->GetBottomRight();
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6774 PyObject *resultobj = 0;
6775 wxRect *arg1 = (wxRect *) 0 ;
6776 wxPoint *arg2 = 0 ;
6777 void *argp1 = 0 ;
6778 int res1 = 0 ;
6779 wxPoint temp2 ;
6780 PyObject * obj0 = 0 ;
6781 PyObject * obj1 = 0 ;
6782 char * kwnames[] = {
6783 (char *) "self",(char *) "p", NULL
6784 };
6785
6786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6790 }
6791 arg1 = reinterpret_cast< wxRect * >(argp1);
6792 {
6793 arg2 = &temp2;
6794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6795 }
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_Py_Void();
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 int result;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 PyObject *swig_obj[1] ;
6816
6817 if (!args) SWIG_fail;
6818 swig_obj[0] = args;
6819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6820 if (!SWIG_IsOK(res1)) {
6821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6822 }
6823 arg1 = reinterpret_cast< wxRect * >(argp1);
6824 {
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (int)((wxRect const *)arg1)->GetLeft();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_From_int(static_cast< int >(result));
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 wxRect *arg1 = (wxRect *) 0 ;
6840 int result;
6841 void *argp1 = 0 ;
6842 int res1 = 0 ;
6843 PyObject *swig_obj[1] ;
6844
6845 if (!args) SWIG_fail;
6846 swig_obj[0] = args;
6847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6850 }
6851 arg1 = reinterpret_cast< wxRect * >(argp1);
6852 {
6853 PyThreadState* __tstate = wxPyBeginAllowThreads();
6854 result = (int)((wxRect const *)arg1)->GetTop();
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 resultobj = SWIG_From_int(static_cast< int >(result));
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6866 PyObject *resultobj = 0;
6867 wxRect *arg1 = (wxRect *) 0 ;
6868 int result;
6869 void *argp1 = 0 ;
6870 int res1 = 0 ;
6871 PyObject *swig_obj[1] ;
6872
6873 if (!args) SWIG_fail;
6874 swig_obj[0] = args;
6875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6876 if (!SWIG_IsOK(res1)) {
6877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6878 }
6879 arg1 = reinterpret_cast< wxRect * >(argp1);
6880 {
6881 PyThreadState* __tstate = wxPyBeginAllowThreads();
6882 result = (int)((wxRect const *)arg1)->GetBottom();
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 resultobj = SWIG_From_int(static_cast< int >(result));
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6894 PyObject *resultobj = 0;
6895 wxRect *arg1 = (wxRect *) 0 ;
6896 int result;
6897 void *argp1 = 0 ;
6898 int res1 = 0 ;
6899 PyObject *swig_obj[1] ;
6900
6901 if (!args) SWIG_fail;
6902 swig_obj[0] = args;
6903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6904 if (!SWIG_IsOK(res1)) {
6905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6906 }
6907 arg1 = reinterpret_cast< wxRect * >(argp1);
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 result = (int)((wxRect const *)arg1)->GetRight();
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_From_int(static_cast< int >(result));
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj = 0;
6923 wxRect *arg1 = (wxRect *) 0 ;
6924 int arg2 ;
6925 void *argp1 = 0 ;
6926 int res1 = 0 ;
6927 int val2 ;
6928 int ecode2 = 0 ;
6929 PyObject * obj0 = 0 ;
6930 PyObject * obj1 = 0 ;
6931 char * kwnames[] = {
6932 (char *) "self",(char *) "left", NULL
6933 };
6934
6935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6937 if (!SWIG_IsOK(res1)) {
6938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6939 }
6940 arg1 = reinterpret_cast< wxRect * >(argp1);
6941 ecode2 = SWIG_AsVal_int(obj1, &val2);
6942 if (!SWIG_IsOK(ecode2)) {
6943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6944 }
6945 arg2 = static_cast< int >(val2);
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 (arg1)->SetLeft(arg2);
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_Py_Void();
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj = 0;
6961 wxRect *arg1 = (wxRect *) 0 ;
6962 int arg2 ;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 int val2 ;
6966 int ecode2 = 0 ;
6967 PyObject * obj0 = 0 ;
6968 PyObject * obj1 = 0 ;
6969 char * kwnames[] = {
6970 (char *) "self",(char *) "right", NULL
6971 };
6972
6973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6977 }
6978 arg1 = reinterpret_cast< wxRect * >(argp1);
6979 ecode2 = SWIG_AsVal_int(obj1, &val2);
6980 if (!SWIG_IsOK(ecode2)) {
6981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6982 }
6983 arg2 = static_cast< int >(val2);
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 (arg1)->SetRight(arg2);
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 resultobj = SWIG_Py_Void();
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6998 PyObject *resultobj = 0;
6999 wxRect *arg1 = (wxRect *) 0 ;
7000 int arg2 ;
7001 void *argp1 = 0 ;
7002 int res1 = 0 ;
7003 int val2 ;
7004 int ecode2 = 0 ;
7005 PyObject * obj0 = 0 ;
7006 PyObject * obj1 = 0 ;
7007 char * kwnames[] = {
7008 (char *) "self",(char *) "top", NULL
7009 };
7010
7011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7013 if (!SWIG_IsOK(res1)) {
7014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7015 }
7016 arg1 = reinterpret_cast< wxRect * >(argp1);
7017 ecode2 = SWIG_AsVal_int(obj1, &val2);
7018 if (!SWIG_IsOK(ecode2)) {
7019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7020 }
7021 arg2 = static_cast< int >(val2);
7022 {
7023 PyThreadState* __tstate = wxPyBeginAllowThreads();
7024 (arg1)->SetTop(arg2);
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 resultobj = SWIG_Py_Void();
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj = 0;
7037 wxRect *arg1 = (wxRect *) 0 ;
7038 int arg2 ;
7039 void *argp1 = 0 ;
7040 int res1 = 0 ;
7041 int val2 ;
7042 int ecode2 = 0 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char * kwnames[] = {
7046 (char *) "self",(char *) "bottom", NULL
7047 };
7048
7049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7051 if (!SWIG_IsOK(res1)) {
7052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7053 }
7054 arg1 = reinterpret_cast< wxRect * >(argp1);
7055 ecode2 = SWIG_AsVal_int(obj1, &val2);
7056 if (!SWIG_IsOK(ecode2)) {
7057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7058 }
7059 arg2 = static_cast< int >(val2);
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 (arg1)->SetBottom(arg2);
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_Py_Void();
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj = 0;
7075 wxRect *arg1 = (wxRect *) 0 ;
7076 int arg2 ;
7077 int arg3 ;
7078 wxRect *result = 0 ;
7079 void *argp1 = 0 ;
7080 int res1 = 0 ;
7081 int val2 ;
7082 int ecode2 = 0 ;
7083 int val3 ;
7084 int ecode3 = 0 ;
7085 PyObject * obj0 = 0 ;
7086 PyObject * obj1 = 0 ;
7087 PyObject * obj2 = 0 ;
7088 char * kwnames[] = {
7089 (char *) "self",(char *) "dx",(char *) "dy", NULL
7090 };
7091
7092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7094 if (!SWIG_IsOK(res1)) {
7095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7096 }
7097 arg1 = reinterpret_cast< wxRect * >(argp1);
7098 ecode2 = SWIG_AsVal_int(obj1, &val2);
7099 if (!SWIG_IsOK(ecode2)) {
7100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7101 }
7102 arg2 = static_cast< int >(val2);
7103 ecode3 = SWIG_AsVal_int(obj2, &val3);
7104 if (!SWIG_IsOK(ecode3)) {
7105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7106 }
7107 arg3 = static_cast< int >(val3);
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 {
7111 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7112 result = (wxRect *) &_result_ref;
7113 }
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj = 0;
7126 wxRect *arg1 = (wxRect *) 0 ;
7127 int arg2 ;
7128 int arg3 ;
7129 wxRect *result = 0 ;
7130 void *argp1 = 0 ;
7131 int res1 = 0 ;
7132 int val2 ;
7133 int ecode2 = 0 ;
7134 int val3 ;
7135 int ecode3 = 0 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 PyObject * obj2 = 0 ;
7139 char * kwnames[] = {
7140 (char *) "self",(char *) "dx",(char *) "dy", NULL
7141 };
7142
7143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7147 }
7148 arg1 = reinterpret_cast< wxRect * >(argp1);
7149 ecode2 = SWIG_AsVal_int(obj1, &val2);
7150 if (!SWIG_IsOK(ecode2)) {
7151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7152 }
7153 arg2 = static_cast< int >(val2);
7154 ecode3 = SWIG_AsVal_int(obj2, &val3);
7155 if (!SWIG_IsOK(ecode3)) {
7156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7157 }
7158 arg3 = static_cast< int >(val3);
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 {
7162 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7163 result = (wxRect *) &_result_ref;
7164 }
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj = 0;
7177 wxRect *arg1 = (wxRect *) 0 ;
7178 int arg2 ;
7179 int arg3 ;
7180 void *argp1 = 0 ;
7181 int res1 = 0 ;
7182 int val2 ;
7183 int ecode2 = 0 ;
7184 int val3 ;
7185 int ecode3 = 0 ;
7186 PyObject * obj0 = 0 ;
7187 PyObject * obj1 = 0 ;
7188 PyObject * obj2 = 0 ;
7189 char * kwnames[] = {
7190 (char *) "self",(char *) "dx",(char *) "dy", NULL
7191 };
7192
7193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7195 if (!SWIG_IsOK(res1)) {
7196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7197 }
7198 arg1 = reinterpret_cast< wxRect * >(argp1);
7199 ecode2 = SWIG_AsVal_int(obj1, &val2);
7200 if (!SWIG_IsOK(ecode2)) {
7201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7202 }
7203 arg2 = static_cast< int >(val2);
7204 ecode3 = SWIG_AsVal_int(obj2, &val3);
7205 if (!SWIG_IsOK(ecode3)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7207 }
7208 arg3 = static_cast< int >(val3);
7209 {
7210 PyThreadState* __tstate = wxPyBeginAllowThreads();
7211 (arg1)->Offset(arg2,arg3);
7212 wxPyEndAllowThreads(__tstate);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_Py_Void();
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = 0;
7224 wxRect *arg1 = (wxRect *) 0 ;
7225 wxPoint *arg2 = 0 ;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 wxPoint temp2 ;
7229 PyObject * obj0 = 0 ;
7230 PyObject * obj1 = 0 ;
7231 char * kwnames[] = {
7232 (char *) "self",(char *) "pt", NULL
7233 };
7234
7235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7237 if (!SWIG_IsOK(res1)) {
7238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7239 }
7240 arg1 = reinterpret_cast< wxRect * >(argp1);
7241 {
7242 arg2 = &temp2;
7243 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7244 }
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 (arg1)->Offset((wxPoint const &)*arg2);
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 resultobj = SWIG_Py_Void();
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj = 0;
7260 wxRect *arg1 = (wxRect *) 0 ;
7261 wxRect *arg2 = 0 ;
7262 wxRect result;
7263 void *argp1 = 0 ;
7264 int res1 = 0 ;
7265 wxRect temp2 ;
7266 PyObject * obj0 = 0 ;
7267 PyObject * obj1 = 0 ;
7268 char * kwnames[] = {
7269 (char *) "self",(char *) "rect", NULL
7270 };
7271
7272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7274 if (!SWIG_IsOK(res1)) {
7275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7276 }
7277 arg1 = reinterpret_cast< wxRect * >(argp1);
7278 {
7279 arg2 = &temp2;
7280 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7281 }
7282 {
7283 PyThreadState* __tstate = wxPyBeginAllowThreads();
7284 result = (arg1)->Intersect((wxRect const &)*arg2);
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj = 0;
7297 wxRect *arg1 = (wxRect *) 0 ;
7298 wxRect *arg2 = 0 ;
7299 wxRect result;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 wxRect temp2 ;
7303 PyObject * obj0 = 0 ;
7304 PyObject * obj1 = 0 ;
7305 char * kwnames[] = {
7306 (char *) "self",(char *) "rect", NULL
7307 };
7308
7309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7311 if (!SWIG_IsOK(res1)) {
7312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7313 }
7314 arg1 = reinterpret_cast< wxRect * >(argp1);
7315 {
7316 arg2 = &temp2;
7317 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7318 }
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (arg1)->Union((wxRect const &)*arg2);
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj = 0;
7334 wxRect *arg1 = (wxRect *) 0 ;
7335 wxRect *arg2 = 0 ;
7336 wxRect result;
7337 void *argp1 = 0 ;
7338 int res1 = 0 ;
7339 wxRect temp2 ;
7340 PyObject * obj0 = 0 ;
7341 PyObject * obj1 = 0 ;
7342 char * kwnames[] = {
7343 (char *) "self",(char *) "rect", NULL
7344 };
7345
7346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7350 }
7351 arg1 = reinterpret_cast< wxRect * >(argp1);
7352 {
7353 arg2 = &temp2;
7354 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7355 }
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7359 wxPyEndAllowThreads(__tstate);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 wxRect *arg2 = 0 ;
7373 wxRect *result = 0 ;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 wxRect temp2 ;
7377 PyObject * obj0 = 0 ;
7378 PyObject * obj1 = 0 ;
7379 char * kwnames[] = {
7380 (char *) "self",(char *) "rect", NULL
7381 };
7382
7383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7387 }
7388 arg1 = reinterpret_cast< wxRect * >(argp1);
7389 {
7390 arg2 = &temp2;
7391 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7392 }
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 {
7396 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7397 result = (wxRect *) &_result_ref;
7398 }
7399 wxPyEndAllowThreads(__tstate);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj = 0;
7411 wxRect *arg1 = (wxRect *) 0 ;
7412 PyObject *arg2 = (PyObject *) 0 ;
7413 bool result;
7414 void *argp1 = 0 ;
7415 int res1 = 0 ;
7416 PyObject * obj0 = 0 ;
7417 PyObject * obj1 = 0 ;
7418 char * kwnames[] = {
7419 (char *) "self",(char *) "other", NULL
7420 };
7421
7422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7424 if (!SWIG_IsOK(res1)) {
7425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7426 }
7427 arg1 = reinterpret_cast< wxRect * >(argp1);
7428 arg2 = obj1;
7429 {
7430 result = (bool)wxRect___eq__(arg1,arg2);
7431 if (PyErr_Occurred()) SWIG_fail;
7432 }
7433 {
7434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7435 }
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj = 0;
7444 wxRect *arg1 = (wxRect *) 0 ;
7445 PyObject *arg2 = (PyObject *) 0 ;
7446 bool result;
7447 void *argp1 = 0 ;
7448 int res1 = 0 ;
7449 PyObject * obj0 = 0 ;
7450 PyObject * obj1 = 0 ;
7451 char * kwnames[] = {
7452 (char *) "self",(char *) "other", NULL
7453 };
7454
7455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7459 }
7460 arg1 = reinterpret_cast< wxRect * >(argp1);
7461 arg2 = obj1;
7462 {
7463 result = (bool)wxRect___ne__(arg1,arg2);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 {
7467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7468 }
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj = 0;
7477 wxRect *arg1 = (wxRect *) 0 ;
7478 int arg2 ;
7479 int arg3 ;
7480 bool result;
7481 void *argp1 = 0 ;
7482 int res1 = 0 ;
7483 int val2 ;
7484 int ecode2 = 0 ;
7485 int val3 ;
7486 int ecode3 = 0 ;
7487 PyObject * obj0 = 0 ;
7488 PyObject * obj1 = 0 ;
7489 PyObject * obj2 = 0 ;
7490 char * kwnames[] = {
7491 (char *) "self",(char *) "x",(char *) "y", NULL
7492 };
7493
7494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7496 if (!SWIG_IsOK(res1)) {
7497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7498 }
7499 arg1 = reinterpret_cast< wxRect * >(argp1);
7500 ecode2 = SWIG_AsVal_int(obj1, &val2);
7501 if (!SWIG_IsOK(ecode2)) {
7502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7503 }
7504 arg2 = static_cast< int >(val2);
7505 ecode3 = SWIG_AsVal_int(obj2, &val3);
7506 if (!SWIG_IsOK(ecode3)) {
7507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7508 }
7509 arg3 = static_cast< int >(val3);
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 {
7517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7518 }
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj = 0;
7527 wxRect *arg1 = (wxRect *) 0 ;
7528 wxPoint *arg2 = 0 ;
7529 bool result;
7530 void *argp1 = 0 ;
7531 int res1 = 0 ;
7532 wxPoint temp2 ;
7533 PyObject * obj0 = 0 ;
7534 PyObject * obj1 = 0 ;
7535 char * kwnames[] = {
7536 (char *) "self",(char *) "pt", NULL
7537 };
7538
7539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7541 if (!SWIG_IsOK(res1)) {
7542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7543 }
7544 arg1 = reinterpret_cast< wxRect * >(argp1);
7545 {
7546 arg2 = &temp2;
7547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7548 }
7549 {
7550 PyThreadState* __tstate = wxPyBeginAllowThreads();
7551 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7552 wxPyEndAllowThreads(__tstate);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 {
7556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7557 }
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj = 0;
7566 wxRect *arg1 = (wxRect *) 0 ;
7567 wxRect *arg2 = 0 ;
7568 bool result;
7569 void *argp1 = 0 ;
7570 int res1 = 0 ;
7571 wxRect temp2 ;
7572 PyObject * obj0 = 0 ;
7573 PyObject * obj1 = 0 ;
7574 char * kwnames[] = {
7575 (char *) "self",(char *) "rect", NULL
7576 };
7577
7578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7580 if (!SWIG_IsOK(res1)) {
7581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7582 }
7583 arg1 = reinterpret_cast< wxRect * >(argp1);
7584 {
7585 arg2 = &temp2;
7586 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7587 }
7588 {
7589 PyThreadState* __tstate = wxPyBeginAllowThreads();
7590 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7591 wxPyEndAllowThreads(__tstate);
7592 if (PyErr_Occurred()) SWIG_fail;
7593 }
7594 {
7595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7596 }
7597 return resultobj;
7598 fail:
7599 return NULL;
7600 }
7601
7602
7603 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7604 PyObject *resultobj = 0;
7605 wxRect *arg1 = (wxRect *) 0 ;
7606 wxRect *arg2 = 0 ;
7607 int arg3 = (int) wxBOTH ;
7608 wxRect result;
7609 void *argp1 = 0 ;
7610 int res1 = 0 ;
7611 wxRect temp2 ;
7612 int val3 ;
7613 int ecode3 = 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 PyObject * obj2 = 0 ;
7617 char * kwnames[] = {
7618 (char *) "self",(char *) "r",(char *) "dir", NULL
7619 };
7620
7621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7623 if (!SWIG_IsOK(res1)) {
7624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7625 }
7626 arg1 = reinterpret_cast< wxRect * >(argp1);
7627 {
7628 arg2 = &temp2;
7629 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7630 }
7631 if (obj2) {
7632 ecode3 = SWIG_AsVal_int(obj2, &val3);
7633 if (!SWIG_IsOK(ecode3)) {
7634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7635 }
7636 arg3 = static_cast< int >(val3);
7637 }
7638 {
7639 PyThreadState* __tstate = wxPyBeginAllowThreads();
7640 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7652 PyObject *resultobj = 0;
7653 wxRect *arg1 = (wxRect *) 0 ;
7654 int arg2 ;
7655 void *argp1 = 0 ;
7656 int res1 = 0 ;
7657 int val2 ;
7658 int ecode2 = 0 ;
7659 PyObject *swig_obj[2] ;
7660
7661 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7668 if (!SWIG_IsOK(ecode2)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7670 }
7671 arg2 = static_cast< int >(val2);
7672 if (arg1) (arg1)->x = arg2;
7673
7674 resultobj = SWIG_Py_Void();
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7682 PyObject *resultobj = 0;
7683 wxRect *arg1 = (wxRect *) 0 ;
7684 int result;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject *swig_obj[1] ;
7688
7689 if (!args) SWIG_fail;
7690 swig_obj[0] = args;
7691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7692 if (!SWIG_IsOK(res1)) {
7693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7694 }
7695 arg1 = reinterpret_cast< wxRect * >(argp1);
7696 result = (int) ((arg1)->x);
7697 resultobj = SWIG_From_int(static_cast< int >(result));
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7705 PyObject *resultobj = 0;
7706 wxRect *arg1 = (wxRect *) 0 ;
7707 int arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 PyObject *swig_obj[2] ;
7713
7714 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7718 }
7719 arg1 = reinterpret_cast< wxRect * >(argp1);
7720 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 if (arg1) (arg1)->y = arg2;
7726
7727 resultobj = SWIG_Py_Void();
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7735 PyObject *resultobj = 0;
7736 wxRect *arg1 = (wxRect *) 0 ;
7737 int result;
7738 void *argp1 = 0 ;
7739 int res1 = 0 ;
7740 PyObject *swig_obj[1] ;
7741
7742 if (!args) SWIG_fail;
7743 swig_obj[0] = args;
7744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7745 if (!SWIG_IsOK(res1)) {
7746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7747 }
7748 arg1 = reinterpret_cast< wxRect * >(argp1);
7749 result = (int) ((arg1)->y);
7750 resultobj = SWIG_From_int(static_cast< int >(result));
7751 return resultobj;
7752 fail:
7753 return NULL;
7754 }
7755
7756
7757 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7758 PyObject *resultobj = 0;
7759 wxRect *arg1 = (wxRect *) 0 ;
7760 int arg2 ;
7761 void *argp1 = 0 ;
7762 int res1 = 0 ;
7763 int val2 ;
7764 int ecode2 = 0 ;
7765 PyObject *swig_obj[2] ;
7766
7767 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7769 if (!SWIG_IsOK(res1)) {
7770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7771 }
7772 arg1 = reinterpret_cast< wxRect * >(argp1);
7773 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7774 if (!SWIG_IsOK(ecode2)) {
7775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7776 }
7777 arg2 = static_cast< int >(val2);
7778 if (arg1) (arg1)->width = arg2;
7779
7780 resultobj = SWIG_Py_Void();
7781 return resultobj;
7782 fail:
7783 return NULL;
7784 }
7785
7786
7787 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7788 PyObject *resultobj = 0;
7789 wxRect *arg1 = (wxRect *) 0 ;
7790 int result;
7791 void *argp1 = 0 ;
7792 int res1 = 0 ;
7793 PyObject *swig_obj[1] ;
7794
7795 if (!args) SWIG_fail;
7796 swig_obj[0] = args;
7797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7798 if (!SWIG_IsOK(res1)) {
7799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7800 }
7801 arg1 = reinterpret_cast< wxRect * >(argp1);
7802 result = (int) ((arg1)->width);
7803 resultobj = SWIG_From_int(static_cast< int >(result));
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7811 PyObject *resultobj = 0;
7812 wxRect *arg1 = (wxRect *) 0 ;
7813 int arg2 ;
7814 void *argp1 = 0 ;
7815 int res1 = 0 ;
7816 int val2 ;
7817 int ecode2 = 0 ;
7818 PyObject *swig_obj[2] ;
7819
7820 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7822 if (!SWIG_IsOK(res1)) {
7823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7824 }
7825 arg1 = reinterpret_cast< wxRect * >(argp1);
7826 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7827 if (!SWIG_IsOK(ecode2)) {
7828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7829 }
7830 arg2 = static_cast< int >(val2);
7831 if (arg1) (arg1)->height = arg2;
7832
7833 resultobj = SWIG_Py_Void();
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7841 PyObject *resultobj = 0;
7842 wxRect *arg1 = (wxRect *) 0 ;
7843 int result;
7844 void *argp1 = 0 ;
7845 int res1 = 0 ;
7846 PyObject *swig_obj[1] ;
7847
7848 if (!args) SWIG_fail;
7849 swig_obj[0] = args;
7850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7851 if (!SWIG_IsOK(res1)) {
7852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7853 }
7854 arg1 = reinterpret_cast< wxRect * >(argp1);
7855 result = (int) ((arg1)->height);
7856 resultobj = SWIG_From_int(static_cast< int >(result));
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7864 PyObject *resultobj = 0;
7865 wxRect *arg1 = (wxRect *) 0 ;
7866 int arg2 = (int) 0 ;
7867 int arg3 = (int) 0 ;
7868 int arg4 = (int) 0 ;
7869 int arg5 = (int) 0 ;
7870 void *argp1 = 0 ;
7871 int res1 = 0 ;
7872 int val2 ;
7873 int ecode2 = 0 ;
7874 int val3 ;
7875 int ecode3 = 0 ;
7876 int val4 ;
7877 int ecode4 = 0 ;
7878 int val5 ;
7879 int ecode5 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 PyObject * obj2 = 0 ;
7883 PyObject * obj3 = 0 ;
7884 PyObject * obj4 = 0 ;
7885 char * kwnames[] = {
7886 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7887 };
7888
7889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7891 if (!SWIG_IsOK(res1)) {
7892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7893 }
7894 arg1 = reinterpret_cast< wxRect * >(argp1);
7895 if (obj1) {
7896 ecode2 = SWIG_AsVal_int(obj1, &val2);
7897 if (!SWIG_IsOK(ecode2)) {
7898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7899 }
7900 arg2 = static_cast< int >(val2);
7901 }
7902 if (obj2) {
7903 ecode3 = SWIG_AsVal_int(obj2, &val3);
7904 if (!SWIG_IsOK(ecode3)) {
7905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7906 }
7907 arg3 = static_cast< int >(val3);
7908 }
7909 if (obj3) {
7910 ecode4 = SWIG_AsVal_int(obj3, &val4);
7911 if (!SWIG_IsOK(ecode4)) {
7912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7913 }
7914 arg4 = static_cast< int >(val4);
7915 }
7916 if (obj4) {
7917 ecode5 = SWIG_AsVal_int(obj4, &val5);
7918 if (!SWIG_IsOK(ecode5)) {
7919 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7920 }
7921 arg5 = static_cast< int >(val5);
7922 }
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 resultobj = SWIG_Py_Void();
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7937 PyObject *resultobj = 0;
7938 wxRect *arg1 = (wxRect *) 0 ;
7939 PyObject *result = 0 ;
7940 void *argp1 = 0 ;
7941 int res1 = 0 ;
7942 PyObject *swig_obj[1] ;
7943
7944 if (!args) SWIG_fail;
7945 swig_obj[0] = args;
7946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7947 if (!SWIG_IsOK(res1)) {
7948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7949 }
7950 arg1 = reinterpret_cast< wxRect * >(argp1);
7951 {
7952 PyThreadState* __tstate = wxPyBeginAllowThreads();
7953 result = (PyObject *)wxRect_Get(arg1);
7954 wxPyEndAllowThreads(__tstate);
7955 if (PyErr_Occurred()) SWIG_fail;
7956 }
7957 resultobj = result;
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7965 PyObject *obj;
7966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7967 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7968 return SWIG_Py_Void();
7969 }
7970
7971 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 return SWIG_Python_InitShadowInstance(args);
7973 }
7974
7975 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7976 PyObject *resultobj = 0;
7977 wxRect *arg1 = (wxRect *) 0 ;
7978 wxRect *arg2 = (wxRect *) 0 ;
7979 PyObject *result = 0 ;
7980 void *argp1 = 0 ;
7981 int res1 = 0 ;
7982 void *argp2 = 0 ;
7983 int res2 = 0 ;
7984 PyObject * obj0 = 0 ;
7985 PyObject * obj1 = 0 ;
7986 char * kwnames[] = {
7987 (char *) "r1",(char *) "r2", NULL
7988 };
7989
7990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7994 }
7995 arg1 = reinterpret_cast< wxRect * >(argp1);
7996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7997 if (!SWIG_IsOK(res2)) {
7998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7999 }
8000 arg2 = reinterpret_cast< wxRect * >(argp2);
8001 {
8002 if (!wxPyCheckForApp()) SWIG_fail;
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 result = (PyObject *)wxIntersectRect(arg1,arg2);
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 resultobj = result;
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj = 0;
8017 double arg1 = (double) 0.0 ;
8018 double arg2 = (double) 0.0 ;
8019 wxPoint2D *result = 0 ;
8020 double val1 ;
8021 int ecode1 = 0 ;
8022 double val2 ;
8023 int ecode2 = 0 ;
8024 PyObject * obj0 = 0 ;
8025 PyObject * obj1 = 0 ;
8026 char * kwnames[] = {
8027 (char *) "x",(char *) "y", NULL
8028 };
8029
8030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8031 if (obj0) {
8032 ecode1 = SWIG_AsVal_double(obj0, &val1);
8033 if (!SWIG_IsOK(ecode1)) {
8034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8035 }
8036 arg1 = static_cast< double >(val1);
8037 }
8038 if (obj1) {
8039 ecode2 = SWIG_AsVal_double(obj1, &val2);
8040 if (!SWIG_IsOK(ecode2)) {
8041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8042 }
8043 arg2 = static_cast< double >(val2);
8044 }
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8059 PyObject *resultobj = 0;
8060 wxPoint2D *arg1 = 0 ;
8061 wxPoint2D *result = 0 ;
8062 wxPoint2D temp1 ;
8063 PyObject * obj0 = 0 ;
8064 char * kwnames[] = {
8065 (char *) "pt", NULL
8066 };
8067
8068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8069 {
8070 arg1 = &temp1;
8071 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8072 }
8073 {
8074 PyThreadState* __tstate = wxPyBeginAllowThreads();
8075 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj = 0;
8088 wxPoint *arg1 = 0 ;
8089 wxPoint2D *result = 0 ;
8090 wxPoint temp1 ;
8091 PyObject * obj0 = 0 ;
8092 char * kwnames[] = {
8093 (char *) "pt", NULL
8094 };
8095
8096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8097 {
8098 arg1 = &temp1;
8099 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8100 }
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8115 PyObject *resultobj = 0;
8116 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8117 int *arg2 = (int *) 0 ;
8118 int *arg3 = (int *) 0 ;
8119 void *argp1 = 0 ;
8120 int res1 = 0 ;
8121 int temp2 ;
8122 int res2 = SWIG_TMPOBJ ;
8123 int temp3 ;
8124 int res3 = SWIG_TMPOBJ ;
8125 PyObject *swig_obj[1] ;
8126
8127 arg2 = &temp2;
8128 arg3 = &temp3;
8129 if (!args) SWIG_fail;
8130 swig_obj[0] = args;
8131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8132 if (!SWIG_IsOK(res1)) {
8133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8134 }
8135 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = SWIG_Py_Void();
8143 if (SWIG_IsTmpObj(res2)) {
8144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8145 } else {
8146 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8148 }
8149 if (SWIG_IsTmpObj(res3)) {
8150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8151 } else {
8152 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8154 }
8155 return resultobj;
8156 fail:
8157 return NULL;
8158 }
8159
8160
8161 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 PyObject *resultobj = 0;
8163 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8164 int *arg2 = (int *) 0 ;
8165 int *arg3 = (int *) 0 ;
8166 void *argp1 = 0 ;
8167 int res1 = 0 ;
8168 int temp2 ;
8169 int res2 = SWIG_TMPOBJ ;
8170 int temp3 ;
8171 int res3 = SWIG_TMPOBJ ;
8172 PyObject *swig_obj[1] ;
8173
8174 arg2 = &temp2;
8175 arg3 = &temp3;
8176 if (!args) SWIG_fail;
8177 swig_obj[0] = args;
8178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8179 if (!SWIG_IsOK(res1)) {
8180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8181 }
8182 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8183 {
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 resultobj = SWIG_Py_Void();
8190 if (SWIG_IsTmpObj(res2)) {
8191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8192 } else {
8193 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8195 }
8196 if (SWIG_IsTmpObj(res3)) {
8197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8198 } else {
8199 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8201 }
8202 return resultobj;
8203 fail:
8204 return NULL;
8205 }
8206
8207
8208 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8209 PyObject *resultobj = 0;
8210 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8211 double result;
8212 void *argp1 = 0 ;
8213 int res1 = 0 ;
8214 PyObject *swig_obj[1] ;
8215
8216 if (!args) SWIG_fail;
8217 swig_obj[0] = args;
8218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8219 if (!SWIG_IsOK(res1)) {
8220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8221 }
8222 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8223 {
8224 PyThreadState* __tstate = wxPyBeginAllowThreads();
8225 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8226 wxPyEndAllowThreads(__tstate);
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 resultobj = SWIG_From_double(static_cast< double >(result));
8230 return resultobj;
8231 fail:
8232 return NULL;
8233 }
8234
8235
8236 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8237 PyObject *resultobj = 0;
8238 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8239 double result;
8240 void *argp1 = 0 ;
8241 int res1 = 0 ;
8242 PyObject *swig_obj[1] ;
8243
8244 if (!args) SWIG_fail;
8245 swig_obj[0] = args;
8246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8247 if (!SWIG_IsOK(res1)) {
8248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8249 }
8250 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8251 {
8252 PyThreadState* __tstate = wxPyBeginAllowThreads();
8253 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_From_double(static_cast< double >(result));
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj = 0;
8266 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8267 double arg2 ;
8268 void *argp1 = 0 ;
8269 int res1 = 0 ;
8270 double val2 ;
8271 int ecode2 = 0 ;
8272 PyObject * obj0 = 0 ;
8273 PyObject * obj1 = 0 ;
8274 char * kwnames[] = {
8275 (char *) "self",(char *) "length", NULL
8276 };
8277
8278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8280 if (!SWIG_IsOK(res1)) {
8281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8282 }
8283 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8284 ecode2 = SWIG_AsVal_double(obj1, &val2);
8285 if (!SWIG_IsOK(ecode2)) {
8286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8287 }
8288 arg2 = static_cast< double >(val2);
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 (arg1)->SetVectorLength(arg2);
8292 wxPyEndAllowThreads(__tstate);
8293 if (PyErr_Occurred()) SWIG_fail;
8294 }
8295 resultobj = SWIG_Py_Void();
8296 return resultobj;
8297 fail:
8298 return NULL;
8299 }
8300
8301
8302 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8303 PyObject *resultobj = 0;
8304 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8305 double arg2 ;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 double val2 ;
8309 int ecode2 = 0 ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char * kwnames[] = {
8313 (char *) "self",(char *) "degrees", NULL
8314 };
8315
8316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8318 if (!SWIG_IsOK(res1)) {
8319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8320 }
8321 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8322 ecode2 = SWIG_AsVal_double(obj1, &val2);
8323 if (!SWIG_IsOK(ecode2)) {
8324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8325 }
8326 arg2 = static_cast< double >(val2);
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 (arg1)->SetVectorAngle(arg2);
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_Py_Void();
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8343 wxPoint2D *arg2 = 0 ;
8344 double result;
8345 void *argp1 = 0 ;
8346 int res1 = 0 ;
8347 wxPoint2D temp2 ;
8348 PyObject * obj0 = 0 ;
8349 PyObject * obj1 = 0 ;
8350 char * kwnames[] = {
8351 (char *) "self",(char *) "pt", NULL
8352 };
8353
8354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8356 if (!SWIG_IsOK(res1)) {
8357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8358 }
8359 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8360 {
8361 arg2 = &temp2;
8362 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8363 }
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 resultobj = SWIG_From_double(static_cast< double >(result));
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj = 0;
8379 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8380 wxPoint2D *arg2 = 0 ;
8381 double result;
8382 void *argp1 = 0 ;
8383 int res1 = 0 ;
8384 wxPoint2D temp2 ;
8385 PyObject * obj0 = 0 ;
8386 PyObject * obj1 = 0 ;
8387 char * kwnames[] = {
8388 (char *) "self",(char *) "pt", NULL
8389 };
8390
8391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8393 if (!SWIG_IsOK(res1)) {
8394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8395 }
8396 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8397 {
8398 arg2 = &temp2;
8399 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8400 }
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8404 wxPyEndAllowThreads(__tstate);
8405 if (PyErr_Occurred()) SWIG_fail;
8406 }
8407 resultobj = SWIG_From_double(static_cast< double >(result));
8408 return resultobj;
8409 fail:
8410 return NULL;
8411 }
8412
8413
8414 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj = 0;
8416 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8417 wxPoint2D *arg2 = 0 ;
8418 double result;
8419 void *argp1 = 0 ;
8420 int res1 = 0 ;
8421 wxPoint2D temp2 ;
8422 PyObject * obj0 = 0 ;
8423 PyObject * obj1 = 0 ;
8424 char * kwnames[] = {
8425 (char *) "self",(char *) "vec", NULL
8426 };
8427
8428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8430 if (!SWIG_IsOK(res1)) {
8431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8432 }
8433 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8434 {
8435 arg2 = &temp2;
8436 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8437 }
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 resultobj = SWIG_From_double(static_cast< double >(result));
8445 return resultobj;
8446 fail:
8447 return NULL;
8448 }
8449
8450
8451 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8452 PyObject *resultobj = 0;
8453 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8454 wxPoint2D *arg2 = 0 ;
8455 double result;
8456 void *argp1 = 0 ;
8457 int res1 = 0 ;
8458 wxPoint2D temp2 ;
8459 PyObject * obj0 = 0 ;
8460 PyObject * obj1 = 0 ;
8461 char * kwnames[] = {
8462 (char *) "self",(char *) "vec", NULL
8463 };
8464
8465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8467 if (!SWIG_IsOK(res1)) {
8468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8469 }
8470 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8471 {
8472 arg2 = &temp2;
8473 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8474 }
8475 {
8476 PyThreadState* __tstate = wxPyBeginAllowThreads();
8477 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 resultobj = SWIG_From_double(static_cast< double >(result));
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8489 PyObject *resultobj = 0;
8490 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8491 wxPoint2D result;
8492 void *argp1 = 0 ;
8493 int res1 = 0 ;
8494 PyObject *swig_obj[1] ;
8495
8496 if (!args) SWIG_fail;
8497 swig_obj[0] = args;
8498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 result = (arg1)->operator -();
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8517 PyObject *resultobj = 0;
8518 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8519 wxPoint2D *arg2 = 0 ;
8520 wxPoint2D *result = 0 ;
8521 void *argp1 = 0 ;
8522 int res1 = 0 ;
8523 wxPoint2D temp2 ;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 char * kwnames[] = {
8527 (char *) "self",(char *) "pt", NULL
8528 };
8529
8530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8532 if (!SWIG_IsOK(res1)) {
8533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8534 }
8535 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8536 {
8537 arg2 = &temp2;
8538 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8539 }
8540 {
8541 PyThreadState* __tstate = wxPyBeginAllowThreads();
8542 {
8543 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8544 result = (wxPoint2D *) &_result_ref;
8545 }
8546 wxPyEndAllowThreads(__tstate);
8547 if (PyErr_Occurred()) SWIG_fail;
8548 }
8549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8550 return resultobj;
8551 fail:
8552 return NULL;
8553 }
8554
8555
8556 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj = 0;
8558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8559 wxPoint2D *arg2 = 0 ;
8560 wxPoint2D *result = 0 ;
8561 void *argp1 = 0 ;
8562 int res1 = 0 ;
8563 wxPoint2D temp2 ;
8564 PyObject * obj0 = 0 ;
8565 PyObject * obj1 = 0 ;
8566 char * kwnames[] = {
8567 (char *) "self",(char *) "pt", NULL
8568 };
8569
8570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8574 }
8575 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8576 {
8577 arg2 = &temp2;
8578 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8579 }
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 {
8583 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8584 result = (wxPoint2D *) &_result_ref;
8585 }
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj = 0;
8598 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8599 wxPoint2D *arg2 = 0 ;
8600 wxPoint2D *result = 0 ;
8601 void *argp1 = 0 ;
8602 int res1 = 0 ;
8603 wxPoint2D temp2 ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 char * kwnames[] = {
8607 (char *) "self",(char *) "pt", NULL
8608 };
8609
8610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8614 }
8615 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8616 {
8617 arg2 = &temp2;
8618 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8619 }
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 {
8623 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8624 result = (wxPoint2D *) &_result_ref;
8625 }
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj = 0;
8638 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8639 wxPoint2D *arg2 = 0 ;
8640 wxPoint2D *result = 0 ;
8641 void *argp1 = 0 ;
8642 int res1 = 0 ;
8643 wxPoint2D temp2 ;
8644 PyObject * obj0 = 0 ;
8645 PyObject * obj1 = 0 ;
8646 char * kwnames[] = {
8647 (char *) "self",(char *) "pt", NULL
8648 };
8649
8650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8652 if (!SWIG_IsOK(res1)) {
8653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8654 }
8655 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8656 {
8657 arg2 = &temp2;
8658 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8659 }
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 {
8663 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8664 result = (wxPoint2D *) &_result_ref;
8665 }
8666 wxPyEndAllowThreads(__tstate);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8677 PyObject *resultobj = 0;
8678 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8679 PyObject *arg2 = (PyObject *) 0 ;
8680 bool result;
8681 void *argp1 = 0 ;
8682 int res1 = 0 ;
8683 PyObject * obj0 = 0 ;
8684 PyObject * obj1 = 0 ;
8685 char * kwnames[] = {
8686 (char *) "self",(char *) "other", NULL
8687 };
8688
8689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8693 }
8694 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8695 arg2 = obj1;
8696 {
8697 result = (bool)wxPoint2D___eq__(arg1,arg2);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8702 }
8703 return resultobj;
8704 fail:
8705 return NULL;
8706 }
8707
8708
8709 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8710 PyObject *resultobj = 0;
8711 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8712 PyObject *arg2 = (PyObject *) 0 ;
8713 bool result;
8714 void *argp1 = 0 ;
8715 int res1 = 0 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 char * kwnames[] = {
8719 (char *) "self",(char *) "other", NULL
8720 };
8721
8722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8724 if (!SWIG_IsOK(res1)) {
8725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8726 }
8727 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8728 arg2 = obj1;
8729 {
8730 result = (bool)wxPoint2D___ne__(arg1,arg2);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 PyObject *resultobj = 0;
8744 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8745 double arg2 ;
8746 void *argp1 = 0 ;
8747 int res1 = 0 ;
8748 double val2 ;
8749 int ecode2 = 0 ;
8750 PyObject *swig_obj[2] ;
8751
8752 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8756 }
8757 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8758 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8759 if (!SWIG_IsOK(ecode2)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8761 }
8762 arg2 = static_cast< double >(val2);
8763 if (arg1) (arg1)->m_x = arg2;
8764
8765 resultobj = SWIG_Py_Void();
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8773 PyObject *resultobj = 0;
8774 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8775 double result;
8776 void *argp1 = 0 ;
8777 int res1 = 0 ;
8778 PyObject *swig_obj[1] ;
8779
8780 if (!args) SWIG_fail;
8781 swig_obj[0] = args;
8782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8783 if (!SWIG_IsOK(res1)) {
8784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8785 }
8786 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8787 result = (double) ((arg1)->m_x);
8788 resultobj = SWIG_From_double(static_cast< double >(result));
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8796 PyObject *resultobj = 0;
8797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8798 double arg2 ;
8799 void *argp1 = 0 ;
8800 int res1 = 0 ;
8801 double val2 ;
8802 int ecode2 = 0 ;
8803 PyObject *swig_obj[2] ;
8804
8805 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8807 if (!SWIG_IsOK(res1)) {
8808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8809 }
8810 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8811 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8812 if (!SWIG_IsOK(ecode2)) {
8813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8814 }
8815 arg2 = static_cast< double >(val2);
8816 if (arg1) (arg1)->m_y = arg2;
8817
8818 resultobj = SWIG_Py_Void();
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8826 PyObject *resultobj = 0;
8827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8828 double result;
8829 void *argp1 = 0 ;
8830 int res1 = 0 ;
8831 PyObject *swig_obj[1] ;
8832
8833 if (!args) SWIG_fail;
8834 swig_obj[0] = args;
8835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8836 if (!SWIG_IsOK(res1)) {
8837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8838 }
8839 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8840 result = (double) ((arg1)->m_y);
8841 resultobj = SWIG_From_double(static_cast< double >(result));
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj = 0;
8850 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8851 double arg2 = (double) 0 ;
8852 double arg3 = (double) 0 ;
8853 void *argp1 = 0 ;
8854 int res1 = 0 ;
8855 double val2 ;
8856 int ecode2 = 0 ;
8857 double val3 ;
8858 int ecode3 = 0 ;
8859 PyObject * obj0 = 0 ;
8860 PyObject * obj1 = 0 ;
8861 PyObject * obj2 = 0 ;
8862 char * kwnames[] = {
8863 (char *) "self",(char *) "x",(char *) "y", NULL
8864 };
8865
8866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8868 if (!SWIG_IsOK(res1)) {
8869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8870 }
8871 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8872 if (obj1) {
8873 ecode2 = SWIG_AsVal_double(obj1, &val2);
8874 if (!SWIG_IsOK(ecode2)) {
8875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8876 }
8877 arg2 = static_cast< double >(val2);
8878 }
8879 if (obj2) {
8880 ecode3 = SWIG_AsVal_double(obj2, &val3);
8881 if (!SWIG_IsOK(ecode3)) {
8882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8883 }
8884 arg3 = static_cast< double >(val3);
8885 }
8886 {
8887 PyThreadState* __tstate = wxPyBeginAllowThreads();
8888 wxPoint2D_Set(arg1,arg2,arg3);
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 resultobj = SWIG_Py_Void();
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
8899 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8900 PyObject *resultobj = 0;
8901 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8902 PyObject *result = 0 ;
8903 void *argp1 = 0 ;
8904 int res1 = 0 ;
8905 PyObject *swig_obj[1] ;
8906
8907 if (!args) SWIG_fail;
8908 swig_obj[0] = args;
8909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8910 if (!SWIG_IsOK(res1)) {
8911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8912 }
8913 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 result = (PyObject *)wxPoint2D_Get(arg1);
8917 wxPyEndAllowThreads(__tstate);
8918 if (PyErr_Occurred()) SWIG_fail;
8919 }
8920 resultobj = result;
8921 return resultobj;
8922 fail:
8923 return NULL;
8924 }
8925
8926
8927 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8928 PyObject *obj;
8929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8930 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8931 return SWIG_Py_Void();
8932 }
8933
8934 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8935 return SWIG_Python_InitShadowInstance(args);
8936 }
8937
8938 SWIGINTERN int DefaultPosition_set(PyObject *) {
8939 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8940 return 1;
8941 }
8942
8943
8944 SWIGINTERN PyObject *DefaultPosition_get(void) {
8945 PyObject *pyobj = 0;
8946
8947 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8948 return pyobj;
8949 }
8950
8951
8952 SWIGINTERN int DefaultSize_set(PyObject *) {
8953 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8954 return 1;
8955 }
8956
8957
8958 SWIGINTERN PyObject *DefaultSize_get(void) {
8959 PyObject *pyobj = 0;
8960
8961 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8962 return pyobj;
8963 }
8964
8965
8966 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8967 PyObject *resultobj = 0;
8968 PyObject *arg1 = (PyObject *) 0 ;
8969 wxPyInputStream *result = 0 ;
8970 PyObject * obj0 = 0 ;
8971 char * kwnames[] = {
8972 (char *) "p", NULL
8973 };
8974
8975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8976 arg1 = obj0;
8977 {
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8991 PyObject *resultobj = 0;
8992 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8993 void *argp1 = 0 ;
8994 int res1 = 0 ;
8995 PyObject *swig_obj[1] ;
8996
8997 if (!args) SWIG_fail;
8998 swig_obj[0] = args;
8999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9002 }
9003 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 delete arg1;
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 resultobj = SWIG_Py_Void();
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9019 PyObject *resultobj = 0;
9020 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9021 void *argp1 = 0 ;
9022 int res1 = 0 ;
9023 PyObject *swig_obj[1] ;
9024
9025 if (!args) SWIG_fail;
9026 swig_obj[0] = args;
9027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9028 if (!SWIG_IsOK(res1)) {
9029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9030 }
9031 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9032 {
9033 PyThreadState* __tstate = wxPyBeginAllowThreads();
9034 (arg1)->close();
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 resultobj = SWIG_Py_Void();
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9046 PyObject *resultobj = 0;
9047 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9048 void *argp1 = 0 ;
9049 int res1 = 0 ;
9050 PyObject *swig_obj[1] ;
9051
9052 if (!args) SWIG_fail;
9053 swig_obj[0] = args;
9054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9057 }
9058 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9059 {
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 (arg1)->flush();
9062 wxPyEndAllowThreads(__tstate);
9063 if (PyErr_Occurred()) SWIG_fail;
9064 }
9065 resultobj = SWIG_Py_Void();
9066 return resultobj;
9067 fail:
9068 return NULL;
9069 }
9070
9071
9072 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9073 PyObject *resultobj = 0;
9074 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9075 bool result;
9076 void *argp1 = 0 ;
9077 int res1 = 0 ;
9078 PyObject *swig_obj[1] ;
9079
9080 if (!args) SWIG_fail;
9081 swig_obj[0] = args;
9082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9083 if (!SWIG_IsOK(res1)) {
9084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9085 }
9086 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9087 {
9088 PyThreadState* __tstate = wxPyBeginAllowThreads();
9089 result = (bool)(arg1)->eof();
9090 wxPyEndAllowThreads(__tstate);
9091 if (PyErr_Occurred()) SWIG_fail;
9092 }
9093 {
9094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9095 }
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9103 PyObject *resultobj = 0;
9104 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9105 int arg2 = (int) -1 ;
9106 PyObject *result = 0 ;
9107 void *argp1 = 0 ;
9108 int res1 = 0 ;
9109 int val2 ;
9110 int ecode2 = 0 ;
9111 PyObject * obj0 = 0 ;
9112 PyObject * obj1 = 0 ;
9113 char * kwnames[] = {
9114 (char *) "self",(char *) "size", NULL
9115 };
9116
9117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9121 }
9122 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9123 if (obj1) {
9124 ecode2 = SWIG_AsVal_int(obj1, &val2);
9125 if (!SWIG_IsOK(ecode2)) {
9126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9127 }
9128 arg2 = static_cast< int >(val2);
9129 }
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 result = (PyObject *)(arg1)->read(arg2);
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 resultobj = result;
9137 return resultobj;
9138 fail:
9139 return NULL;
9140 }
9141
9142
9143 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9144 PyObject *resultobj = 0;
9145 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9146 int arg2 = (int) -1 ;
9147 PyObject *result = 0 ;
9148 void *argp1 = 0 ;
9149 int res1 = 0 ;
9150 int val2 ;
9151 int ecode2 = 0 ;
9152 PyObject * obj0 = 0 ;
9153 PyObject * obj1 = 0 ;
9154 char * kwnames[] = {
9155 (char *) "self",(char *) "size", NULL
9156 };
9157
9158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9162 }
9163 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9164 if (obj1) {
9165 ecode2 = SWIG_AsVal_int(obj1, &val2);
9166 if (!SWIG_IsOK(ecode2)) {
9167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9168 }
9169 arg2 = static_cast< int >(val2);
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 result = (PyObject *)(arg1)->readline(arg2);
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 resultobj = result;
9178 return resultobj;
9179 fail:
9180 return NULL;
9181 }
9182
9183
9184 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9185 PyObject *resultobj = 0;
9186 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9187 int arg2 = (int) -1 ;
9188 PyObject *result = 0 ;
9189 void *argp1 = 0 ;
9190 int res1 = 0 ;
9191 int val2 ;
9192 int ecode2 = 0 ;
9193 PyObject * obj0 = 0 ;
9194 PyObject * obj1 = 0 ;
9195 char * kwnames[] = {
9196 (char *) "self",(char *) "sizehint", NULL
9197 };
9198
9199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9201 if (!SWIG_IsOK(res1)) {
9202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9203 }
9204 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9205 if (obj1) {
9206 ecode2 = SWIG_AsVal_int(obj1, &val2);
9207 if (!SWIG_IsOK(ecode2)) {
9208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9209 }
9210 arg2 = static_cast< int >(val2);
9211 }
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (PyObject *)(arg1)->readlines(arg2);
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = result;
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj = 0;
9227 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9228 int arg2 ;
9229 int arg3 = (int) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 int val2 ;
9233 int ecode2 = 0 ;
9234 int val3 ;
9235 int ecode3 = 0 ;
9236 PyObject * obj0 = 0 ;
9237 PyObject * obj1 = 0 ;
9238 PyObject * obj2 = 0 ;
9239 char * kwnames[] = {
9240 (char *) "self",(char *) "offset",(char *) "whence", NULL
9241 };
9242
9243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9245 if (!SWIG_IsOK(res1)) {
9246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9247 }
9248 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9249 ecode2 = SWIG_AsVal_int(obj1, &val2);
9250 if (!SWIG_IsOK(ecode2)) {
9251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9252 }
9253 arg2 = static_cast< int >(val2);
9254 if (obj2) {
9255 ecode3 = SWIG_AsVal_int(obj2, &val3);
9256 if (!SWIG_IsOK(ecode3)) {
9257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9258 }
9259 arg3 = static_cast< int >(val3);
9260 }
9261 {
9262 PyThreadState* __tstate = wxPyBeginAllowThreads();
9263 (arg1)->seek(arg2,arg3);
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 resultobj = SWIG_Py_Void();
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 PyObject *resultobj = 0;
9276 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9277 int result;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 PyObject *swig_obj[1] ;
9281
9282 if (!args) SWIG_fail;
9283 swig_obj[0] = args;
9284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9285 if (!SWIG_IsOK(res1)) {
9286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9287 }
9288 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 result = (int)(arg1)->tell();
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_From_int(static_cast< int >(result));
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9303 PyObject *resultobj = 0;
9304 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9305 char result;
9306 void *argp1 = 0 ;
9307 int res1 = 0 ;
9308 PyObject *swig_obj[1] ;
9309
9310 if (!args) SWIG_fail;
9311 swig_obj[0] = args;
9312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9313 if (!SWIG_IsOK(res1)) {
9314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9315 }
9316 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 result = (char)(arg1)->Peek();
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 resultobj = SWIG_From_char(static_cast< char >(result));
9324 return resultobj;
9325 fail:
9326 return NULL;
9327 }
9328
9329
9330 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9331 PyObject *resultobj = 0;
9332 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9333 char result;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 PyObject *swig_obj[1] ;
9337
9338 if (!args) SWIG_fail;
9339 swig_obj[0] = args;
9340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9341 if (!SWIG_IsOK(res1)) {
9342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9343 }
9344 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 result = (char)(arg1)->GetC();
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 resultobj = SWIG_From_char(static_cast< char >(result));
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 PyObject *resultobj = 0;
9360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9361 size_t result;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 PyObject *swig_obj[1] ;
9365
9366 if (!args) SWIG_fail;
9367 swig_obj[0] = args;
9368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9369 if (!SWIG_IsOK(res1)) {
9370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9371 }
9372 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9373 {
9374 PyThreadState* __tstate = wxPyBeginAllowThreads();
9375 result = (size_t)(arg1)->LastRead();
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9380 return resultobj;
9381 fail:
9382 return NULL;
9383 }
9384
9385
9386 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9387 PyObject *resultobj = 0;
9388 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9389 bool result;
9390 void *argp1 = 0 ;
9391 int res1 = 0 ;
9392 PyObject *swig_obj[1] ;
9393
9394 if (!args) SWIG_fail;
9395 swig_obj[0] = args;
9396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9397 if (!SWIG_IsOK(res1)) {
9398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9399 }
9400 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (bool)(arg1)->CanRead();
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 {
9408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9409 }
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 bool result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (bool)(arg1)->Eof();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 {
9438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9439 }
9440 return resultobj;
9441 fail:
9442 return NULL;
9443 }
9444
9445
9446 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9447 PyObject *resultobj = 0;
9448 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9449 char arg2 ;
9450 bool result;
9451 void *argp1 = 0 ;
9452 int res1 = 0 ;
9453 char val2 ;
9454 int ecode2 = 0 ;
9455 PyObject * obj0 = 0 ;
9456 PyObject * obj1 = 0 ;
9457 char * kwnames[] = {
9458 (char *) "self",(char *) "c", NULL
9459 };
9460
9461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9463 if (!SWIG_IsOK(res1)) {
9464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9465 }
9466 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9467 ecode2 = SWIG_AsVal_char(obj1, &val2);
9468 if (!SWIG_IsOK(ecode2)) {
9469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9470 }
9471 arg2 = static_cast< char >(val2);
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (bool)(arg1)->Ungetch(arg2);
9475 wxPyEndAllowThreads(__tstate);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 {
9479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9480 }
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9488 PyObject *resultobj = 0;
9489 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9490 long arg2 ;
9491 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9492 long result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 long val2 ;
9496 int ecode2 = 0 ;
9497 int val3 ;
9498 int ecode3 = 0 ;
9499 PyObject * obj0 = 0 ;
9500 PyObject * obj1 = 0 ;
9501 PyObject * obj2 = 0 ;
9502 char * kwnames[] = {
9503 (char *) "self",(char *) "pos",(char *) "mode", NULL
9504 };
9505
9506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9510 }
9511 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9512 ecode2 = SWIG_AsVal_long(obj1, &val2);
9513 if (!SWIG_IsOK(ecode2)) {
9514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9515 }
9516 arg2 = static_cast< long >(val2);
9517 if (obj2) {
9518 ecode3 = SWIG_AsVal_int(obj2, &val3);
9519 if (!SWIG_IsOK(ecode3)) {
9520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9521 }
9522 arg3 = static_cast< wxSeekMode >(val3);
9523 }
9524 {
9525 PyThreadState* __tstate = wxPyBeginAllowThreads();
9526 result = (long)(arg1)->SeekI(arg2,arg3);
9527 wxPyEndAllowThreads(__tstate);
9528 if (PyErr_Occurred()) SWIG_fail;
9529 }
9530 resultobj = SWIG_From_long(static_cast< long >(result));
9531 return resultobj;
9532 fail:
9533 return NULL;
9534 }
9535
9536
9537 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9538 PyObject *resultobj = 0;
9539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9540 long result;
9541 void *argp1 = 0 ;
9542 int res1 = 0 ;
9543 PyObject *swig_obj[1] ;
9544
9545 if (!args) SWIG_fail;
9546 swig_obj[0] = args;
9547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9548 if (!SWIG_IsOK(res1)) {
9549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9550 }
9551 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9552 {
9553 PyThreadState* __tstate = wxPyBeginAllowThreads();
9554 result = (long)(arg1)->TellI();
9555 wxPyEndAllowThreads(__tstate);
9556 if (PyErr_Occurred()) SWIG_fail;
9557 }
9558 resultobj = SWIG_From_long(static_cast< long >(result));
9559 return resultobj;
9560 fail:
9561 return NULL;
9562 }
9563
9564
9565 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9566 PyObject *obj;
9567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9568 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9569 return SWIG_Py_Void();
9570 }
9571
9572 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9573 return SWIG_Python_InitShadowInstance(args);
9574 }
9575
9576 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9577 PyObject *resultobj = 0;
9578 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9579 PyObject *arg2 = (PyObject *) 0 ;
9580 void *argp1 = 0 ;
9581 int res1 = 0 ;
9582 PyObject * obj0 = 0 ;
9583 PyObject * obj1 = 0 ;
9584 char * kwnames[] = {
9585 (char *) "self",(char *) "obj", NULL
9586 };
9587
9588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9590 if (!SWIG_IsOK(res1)) {
9591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9592 }
9593 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9594 arg2 = obj1;
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 wxOutputStream_write(arg1,arg2);
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_Py_Void();
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609 PyObject *resultobj = 0;
9610 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9611 size_t result;
9612 void *argp1 = 0 ;
9613 int res1 = 0 ;
9614 PyObject *swig_obj[1] ;
9615
9616 if (!args) SWIG_fail;
9617 swig_obj[0] = args;
9618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9619 if (!SWIG_IsOK(res1)) {
9620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9621 }
9622 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9626 wxPyEndAllowThreads(__tstate);
9627 if (PyErr_Occurred()) SWIG_fail;
9628 }
9629 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9630 return resultobj;
9631 fail:
9632 return NULL;
9633 }
9634
9635
9636 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9637 PyObject *obj;
9638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9639 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9640 return SWIG_Py_Void();
9641 }
9642
9643 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9644 PyObject *resultobj = 0;
9645 wxInputStream *arg1 = (wxInputStream *) 0 ;
9646 wxString *arg2 = 0 ;
9647 wxString *arg3 = 0 ;
9648 wxString *arg4 = 0 ;
9649 wxDateTime arg5 ;
9650 wxFSFile *result = 0 ;
9651 wxPyInputStream *temp1 ;
9652 bool temp2 = false ;
9653 bool temp3 = false ;
9654 bool temp4 = false ;
9655 void *argp5 ;
9656 int res5 = 0 ;
9657 PyObject * obj0 = 0 ;
9658 PyObject * obj1 = 0 ;
9659 PyObject * obj2 = 0 ;
9660 PyObject * obj3 = 0 ;
9661 PyObject * obj4 = 0 ;
9662 char * kwnames[] = {
9663 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9664 };
9665
9666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9667 {
9668 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9669 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9670 } else {
9671 PyErr_Clear(); // clear the failure of the wxPyConvert above
9672 arg1 = wxPyCBInputStream_create(obj0, true);
9673 if (arg1 == NULL) {
9674 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9675 SWIG_fail;
9676 }
9677 }
9678 }
9679 {
9680 arg2 = wxString_in_helper(obj1);
9681 if (arg2 == NULL) SWIG_fail;
9682 temp2 = true;
9683 }
9684 {
9685 arg3 = wxString_in_helper(obj2);
9686 if (arg3 == NULL) SWIG_fail;
9687 temp3 = true;
9688 }
9689 {
9690 arg4 = wxString_in_helper(obj3);
9691 if (arg4 == NULL) SWIG_fail;
9692 temp4 = true;
9693 }
9694 {
9695 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9696 if (!SWIG_IsOK(res5)) {
9697 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9698 }
9699 if (!argp5) {
9700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9701 } else {
9702 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9703 arg5 = *temp;
9704 if (SWIG_IsNewObj(res5)) delete temp;
9705 }
9706 }
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9710 wxPyEndAllowThreads(__tstate);
9711 if (PyErr_Occurred()) SWIG_fail;
9712 }
9713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9714 {
9715 if (temp2)
9716 delete arg2;
9717 }
9718 {
9719 if (temp3)
9720 delete arg3;
9721 }
9722 {
9723 if (temp4)
9724 delete arg4;
9725 }
9726 return resultobj;
9727 fail:
9728 {
9729 if (temp2)
9730 delete arg2;
9731 }
9732 {
9733 if (temp3)
9734 delete arg3;
9735 }
9736 {
9737 if (temp4)
9738 delete arg4;
9739 }
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 PyObject *resultobj = 0;
9746 wxFSFile *arg1 = (wxFSFile *) 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 PyObject *swig_obj[1] ;
9750
9751 if (!args) SWIG_fail;
9752 swig_obj[0] = args;
9753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9756 }
9757 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 delete arg1;
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9773 PyObject *resultobj = 0;
9774 wxFSFile *arg1 = (wxFSFile *) 0 ;
9775 wxInputStream *result = 0 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 PyObject *swig_obj[1] ;
9779
9780 if (!args) SWIG_fail;
9781 swig_obj[0] = args;
9782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9783 if (!SWIG_IsOK(res1)) {
9784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9785 }
9786 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 result = (wxInputStream *)(arg1)->GetStream();
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 {
9794 wxPyInputStream * _ptr = NULL;
9795
9796 if (result) {
9797 _ptr = new wxPyInputStream(result);
9798 }
9799 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9800 }
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9808 PyObject *resultobj = 0;
9809 wxFSFile *arg1 = (wxFSFile *) 0 ;
9810 wxString *result = 0 ;
9811 void *argp1 = 0 ;
9812 int res1 = 0 ;
9813 PyObject *swig_obj[1] ;
9814
9815 if (!args) SWIG_fail;
9816 swig_obj[0] = args;
9817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9820 }
9821 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9822 {
9823 PyThreadState* __tstate = wxPyBeginAllowThreads();
9824 {
9825 wxString const &_result_ref = (arg1)->GetMimeType();
9826 result = (wxString *) &_result_ref;
9827 }
9828 wxPyEndAllowThreads(__tstate);
9829 if (PyErr_Occurred()) SWIG_fail;
9830 }
9831 {
9832 #if wxUSE_UNICODE
9833 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9834 #else
9835 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9836 #endif
9837 }
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9845 PyObject *resultobj = 0;
9846 wxFSFile *arg1 = (wxFSFile *) 0 ;
9847 wxString *result = 0 ;
9848 void *argp1 = 0 ;
9849 int res1 = 0 ;
9850 PyObject *swig_obj[1] ;
9851
9852 if (!args) SWIG_fail;
9853 swig_obj[0] = args;
9854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9855 if (!SWIG_IsOK(res1)) {
9856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9857 }
9858 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9859 {
9860 PyThreadState* __tstate = wxPyBeginAllowThreads();
9861 {
9862 wxString const &_result_ref = (arg1)->GetLocation();
9863 result = (wxString *) &_result_ref;
9864 }
9865 wxPyEndAllowThreads(__tstate);
9866 if (PyErr_Occurred()) SWIG_fail;
9867 }
9868 {
9869 #if wxUSE_UNICODE
9870 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9871 #else
9872 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9873 #endif
9874 }
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9882 PyObject *resultobj = 0;
9883 wxFSFile *arg1 = (wxFSFile *) 0 ;
9884 wxString *result = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 PyObject *swig_obj[1] ;
9888
9889 if (!args) SWIG_fail;
9890 swig_obj[0] = args;
9891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9894 }
9895 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 {
9899 wxString const &_result_ref = (arg1)->GetAnchor();
9900 result = (wxString *) &_result_ref;
9901 }
9902 wxPyEndAllowThreads(__tstate);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 {
9906 #if wxUSE_UNICODE
9907 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9908 #else
9909 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9910 #endif
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9919 PyObject *resultobj = 0;
9920 wxFSFile *arg1 = (wxFSFile *) 0 ;
9921 wxDateTime result;
9922 void *argp1 = 0 ;
9923 int res1 = 0 ;
9924 PyObject *swig_obj[1] ;
9925
9926 if (!args) SWIG_fail;
9927 swig_obj[0] = args;
9928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9931 }
9932 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (arg1)->GetModificationTime();
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *obj;
9948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9949 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9950 return SWIG_Py_Void();
9951 }
9952
9953 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9954 return SWIG_Python_InitShadowInstance(args);
9955 }
9956
9957 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9958 PyObject *resultobj = 0;
9959 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9960 void *argp1 = 0 ;
9961 int res1 = 0 ;
9962 PyObject *swig_obj[1] ;
9963
9964 if (!args) SWIG_fail;
9965 swig_obj[0] = args;
9966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9967 if (!SWIG_IsOK(res1)) {
9968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9969 }
9970 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 delete arg1;
9974
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_Py_Void();
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9986 PyObject *obj;
9987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9988 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9989 return SWIG_Py_Void();
9990 }
9991
9992 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9993 PyObject *resultobj = 0;
9994 wxPyFileSystemHandler *result = 0 ;
9995
9996 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10004 return resultobj;
10005 fail:
10006 return NULL;
10007 }
10008
10009
10010 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10011 PyObject *resultobj = 0;
10012 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10013 PyObject *arg2 = (PyObject *) 0 ;
10014 PyObject *arg3 = (PyObject *) 0 ;
10015 void *argp1 = 0 ;
10016 int res1 = 0 ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 PyObject * obj2 = 0 ;
10020 char * kwnames[] = {
10021 (char *) "self",(char *) "self",(char *) "_class", NULL
10022 };
10023
10024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10026 if (!SWIG_IsOK(res1)) {
10027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10028 }
10029 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10030 arg2 = obj1;
10031 arg3 = obj2;
10032 {
10033 PyThreadState* __tstate = wxPyBeginAllowThreads();
10034 (arg1)->_setCallbackInfo(arg2,arg3);
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 resultobj = SWIG_Py_Void();
10039 return resultobj;
10040 fail:
10041 return NULL;
10042 }
10043
10044
10045 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj = 0;
10047 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10048 wxString *arg2 = 0 ;
10049 bool result;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 bool temp2 = false ;
10053 PyObject * obj0 = 0 ;
10054 PyObject * obj1 = 0 ;
10055 char * kwnames[] = {
10056 (char *) "self",(char *) "location", NULL
10057 };
10058
10059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10061 if (!SWIG_IsOK(res1)) {
10062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10063 }
10064 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10065 {
10066 arg2 = wxString_in_helper(obj1);
10067 if (arg2 == NULL) SWIG_fail;
10068 temp2 = true;
10069 }
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10073 wxPyEndAllowThreads(__tstate);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 {
10077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10078 }
10079 {
10080 if (temp2)
10081 delete arg2;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp2)
10087 delete arg2;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj = 0;
10095 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10096 wxFileSystem *arg2 = 0 ;
10097 wxString *arg3 = 0 ;
10098 wxFSFile *result = 0 ;
10099 void *argp1 = 0 ;
10100 int res1 = 0 ;
10101 void *argp2 = 0 ;
10102 int res2 = 0 ;
10103 bool temp3 = false ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 PyObject * obj2 = 0 ;
10107 char * kwnames[] = {
10108 (char *) "self",(char *) "fs",(char *) "location", NULL
10109 };
10110
10111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10113 if (!SWIG_IsOK(res1)) {
10114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10115 }
10116 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10118 if (!SWIG_IsOK(res2)) {
10119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10120 }
10121 if (!argp2) {
10122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10123 }
10124 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10125 {
10126 arg3 = wxString_in_helper(obj2);
10127 if (arg3 == NULL) SWIG_fail;
10128 temp3 = true;
10129 }
10130 {
10131 PyThreadState* __tstate = wxPyBeginAllowThreads();
10132 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 {
10137 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10138 }
10139 {
10140 if (temp3)
10141 delete arg3;
10142 }
10143 return resultobj;
10144 fail:
10145 {
10146 if (temp3)
10147 delete arg3;
10148 }
10149 return NULL;
10150 }
10151
10152
10153 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj = 0;
10155 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10156 wxString *arg2 = 0 ;
10157 int arg3 = (int) 0 ;
10158 wxString result;
10159 void *argp1 = 0 ;
10160 int res1 = 0 ;
10161 bool temp2 = false ;
10162 int val3 ;
10163 int ecode3 = 0 ;
10164 PyObject * obj0 = 0 ;
10165 PyObject * obj1 = 0 ;
10166 PyObject * obj2 = 0 ;
10167 char * kwnames[] = {
10168 (char *) "self",(char *) "spec",(char *) "flags", NULL
10169 };
10170
10171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10173 if (!SWIG_IsOK(res1)) {
10174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10175 }
10176 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10177 {
10178 arg2 = wxString_in_helper(obj1);
10179 if (arg2 == NULL) SWIG_fail;
10180 temp2 = true;
10181 }
10182 if (obj2) {
10183 ecode3 = SWIG_AsVal_int(obj2, &val3);
10184 if (!SWIG_IsOK(ecode3)) {
10185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10186 }
10187 arg3 = static_cast< int >(val3);
10188 }
10189 {
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10192 wxPyEndAllowThreads(__tstate);
10193 if (PyErr_Occurred()) SWIG_fail;
10194 }
10195 {
10196 #if wxUSE_UNICODE
10197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10198 #else
10199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10200 #endif
10201 }
10202 {
10203 if (temp2)
10204 delete arg2;
10205 }
10206 return resultobj;
10207 fail:
10208 {
10209 if (temp2)
10210 delete arg2;
10211 }
10212 return NULL;
10213 }
10214
10215
10216 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10217 PyObject *resultobj = 0;
10218 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10219 wxString result;
10220 void *argp1 = 0 ;
10221 int res1 = 0 ;
10222 PyObject *swig_obj[1] ;
10223
10224 if (!args) SWIG_fail;
10225 swig_obj[0] = args;
10226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10227 if (!SWIG_IsOK(res1)) {
10228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10229 }
10230 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10231 {
10232 PyThreadState* __tstate = wxPyBeginAllowThreads();
10233 result = (arg1)->FindNext();
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 {
10238 #if wxUSE_UNICODE
10239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10240 #else
10241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10242 #endif
10243 }
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10253 wxString *arg2 = 0 ;
10254 wxString result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 bool temp2 = false ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "self",(char *) "location", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10268 }
10269 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10270 {
10271 arg2 = wxString_in_helper(obj1);
10272 if (arg2 == NULL) SWIG_fail;
10273 temp2 = true;
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (arg1)->GetProtocol((wxString const &)*arg2);
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 #if wxUSE_UNICODE
10283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10284 #else
10285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10286 #endif
10287 }
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return resultobj;
10293 fail:
10294 {
10295 if (temp2)
10296 delete arg2;
10297 }
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10305 wxString *arg2 = 0 ;
10306 wxString result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 bool temp2 = false ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "location", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10320 }
10321 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10322 {
10323 arg2 = wxString_in_helper(obj1);
10324 if (arg2 == NULL) SWIG_fail;
10325 temp2 = true;
10326 }
10327 {
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 {
10334 #if wxUSE_UNICODE
10335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10336 #else
10337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10338 #endif
10339 }
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return resultobj;
10345 fail:
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return NULL;
10351 }
10352
10353
10354 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10355 PyObject *resultobj = 0;
10356 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10357 wxString *arg2 = 0 ;
10358 wxString result;
10359 void *argp1 = 0 ;
10360 int res1 = 0 ;
10361 bool temp2 = false ;
10362 PyObject * obj0 = 0 ;
10363 PyObject * obj1 = 0 ;
10364 char * kwnames[] = {
10365 (char *) "self",(char *) "location", NULL
10366 };
10367
10368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10370 if (!SWIG_IsOK(res1)) {
10371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10372 }
10373 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10374 {
10375 arg2 = wxString_in_helper(obj1);
10376 if (arg2 == NULL) SWIG_fail;
10377 temp2 = true;
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 result = (arg1)->GetAnchor((wxString const &)*arg2);
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 {
10386 #if wxUSE_UNICODE
10387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10388 #else
10389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10390 #endif
10391 }
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return resultobj;
10397 fail:
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return NULL;
10403 }
10404
10405
10406 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10407 PyObject *resultobj = 0;
10408 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10409 wxString *arg2 = 0 ;
10410 wxString result;
10411 void *argp1 = 0 ;
10412 int res1 = 0 ;
10413 bool temp2 = false ;
10414 PyObject * obj0 = 0 ;
10415 PyObject * obj1 = 0 ;
10416 char * kwnames[] = {
10417 (char *) "self",(char *) "location", NULL
10418 };
10419
10420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10424 }
10425 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10426 {
10427 arg2 = wxString_in_helper(obj1);
10428 if (arg2 == NULL) SWIG_fail;
10429 temp2 = true;
10430 }
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10434 wxPyEndAllowThreads(__tstate);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 #if wxUSE_UNICODE
10439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10440 #else
10441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10442 #endif
10443 }
10444 {
10445 if (temp2)
10446 delete arg2;
10447 }
10448 return resultobj;
10449 fail:
10450 {
10451 if (temp2)
10452 delete arg2;
10453 }
10454 return NULL;
10455 }
10456
10457
10458 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10459 PyObject *resultobj = 0;
10460 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10461 wxString *arg2 = 0 ;
10462 wxString result;
10463 void *argp1 = 0 ;
10464 int res1 = 0 ;
10465 bool temp2 = false ;
10466 PyObject * obj0 = 0 ;
10467 PyObject * obj1 = 0 ;
10468 char * kwnames[] = {
10469 (char *) "self",(char *) "location", NULL
10470 };
10471
10472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10474 if (!SWIG_IsOK(res1)) {
10475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10476 }
10477 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10478 {
10479 arg2 = wxString_in_helper(obj1);
10480 if (arg2 == NULL) SWIG_fail;
10481 temp2 = true;
10482 }
10483 {
10484 PyThreadState* __tstate = wxPyBeginAllowThreads();
10485 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 {
10490 #if wxUSE_UNICODE
10491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10492 #else
10493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10494 #endif
10495 }
10496 {
10497 if (temp2)
10498 delete arg2;
10499 }
10500 return resultobj;
10501 fail:
10502 {
10503 if (temp2)
10504 delete arg2;
10505 }
10506 return NULL;
10507 }
10508
10509
10510 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10511 PyObject *obj;
10512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10513 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10514 return SWIG_Py_Void();
10515 }
10516
10517 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10518 return SWIG_Python_InitShadowInstance(args);
10519 }
10520
10521 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10522 PyObject *resultobj = 0;
10523 wxFileSystem *result = 0 ;
10524
10525 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (wxFileSystem *)new wxFileSystem();
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 {
10533 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10534 }
10535 return resultobj;
10536 fail:
10537 return NULL;
10538 }
10539
10540
10541 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10542 PyObject *resultobj = 0;
10543 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 PyObject *swig_obj[1] ;
10547
10548 if (!args) SWIG_fail;
10549 swig_obj[0] = args;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10553 }
10554 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 delete arg1;
10558
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 resultobj = SWIG_Py_Void();
10563 return resultobj;
10564 fail:
10565 return NULL;
10566 }
10567
10568
10569 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj = 0;
10571 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10572 wxString *arg2 = 0 ;
10573 bool arg3 = (bool) false ;
10574 void *argp1 = 0 ;
10575 int res1 = 0 ;
10576 bool temp2 = false ;
10577 bool val3 ;
10578 int ecode3 = 0 ;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581 PyObject * obj2 = 0 ;
10582 char * kwnames[] = {
10583 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10584 };
10585
10586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10588 if (!SWIG_IsOK(res1)) {
10589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10590 }
10591 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10592 {
10593 arg2 = wxString_in_helper(obj1);
10594 if (arg2 == NULL) SWIG_fail;
10595 temp2 = true;
10596 }
10597 if (obj2) {
10598 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10599 if (!SWIG_IsOK(ecode3)) {
10600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10601 }
10602 arg3 = static_cast< bool >(val3);
10603 }
10604 {
10605 PyThreadState* __tstate = wxPyBeginAllowThreads();
10606 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10607 wxPyEndAllowThreads(__tstate);
10608 if (PyErr_Occurred()) SWIG_fail;
10609 }
10610 resultobj = SWIG_Py_Void();
10611 {
10612 if (temp2)
10613 delete arg2;
10614 }
10615 return resultobj;
10616 fail:
10617 {
10618 if (temp2)
10619 delete arg2;
10620 }
10621 return NULL;
10622 }
10623
10624
10625 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10626 PyObject *resultobj = 0;
10627 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10628 wxString result;
10629 void *argp1 = 0 ;
10630 int res1 = 0 ;
10631 PyObject *swig_obj[1] ;
10632
10633 if (!args) SWIG_fail;
10634 swig_obj[0] = args;
10635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10636 if (!SWIG_IsOK(res1)) {
10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10638 }
10639 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 result = (arg1)->GetPath();
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 {
10647 #if wxUSE_UNICODE
10648 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10649 #else
10650 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10651 #endif
10652 }
10653 return resultobj;
10654 fail:
10655 return NULL;
10656 }
10657
10658
10659 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj = 0;
10661 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10662 wxString *arg2 = 0 ;
10663 wxFSFile *result = 0 ;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 bool temp2 = false ;
10667 PyObject * obj0 = 0 ;
10668 PyObject * obj1 = 0 ;
10669 char * kwnames[] = {
10670 (char *) "self",(char *) "location", NULL
10671 };
10672
10673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10677 }
10678 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10679 {
10680 arg2 = wxString_in_helper(obj1);
10681 if (arg2 == NULL) SWIG_fail;
10682 temp2 = true;
10683 }
10684 {
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10687 wxPyEndAllowThreads(__tstate);
10688 if (PyErr_Occurred()) SWIG_fail;
10689 }
10690 {
10691 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10692 }
10693 {
10694 if (temp2)
10695 delete arg2;
10696 }
10697 return resultobj;
10698 fail:
10699 {
10700 if (temp2)
10701 delete arg2;
10702 }
10703 return NULL;
10704 }
10705
10706
10707 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj = 0;
10709 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10710 wxString *arg2 = 0 ;
10711 int arg3 = (int) 0 ;
10712 wxString result;
10713 void *argp1 = 0 ;
10714 int res1 = 0 ;
10715 bool temp2 = false ;
10716 int val3 ;
10717 int ecode3 = 0 ;
10718 PyObject * obj0 = 0 ;
10719 PyObject * obj1 = 0 ;
10720 PyObject * obj2 = 0 ;
10721 char * kwnames[] = {
10722 (char *) "self",(char *) "spec",(char *) "flags", NULL
10723 };
10724
10725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10727 if (!SWIG_IsOK(res1)) {
10728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10729 }
10730 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10731 {
10732 arg2 = wxString_in_helper(obj1);
10733 if (arg2 == NULL) SWIG_fail;
10734 temp2 = true;
10735 }
10736 if (obj2) {
10737 ecode3 = SWIG_AsVal_int(obj2, &val3);
10738 if (!SWIG_IsOK(ecode3)) {
10739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10740 }
10741 arg3 = static_cast< int >(val3);
10742 }
10743 {
10744 PyThreadState* __tstate = wxPyBeginAllowThreads();
10745 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10746 wxPyEndAllowThreads(__tstate);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 {
10750 #if wxUSE_UNICODE
10751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10752 #else
10753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10754 #endif
10755 }
10756 {
10757 if (temp2)
10758 delete arg2;
10759 }
10760 return resultobj;
10761 fail:
10762 {
10763 if (temp2)
10764 delete arg2;
10765 }
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10771 PyObject *resultobj = 0;
10772 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10773 wxString result;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 PyObject *swig_obj[1] ;
10777
10778 if (!args) SWIG_fail;
10779 swig_obj[0] = args;
10780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10781 if (!SWIG_IsOK(res1)) {
10782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10783 }
10784 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10785 {
10786 PyThreadState* __tstate = wxPyBeginAllowThreads();
10787 result = (arg1)->FindNext();
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 {
10792 #if wxUSE_UNICODE
10793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10794 #else
10795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10796 #endif
10797 }
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = 0;
10806 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10807 int res1 = 0 ;
10808 PyObject * obj0 = 0 ;
10809 char * kwnames[] = {
10810 (char *) "handler", NULL
10811 };
10812
10813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10814 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10815 if (!SWIG_IsOK(res1)) {
10816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10817 }
10818 {
10819 PyThreadState* __tstate = wxPyBeginAllowThreads();
10820 wxFileSystem::AddHandler(arg1);
10821 wxPyEndAllowThreads(__tstate);
10822 if (PyErr_Occurred()) SWIG_fail;
10823 }
10824 resultobj = SWIG_Py_Void();
10825 return resultobj;
10826 fail:
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10832 PyObject *resultobj = 0;
10833
10834 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 wxFileSystem::CleanUpHandlers();
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 resultobj = SWIG_Py_Void();
10842 return resultobj;
10843 fail:
10844 return NULL;
10845 }
10846
10847
10848 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10849 PyObject *resultobj = 0;
10850 wxString *arg1 = 0 ;
10851 wxString result;
10852 bool temp1 = false ;
10853 PyObject * obj0 = 0 ;
10854 char * kwnames[] = {
10855 (char *) "filename", NULL
10856 };
10857
10858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10859 {
10860 arg1 = wxString_in_helper(obj0);
10861 if (arg1 == NULL) SWIG_fail;
10862 temp1 = true;
10863 }
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 {
10871 #if wxUSE_UNICODE
10872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10873 #else
10874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10875 #endif
10876 }
10877 {
10878 if (temp1)
10879 delete arg1;
10880 }
10881 return resultobj;
10882 fail:
10883 {
10884 if (temp1)
10885 delete arg1;
10886 }
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj = 0;
10893 wxString *arg1 = 0 ;
10894 wxString result;
10895 bool temp1 = false ;
10896 PyObject * obj0 = 0 ;
10897 char * kwnames[] = {
10898 (char *) "url", NULL
10899 };
10900
10901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10902 {
10903 arg1 = wxString_in_helper(obj0);
10904 if (arg1 == NULL) SWIG_fail;
10905 temp1 = true;
10906 }
10907 {
10908 PyThreadState* __tstate = wxPyBeginAllowThreads();
10909 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 {
10914 #if wxUSE_UNICODE
10915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10916 #else
10917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10918 #endif
10919 }
10920 {
10921 if (temp1)
10922 delete arg1;
10923 }
10924 return resultobj;
10925 fail:
10926 {
10927 if (temp1)
10928 delete arg1;
10929 }
10930 return NULL;
10931 }
10932
10933
10934 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10935 PyObject *obj;
10936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10937 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10938 return SWIG_Py_Void();
10939 }
10940
10941 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10942 return SWIG_Python_InitShadowInstance(args);
10943 }
10944
10945 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10946 PyObject *resultobj = 0;
10947 wxInternetFSHandler *result = 0 ;
10948
10949 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10950 {
10951 PyThreadState* __tstate = wxPyBeginAllowThreads();
10952 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = 0;
10965 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10966 wxString *arg2 = 0 ;
10967 bool result;
10968 void *argp1 = 0 ;
10969 int res1 = 0 ;
10970 bool temp2 = false ;
10971 PyObject * obj0 = 0 ;
10972 PyObject * obj1 = 0 ;
10973 char * kwnames[] = {
10974 (char *) "self",(char *) "location", NULL
10975 };
10976
10977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10981 }
10982 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10983 {
10984 arg2 = wxString_in_helper(obj1);
10985 if (arg2 == NULL) SWIG_fail;
10986 temp2 = true;
10987 }
10988 {
10989 PyThreadState* __tstate = wxPyBeginAllowThreads();
10990 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 {
10995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10996 }
10997 {
10998 if (temp2)
10999 delete arg2;
11000 }
11001 return resultobj;
11002 fail:
11003 {
11004 if (temp2)
11005 delete arg2;
11006 }
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj = 0;
11013 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11014 wxFileSystem *arg2 = 0 ;
11015 wxString *arg3 = 0 ;
11016 wxFSFile *result = 0 ;
11017 void *argp1 = 0 ;
11018 int res1 = 0 ;
11019 void *argp2 = 0 ;
11020 int res2 = 0 ;
11021 bool temp3 = false ;
11022 PyObject * obj0 = 0 ;
11023 PyObject * obj1 = 0 ;
11024 PyObject * obj2 = 0 ;
11025 char * kwnames[] = {
11026 (char *) "self",(char *) "fs",(char *) "location", NULL
11027 };
11028
11029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11031 if (!SWIG_IsOK(res1)) {
11032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11033 }
11034 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11035 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11036 if (!SWIG_IsOK(res2)) {
11037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11038 }
11039 if (!argp2) {
11040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11041 }
11042 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11043 {
11044 arg3 = wxString_in_helper(obj2);
11045 if (arg3 == NULL) SWIG_fail;
11046 temp3 = true;
11047 }
11048 {
11049 PyThreadState* __tstate = wxPyBeginAllowThreads();
11050 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11051 wxPyEndAllowThreads(__tstate);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 {
11055 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11056 }
11057 {
11058 if (temp3)
11059 delete arg3;
11060 }
11061 return resultobj;
11062 fail:
11063 {
11064 if (temp3)
11065 delete arg3;
11066 }
11067 return NULL;
11068 }
11069
11070
11071 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11072 PyObject *obj;
11073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11074 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11075 return SWIG_Py_Void();
11076 }
11077
11078 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11079 return SWIG_Python_InitShadowInstance(args);
11080 }
11081
11082 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11083 PyObject *resultobj = 0;
11084 wxZipFSHandler *result = 0 ;
11085
11086 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11087 {
11088 PyThreadState* __tstate = wxPyBeginAllowThreads();
11089 result = (wxZipFSHandler *)new wxZipFSHandler();
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11094 return resultobj;
11095 fail:
11096 return NULL;
11097 }
11098
11099
11100 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj = 0;
11102 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11103 wxString *arg2 = 0 ;
11104 bool result;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 bool temp2 = false ;
11108 PyObject * obj0 = 0 ;
11109 PyObject * obj1 = 0 ;
11110 char * kwnames[] = {
11111 (char *) "self",(char *) "location", NULL
11112 };
11113
11114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11116 if (!SWIG_IsOK(res1)) {
11117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11118 }
11119 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11120 {
11121 arg2 = wxString_in_helper(obj1);
11122 if (arg2 == NULL) SWIG_fail;
11123 temp2 = true;
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 {
11132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11133 }
11134 {
11135 if (temp2)
11136 delete arg2;
11137 }
11138 return resultobj;
11139 fail:
11140 {
11141 if (temp2)
11142 delete arg2;
11143 }
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj = 0;
11150 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11151 wxFileSystem *arg2 = 0 ;
11152 wxString *arg3 = 0 ;
11153 wxFSFile *result = 0 ;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 void *argp2 = 0 ;
11157 int res2 = 0 ;
11158 bool temp3 = false ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 PyObject * obj2 = 0 ;
11162 char * kwnames[] = {
11163 (char *) "self",(char *) "fs",(char *) "location", NULL
11164 };
11165
11166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11168 if (!SWIG_IsOK(res1)) {
11169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11170 }
11171 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11173 if (!SWIG_IsOK(res2)) {
11174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11175 }
11176 if (!argp2) {
11177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11178 }
11179 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11180 {
11181 arg3 = wxString_in_helper(obj2);
11182 if (arg3 == NULL) SWIG_fail;
11183 temp3 = true;
11184 }
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 {
11192 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11193 }
11194 {
11195 if (temp3)
11196 delete arg3;
11197 }
11198 return resultobj;
11199 fail:
11200 {
11201 if (temp3)
11202 delete arg3;
11203 }
11204 return NULL;
11205 }
11206
11207
11208 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11209 PyObject *resultobj = 0;
11210 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11211 wxString *arg2 = 0 ;
11212 int arg3 = (int) 0 ;
11213 wxString result;
11214 void *argp1 = 0 ;
11215 int res1 = 0 ;
11216 bool temp2 = false ;
11217 int val3 ;
11218 int ecode3 = 0 ;
11219 PyObject * obj0 = 0 ;
11220 PyObject * obj1 = 0 ;
11221 PyObject * obj2 = 0 ;
11222 char * kwnames[] = {
11223 (char *) "self",(char *) "spec",(char *) "flags", NULL
11224 };
11225
11226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11228 if (!SWIG_IsOK(res1)) {
11229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11230 }
11231 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11232 {
11233 arg2 = wxString_in_helper(obj1);
11234 if (arg2 == NULL) SWIG_fail;
11235 temp2 = true;
11236 }
11237 if (obj2) {
11238 ecode3 = SWIG_AsVal_int(obj2, &val3);
11239 if (!SWIG_IsOK(ecode3)) {
11240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11241 }
11242 arg3 = static_cast< int >(val3);
11243 }
11244 {
11245 PyThreadState* __tstate = wxPyBeginAllowThreads();
11246 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11247 wxPyEndAllowThreads(__tstate);
11248 if (PyErr_Occurred()) SWIG_fail;
11249 }
11250 {
11251 #if wxUSE_UNICODE
11252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11253 #else
11254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11255 #endif
11256 }
11257 {
11258 if (temp2)
11259 delete arg2;
11260 }
11261 return resultobj;
11262 fail:
11263 {
11264 if (temp2)
11265 delete arg2;
11266 }
11267 return NULL;
11268 }
11269
11270
11271 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11272 PyObject *resultobj = 0;
11273 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11274 wxString result;
11275 void *argp1 = 0 ;
11276 int res1 = 0 ;
11277 PyObject *swig_obj[1] ;
11278
11279 if (!args) SWIG_fail;
11280 swig_obj[0] = args;
11281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11282 if (!SWIG_IsOK(res1)) {
11283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11284 }
11285 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (arg1)->FindNext();
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 {
11293 #if wxUSE_UNICODE
11294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11295 #else
11296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11297 #endif
11298 }
11299 return resultobj;
11300 fail:
11301 return NULL;
11302 }
11303
11304
11305 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11306 PyObject *obj;
11307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11308 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11309 return SWIG_Py_Void();
11310 }
11311
11312 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11313 return SWIG_Python_InitShadowInstance(args);
11314 }
11315
11316 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11317 PyObject *resultobj = 0;
11318 wxString *arg1 = 0 ;
11319 wxImage *arg2 = 0 ;
11320 long arg3 ;
11321 bool temp1 = false ;
11322 void *argp2 = 0 ;
11323 int res2 = 0 ;
11324 long val3 ;
11325 int ecode3 = 0 ;
11326 PyObject * obj0 = 0 ;
11327 PyObject * obj1 = 0 ;
11328 PyObject * obj2 = 0 ;
11329 char * kwnames[] = {
11330 (char *) "filename",(char *) "image",(char *) "type", NULL
11331 };
11332
11333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11334 {
11335 arg1 = wxString_in_helper(obj0);
11336 if (arg1 == NULL) SWIG_fail;
11337 temp1 = true;
11338 }
11339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11340 if (!SWIG_IsOK(res2)) {
11341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11342 }
11343 if (!argp2) {
11344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11345 }
11346 arg2 = reinterpret_cast< wxImage * >(argp2);
11347 ecode3 = SWIG_AsVal_long(obj2, &val3);
11348 if (!SWIG_IsOK(ecode3)) {
11349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11350 }
11351 arg3 = static_cast< long >(val3);
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 {
11360 if (temp1)
11361 delete arg1;
11362 }
11363 return resultobj;
11364 fail:
11365 {
11366 if (temp1)
11367 delete arg1;
11368 }
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxString *arg1 = 0 ;
11376 wxBitmap *arg2 = 0 ;
11377 long arg3 ;
11378 bool temp1 = false ;
11379 void *argp2 = 0 ;
11380 int res2 = 0 ;
11381 long val3 ;
11382 int ecode3 = 0 ;
11383 PyObject * obj0 = 0 ;
11384 PyObject * obj1 = 0 ;
11385 PyObject * obj2 = 0 ;
11386 char * kwnames[] = {
11387 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11388 };
11389
11390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11391 {
11392 arg1 = wxString_in_helper(obj0);
11393 if (arg1 == NULL) SWIG_fail;
11394 temp1 = true;
11395 }
11396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11397 if (!SWIG_IsOK(res2)) {
11398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11399 }
11400 if (!argp2) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11402 }
11403 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11404 ecode3 = SWIG_AsVal_long(obj2, &val3);
11405 if (!SWIG_IsOK(ecode3)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11407 }
11408 arg3 = static_cast< long >(val3);
11409 {
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 resultobj = SWIG_Py_Void();
11416 {
11417 if (temp1)
11418 delete arg1;
11419 }
11420 return resultobj;
11421 fail:
11422 {
11423 if (temp1)
11424 delete arg1;
11425 }
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 PyObject *arg2 = (PyObject *) 0 ;
11434 bool temp1 = false ;
11435 PyObject * obj0 = 0 ;
11436 PyObject * obj1 = 0 ;
11437 char * kwnames[] = {
11438 (char *) "filename",(char *) "data", NULL
11439 };
11440
11441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11442 {
11443 arg1 = wxString_in_helper(obj0);
11444 if (arg1 == NULL) SWIG_fail;
11445 temp1 = true;
11446 }
11447 arg2 = obj1;
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 resultobj = SWIG_Py_Void();
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return resultobj;
11460 fail:
11461 {
11462 if (temp1)
11463 delete arg1;
11464 }
11465 return NULL;
11466 }
11467
11468
11469 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470 PyObject *resultobj = 0;
11471 wxMemoryFSHandler *result = 0 ;
11472
11473 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11481 return resultobj;
11482 fail:
11483 return NULL;
11484 }
11485
11486
11487 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj = 0;
11489 wxString *arg1 = 0 ;
11490 bool temp1 = false ;
11491 PyObject * obj0 = 0 ;
11492 char * kwnames[] = {
11493 (char *) "filename", NULL
11494 };
11495
11496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11497 {
11498 arg1 = wxString_in_helper(obj0);
11499 if (arg1 == NULL) SWIG_fail;
11500 temp1 = true;
11501 }
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 resultobj = SWIG_Py_Void();
11509 {
11510 if (temp1)
11511 delete arg1;
11512 }
11513 return resultobj;
11514 fail:
11515 {
11516 if (temp1)
11517 delete arg1;
11518 }
11519 return NULL;
11520 }
11521
11522
11523 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj = 0;
11525 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11526 wxString *arg2 = 0 ;
11527 bool result;
11528 void *argp1 = 0 ;
11529 int res1 = 0 ;
11530 bool temp2 = false ;
11531 PyObject * obj0 = 0 ;
11532 PyObject * obj1 = 0 ;
11533 char * kwnames[] = {
11534 (char *) "self",(char *) "location", NULL
11535 };
11536
11537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11539 if (!SWIG_IsOK(res1)) {
11540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11541 }
11542 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11543 {
11544 arg2 = wxString_in_helper(obj1);
11545 if (arg2 == NULL) SWIG_fail;
11546 temp2 = true;
11547 }
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11556 }
11557 {
11558 if (temp2)
11559 delete arg2;
11560 }
11561 return resultobj;
11562 fail:
11563 {
11564 if (temp2)
11565 delete arg2;
11566 }
11567 return NULL;
11568 }
11569
11570
11571 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11572 PyObject *resultobj = 0;
11573 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11574 wxFileSystem *arg2 = 0 ;
11575 wxString *arg3 = 0 ;
11576 wxFSFile *result = 0 ;
11577 void *argp1 = 0 ;
11578 int res1 = 0 ;
11579 void *argp2 = 0 ;
11580 int res2 = 0 ;
11581 bool temp3 = false ;
11582 PyObject * obj0 = 0 ;
11583 PyObject * obj1 = 0 ;
11584 PyObject * obj2 = 0 ;
11585 char * kwnames[] = {
11586 (char *) "self",(char *) "fs",(char *) "location", NULL
11587 };
11588
11589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11591 if (!SWIG_IsOK(res1)) {
11592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11593 }
11594 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11596 if (!SWIG_IsOK(res2)) {
11597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11598 }
11599 if (!argp2) {
11600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11601 }
11602 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11603 {
11604 arg3 = wxString_in_helper(obj2);
11605 if (arg3 == NULL) SWIG_fail;
11606 temp3 = true;
11607 }
11608 {
11609 PyThreadState* __tstate = wxPyBeginAllowThreads();
11610 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 {
11615 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11616 }
11617 {
11618 if (temp3)
11619 delete arg3;
11620 }
11621 return resultobj;
11622 fail:
11623 {
11624 if (temp3)
11625 delete arg3;
11626 }
11627 return NULL;
11628 }
11629
11630
11631 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj = 0;
11633 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11634 wxString *arg2 = 0 ;
11635 int arg3 = (int) 0 ;
11636 wxString result;
11637 void *argp1 = 0 ;
11638 int res1 = 0 ;
11639 bool temp2 = false ;
11640 int val3 ;
11641 int ecode3 = 0 ;
11642 PyObject * obj0 = 0 ;
11643 PyObject * obj1 = 0 ;
11644 PyObject * obj2 = 0 ;
11645 char * kwnames[] = {
11646 (char *) "self",(char *) "spec",(char *) "flags", NULL
11647 };
11648
11649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11651 if (!SWIG_IsOK(res1)) {
11652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11653 }
11654 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11655 {
11656 arg2 = wxString_in_helper(obj1);
11657 if (arg2 == NULL) SWIG_fail;
11658 temp2 = true;
11659 }
11660 if (obj2) {
11661 ecode3 = SWIG_AsVal_int(obj2, &val3);
11662 if (!SWIG_IsOK(ecode3)) {
11663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11664 }
11665 arg3 = static_cast< int >(val3);
11666 }
11667 {
11668 PyThreadState* __tstate = wxPyBeginAllowThreads();
11669 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11670 wxPyEndAllowThreads(__tstate);
11671 if (PyErr_Occurred()) SWIG_fail;
11672 }
11673 {
11674 #if wxUSE_UNICODE
11675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11676 #else
11677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11678 #endif
11679 }
11680 {
11681 if (temp2)
11682 delete arg2;
11683 }
11684 return resultobj;
11685 fail:
11686 {
11687 if (temp2)
11688 delete arg2;
11689 }
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 PyObject *resultobj = 0;
11696 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11697 wxString result;
11698 void *argp1 = 0 ;
11699 int res1 = 0 ;
11700 PyObject *swig_obj[1] ;
11701
11702 if (!args) SWIG_fail;
11703 swig_obj[0] = args;
11704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11707 }
11708 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (arg1)->FindNext();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 #if wxUSE_UNICODE
11717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11718 #else
11719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11720 #endif
11721 }
11722 return resultobj;
11723 fail:
11724 return NULL;
11725 }
11726
11727
11728 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11729 PyObject *obj;
11730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11731 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11732 return SWIG_Py_Void();
11733 }
11734
11735 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 return SWIG_Python_InitShadowInstance(args);
11737 }
11738
11739 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11740 PyObject *resultobj = 0;
11741 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11742 wxString result;
11743 void *argp1 = 0 ;
11744 int res1 = 0 ;
11745 PyObject *swig_obj[1] ;
11746
11747 if (!args) SWIG_fail;
11748 swig_obj[0] = args;
11749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11750 if (!SWIG_IsOK(res1)) {
11751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11752 }
11753 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11754 {
11755 PyThreadState* __tstate = wxPyBeginAllowThreads();
11756 result = (arg1)->GetName();
11757 wxPyEndAllowThreads(__tstate);
11758 if (PyErr_Occurred()) SWIG_fail;
11759 }
11760 {
11761 #if wxUSE_UNICODE
11762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11763 #else
11764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11765 #endif
11766 }
11767 return resultobj;
11768 fail:
11769 return NULL;
11770 }
11771
11772
11773 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11774 PyObject *resultobj = 0;
11775 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11776 wxString result;
11777 void *argp1 = 0 ;
11778 int res1 = 0 ;
11779 PyObject *swig_obj[1] ;
11780
11781 if (!args) SWIG_fail;
11782 swig_obj[0] = args;
11783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11784 if (!SWIG_IsOK(res1)) {
11785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11786 }
11787 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11788 {
11789 PyThreadState* __tstate = wxPyBeginAllowThreads();
11790 result = (arg1)->GetExtension();
11791 wxPyEndAllowThreads(__tstate);
11792 if (PyErr_Occurred()) SWIG_fail;
11793 }
11794 {
11795 #if wxUSE_UNICODE
11796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11797 #else
11798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11799 #endif
11800 }
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11808 PyObject *resultobj = 0;
11809 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11810 long result;
11811 void *argp1 = 0 ;
11812 int res1 = 0 ;
11813 PyObject *swig_obj[1] ;
11814
11815 if (!args) SWIG_fail;
11816 swig_obj[0] = args;
11817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11820 }
11821 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (long)(arg1)->GetType();
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 resultobj = SWIG_From_long(static_cast< long >(result));
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 PyObject *resultobj = 0;
11837 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11838 wxString result;
11839 void *argp1 = 0 ;
11840 int res1 = 0 ;
11841 PyObject *swig_obj[1] ;
11842
11843 if (!args) SWIG_fail;
11844 swig_obj[0] = args;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11848 }
11849 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (arg1)->GetMimeType();
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 {
11857 #if wxUSE_UNICODE
11858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11859 #else
11860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11861 #endif
11862 }
11863 return resultobj;
11864 fail:
11865 return NULL;
11866 }
11867
11868
11869 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11870 PyObject *resultobj = 0;
11871 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11872 wxString *arg2 = 0 ;
11873 bool result;
11874 void *argp1 = 0 ;
11875 int res1 = 0 ;
11876 bool temp2 = false ;
11877 PyObject * obj0 = 0 ;
11878 PyObject * obj1 = 0 ;
11879 char * kwnames[] = {
11880 (char *) "self",(char *) "name", NULL
11881 };
11882
11883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11887 }
11888 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11889 {
11890 arg2 = wxString_in_helper(obj1);
11891 if (arg2 == NULL) SWIG_fail;
11892 temp2 = true;
11893 }
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11902 }
11903 {
11904 if (temp2)
11905 delete arg2;
11906 }
11907 return resultobj;
11908 fail:
11909 {
11910 if (temp2)
11911 delete arg2;
11912 }
11913 return NULL;
11914 }
11915
11916
11917 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11918 PyObject *resultobj = 0;
11919 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11920 wxInputStream *arg2 = 0 ;
11921 bool result;
11922 void *argp1 = 0 ;
11923 int res1 = 0 ;
11924 wxPyInputStream *temp2 ;
11925 bool created2 ;
11926 PyObject * obj0 = 0 ;
11927 PyObject * obj1 = 0 ;
11928 char * kwnames[] = {
11929 (char *) "self",(char *) "stream", NULL
11930 };
11931
11932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11934 if (!SWIG_IsOK(res1)) {
11935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11936 }
11937 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11938 {
11939 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11940 arg2 = temp2->m_wxis;
11941 created2 = false;
11942 } else {
11943 PyErr_Clear(); // clear the failure of the wxPyConvert above
11944 arg2 = wxPyCBInputStream_create(obj1, false);
11945 if (arg2 == NULL) {
11946 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11947 SWIG_fail;
11948 }
11949 created2 = true;
11950 }
11951 }
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (bool)(arg1)->CanRead(*arg2);
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11960 }
11961 {
11962 if (created2) delete arg2;
11963 }
11964 return resultobj;
11965 fail:
11966 {
11967 if (created2) delete arg2;
11968 }
11969 return NULL;
11970 }
11971
11972
11973 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11974 PyObject *resultobj = 0;
11975 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11976 wxString *arg2 = 0 ;
11977 void *argp1 = 0 ;
11978 int res1 = 0 ;
11979 bool temp2 = false ;
11980 PyObject * obj0 = 0 ;
11981 PyObject * obj1 = 0 ;
11982 char * kwnames[] = {
11983 (char *) "self",(char *) "name", NULL
11984 };
11985
11986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11988 if (!SWIG_IsOK(res1)) {
11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11990 }
11991 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11992 {
11993 arg2 = wxString_in_helper(obj1);
11994 if (arg2 == NULL) SWIG_fail;
11995 temp2 = true;
11996 }
11997 {
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 (arg1)->SetName((wxString const &)*arg2);
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 resultobj = SWIG_Py_Void();
12004 {
12005 if (temp2)
12006 delete arg2;
12007 }
12008 return resultobj;
12009 fail:
12010 {
12011 if (temp2)
12012 delete arg2;
12013 }
12014 return NULL;
12015 }
12016
12017
12018 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12019 PyObject *resultobj = 0;
12020 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12021 wxString *arg2 = 0 ;
12022 void *argp1 = 0 ;
12023 int res1 = 0 ;
12024 bool temp2 = false ;
12025 PyObject * obj0 = 0 ;
12026 PyObject * obj1 = 0 ;
12027 char * kwnames[] = {
12028 (char *) "self",(char *) "extension", NULL
12029 };
12030
12031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12033 if (!SWIG_IsOK(res1)) {
12034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12035 }
12036 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12037 {
12038 arg2 = wxString_in_helper(obj1);
12039 if (arg2 == NULL) SWIG_fail;
12040 temp2 = true;
12041 }
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 (arg1)->SetExtension((wxString const &)*arg2);
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 resultobj = SWIG_Py_Void();
12049 {
12050 if (temp2)
12051 delete arg2;
12052 }
12053 return resultobj;
12054 fail:
12055 {
12056 if (temp2)
12057 delete arg2;
12058 }
12059 return NULL;
12060 }
12061
12062
12063 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12064 PyObject *resultobj = 0;
12065 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12066 long arg2 ;
12067 void *argp1 = 0 ;
12068 int res1 = 0 ;
12069 long val2 ;
12070 int ecode2 = 0 ;
12071 PyObject * obj0 = 0 ;
12072 PyObject * obj1 = 0 ;
12073 char * kwnames[] = {
12074 (char *) "self",(char *) "type", NULL
12075 };
12076
12077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12079 if (!SWIG_IsOK(res1)) {
12080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12081 }
12082 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12083 ecode2 = SWIG_AsVal_long(obj1, &val2);
12084 if (!SWIG_IsOK(ecode2)) {
12085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12086 }
12087 arg2 = static_cast< long >(val2);
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 (arg1)->SetType(arg2);
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 resultobj = SWIG_Py_Void();
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj = 0;
12103 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12104 wxString *arg2 = 0 ;
12105 void *argp1 = 0 ;
12106 int res1 = 0 ;
12107 bool temp2 = false ;
12108 PyObject * obj0 = 0 ;
12109 PyObject * obj1 = 0 ;
12110 char * kwnames[] = {
12111 (char *) "self",(char *) "mimetype", NULL
12112 };
12113
12114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12116 if (!SWIG_IsOK(res1)) {
12117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12118 }
12119 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12120 {
12121 arg2 = wxString_in_helper(obj1);
12122 if (arg2 == NULL) SWIG_fail;
12123 temp2 = true;
12124 }
12125 {
12126 PyThreadState* __tstate = wxPyBeginAllowThreads();
12127 (arg1)->SetMimeType((wxString const &)*arg2);
12128 wxPyEndAllowThreads(__tstate);
12129 if (PyErr_Occurred()) SWIG_fail;
12130 }
12131 resultobj = SWIG_Py_Void();
12132 {
12133 if (temp2)
12134 delete arg2;
12135 }
12136 return resultobj;
12137 fail:
12138 {
12139 if (temp2)
12140 delete arg2;
12141 }
12142 return NULL;
12143 }
12144
12145
12146 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12147 PyObject *obj;
12148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12149 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12150 return SWIG_Py_Void();
12151 }
12152
12153 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154 PyObject *resultobj = 0;
12155 wxPyImageHandler *result = 0 ;
12156
12157 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (wxPyImageHandler *)new wxPyImageHandler();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj = 0;
12173 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12174 PyObject *arg2 = (PyObject *) 0 ;
12175 void *argp1 = 0 ;
12176 int res1 = 0 ;
12177 PyObject * obj0 = 0 ;
12178 PyObject * obj1 = 0 ;
12179 char * kwnames[] = {
12180 (char *) "self",(char *) "self", NULL
12181 };
12182
12183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12185 if (!SWIG_IsOK(res1)) {
12186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12187 }
12188 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12189 arg2 = obj1;
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 (arg1)->_SetSelf(arg2);
12193 wxPyEndAllowThreads(__tstate);
12194 if (PyErr_Occurred()) SWIG_fail;
12195 }
12196 resultobj = SWIG_Py_Void();
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12204 PyObject *obj;
12205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12206 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12207 return SWIG_Py_Void();
12208 }
12209
12210 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 return SWIG_Python_InitShadowInstance(args);
12212 }
12213
12214 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12215 PyObject *resultobj = 0;
12216 wxImageHistogram *result = 0 ;
12217
12218 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (wxImageHistogram *)new wxImageHistogram();
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12233 PyObject *resultobj = 0;
12234 byte arg1 ;
12235 byte arg2 ;
12236 byte arg3 ;
12237 unsigned long result;
12238 unsigned char val1 ;
12239 int ecode1 = 0 ;
12240 unsigned char val2 ;
12241 int ecode2 = 0 ;
12242 unsigned char val3 ;
12243 int ecode3 = 0 ;
12244 PyObject * obj0 = 0 ;
12245 PyObject * obj1 = 0 ;
12246 PyObject * obj2 = 0 ;
12247 char * kwnames[] = {
12248 (char *) "r",(char *) "g",(char *) "b", NULL
12249 };
12250
12251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12252 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12253 if (!SWIG_IsOK(ecode1)) {
12254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12255 }
12256 arg1 = static_cast< byte >(val1);
12257 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12258 if (!SWIG_IsOK(ecode2)) {
12259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12260 }
12261 arg2 = static_cast< byte >(val2);
12262 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12263 if (!SWIG_IsOK(ecode3)) {
12264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12265 }
12266 arg3 = static_cast< byte >(val3);
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12281 PyObject *resultobj = 0;
12282 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12283 byte *arg2 = (byte *) 0 ;
12284 byte *arg3 = (byte *) 0 ;
12285 byte *arg4 = (byte *) 0 ;
12286 byte arg5 = (byte) 1 ;
12287 byte arg6 = (byte) 0 ;
12288 byte arg7 = (byte) 0 ;
12289 bool result;
12290 void *argp1 = 0 ;
12291 int res1 = 0 ;
12292 byte temp2 ;
12293 int res2 = SWIG_TMPOBJ ;
12294 byte temp3 ;
12295 int res3 = SWIG_TMPOBJ ;
12296 byte temp4 ;
12297 int res4 = SWIG_TMPOBJ ;
12298 unsigned char val5 ;
12299 int ecode5 = 0 ;
12300 unsigned char val6 ;
12301 int ecode6 = 0 ;
12302 unsigned char val7 ;
12303 int ecode7 = 0 ;
12304 PyObject * obj0 = 0 ;
12305 PyObject * obj1 = 0 ;
12306 PyObject * obj2 = 0 ;
12307 PyObject * obj3 = 0 ;
12308 char * kwnames[] = {
12309 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12310 };
12311
12312 arg2 = &temp2;
12313 arg3 = &temp3;
12314 arg4 = &temp4;
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12319 }
12320 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12321 if (obj1) {
12322 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12323 if (!SWIG_IsOK(ecode5)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12325 }
12326 arg5 = static_cast< byte >(val5);
12327 }
12328 if (obj2) {
12329 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12330 if (!SWIG_IsOK(ecode6)) {
12331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12332 }
12333 arg6 = static_cast< byte >(val6);
12334 }
12335 if (obj3) {
12336 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12337 if (!SWIG_IsOK(ecode7)) {
12338 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12339 }
12340 arg7 = static_cast< byte >(val7);
12341 }
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12350 }
12351 if (SWIG_IsTmpObj(res2)) {
12352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12353 } else {
12354 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12356 }
12357 if (SWIG_IsTmpObj(res3)) {
12358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12359 } else {
12360 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12362 }
12363 if (SWIG_IsTmpObj(res4)) {
12364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12365 } else {
12366 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12368 }
12369 return resultobj;
12370 fail:
12371 return NULL;
12372 }
12373
12374
12375 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12376 PyObject *resultobj = 0;
12377 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12378 unsigned long arg2 ;
12379 unsigned long result;
12380 void *argp1 = 0 ;
12381 int res1 = 0 ;
12382 unsigned long val2 ;
12383 int ecode2 = 0 ;
12384 PyObject * obj0 = 0 ;
12385 PyObject * obj1 = 0 ;
12386 char * kwnames[] = {
12387 (char *) "self",(char *) "key", NULL
12388 };
12389
12390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12392 if (!SWIG_IsOK(res1)) {
12393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12394 }
12395 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12396 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12397 if (!SWIG_IsOK(ecode2)) {
12398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12399 }
12400 arg2 = static_cast< unsigned long >(val2);
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12417 byte arg2 ;
12418 byte arg3 ;
12419 byte arg4 ;
12420 unsigned long result;
12421 void *argp1 = 0 ;
12422 int res1 = 0 ;
12423 unsigned char val2 ;
12424 int ecode2 = 0 ;
12425 unsigned char val3 ;
12426 int ecode3 = 0 ;
12427 unsigned char val4 ;
12428 int ecode4 = 0 ;
12429 PyObject * obj0 = 0 ;
12430 PyObject * obj1 = 0 ;
12431 PyObject * obj2 = 0 ;
12432 PyObject * obj3 = 0 ;
12433 char * kwnames[] = {
12434 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12435 };
12436
12437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12439 if (!SWIG_IsOK(res1)) {
12440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12441 }
12442 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12443 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12444 if (!SWIG_IsOK(ecode2)) {
12445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12446 }
12447 arg2 = static_cast< byte >(val2);
12448 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12449 if (!SWIG_IsOK(ecode3)) {
12450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12451 }
12452 arg3 = static_cast< byte >(val3);
12453 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12454 if (!SWIG_IsOK(ecode4)) {
12455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12456 }
12457 arg4 = static_cast< byte >(val4);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12474 wxColour *arg2 = 0 ;
12475 unsigned long result;
12476 void *argp1 = 0 ;
12477 int res1 = 0 ;
12478 wxColour temp2 ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 char * kwnames[] = {
12482 (char *) "self",(char *) "colour", NULL
12483 };
12484
12485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12487 if (!SWIG_IsOK(res1)) {
12488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12489 }
12490 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12491 {
12492 arg2 = &temp2;
12493 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12494 }
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12509 PyObject *obj;
12510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12511 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12512 return SWIG_Py_Void();
12513 }
12514
12515 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12516 return SWIG_Python_InitShadowInstance(args);
12517 }
12518
12519 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj = 0;
12521 byte arg1 = (byte) 0 ;
12522 byte arg2 = (byte) 0 ;
12523 byte arg3 = (byte) 0 ;
12524 wxImage_RGBValue *result = 0 ;
12525 unsigned char val1 ;
12526 int ecode1 = 0 ;
12527 unsigned char val2 ;
12528 int ecode2 = 0 ;
12529 unsigned char val3 ;
12530 int ecode3 = 0 ;
12531 PyObject * obj0 = 0 ;
12532 PyObject * obj1 = 0 ;
12533 PyObject * obj2 = 0 ;
12534 char * kwnames[] = {
12535 (char *) "r",(char *) "g",(char *) "b", NULL
12536 };
12537
12538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12539 if (obj0) {
12540 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12541 if (!SWIG_IsOK(ecode1)) {
12542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12543 }
12544 arg1 = static_cast< byte >(val1);
12545 }
12546 if (obj1) {
12547 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12548 if (!SWIG_IsOK(ecode2)) {
12549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12550 }
12551 arg2 = static_cast< byte >(val2);
12552 }
12553 if (obj2) {
12554 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12555 if (!SWIG_IsOK(ecode3)) {
12556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12557 }
12558 arg3 = static_cast< byte >(val3);
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574 PyObject *resultobj = 0;
12575 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12576 byte arg2 ;
12577 void *argp1 = 0 ;
12578 int res1 = 0 ;
12579 unsigned char val2 ;
12580 int ecode2 = 0 ;
12581 PyObject *swig_obj[2] ;
12582
12583 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12585 if (!SWIG_IsOK(res1)) {
12586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12587 }
12588 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12589 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12590 if (!SWIG_IsOK(ecode2)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12592 }
12593 arg2 = static_cast< byte >(val2);
12594 if (arg1) (arg1)->red = arg2;
12595
12596 resultobj = SWIG_Py_Void();
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12604 PyObject *resultobj = 0;
12605 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12606 byte result;
12607 void *argp1 = 0 ;
12608 int res1 = 0 ;
12609 PyObject *swig_obj[1] ;
12610
12611 if (!args) SWIG_fail;
12612 swig_obj[0] = args;
12613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12614 if (!SWIG_IsOK(res1)) {
12615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12616 }
12617 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12618 result = (byte) ((arg1)->red);
12619 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12627 PyObject *resultobj = 0;
12628 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12629 byte arg2 ;
12630 void *argp1 = 0 ;
12631 int res1 = 0 ;
12632 unsigned char val2 ;
12633 int ecode2 = 0 ;
12634 PyObject *swig_obj[2] ;
12635
12636 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12638 if (!SWIG_IsOK(res1)) {
12639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12640 }
12641 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12642 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12643 if (!SWIG_IsOK(ecode2)) {
12644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12645 }
12646 arg2 = static_cast< byte >(val2);
12647 if (arg1) (arg1)->green = arg2;
12648
12649 resultobj = SWIG_Py_Void();
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12657 PyObject *resultobj = 0;
12658 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12659 byte result;
12660 void *argp1 = 0 ;
12661 int res1 = 0 ;
12662 PyObject *swig_obj[1] ;
12663
12664 if (!args) SWIG_fail;
12665 swig_obj[0] = args;
12666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12667 if (!SWIG_IsOK(res1)) {
12668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12669 }
12670 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12671 result = (byte) ((arg1)->green);
12672 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680 PyObject *resultobj = 0;
12681 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12682 byte arg2 ;
12683 void *argp1 = 0 ;
12684 int res1 = 0 ;
12685 unsigned char val2 ;
12686 int ecode2 = 0 ;
12687 PyObject *swig_obj[2] ;
12688
12689 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12691 if (!SWIG_IsOK(res1)) {
12692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12693 }
12694 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12695 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12696 if (!SWIG_IsOK(ecode2)) {
12697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12698 }
12699 arg2 = static_cast< byte >(val2);
12700 if (arg1) (arg1)->blue = arg2;
12701
12702 resultobj = SWIG_Py_Void();
12703 return resultobj;
12704 fail:
12705 return NULL;
12706 }
12707
12708
12709 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12710 PyObject *resultobj = 0;
12711 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12712 byte result;
12713 void *argp1 = 0 ;
12714 int res1 = 0 ;
12715 PyObject *swig_obj[1] ;
12716
12717 if (!args) SWIG_fail;
12718 swig_obj[0] = args;
12719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12720 if (!SWIG_IsOK(res1)) {
12721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12722 }
12723 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12724 result = (byte) ((arg1)->blue);
12725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12733 PyObject *obj;
12734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12735 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12736 return SWIG_Py_Void();
12737 }
12738
12739 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12740 return SWIG_Python_InitShadowInstance(args);
12741 }
12742
12743 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12744 PyObject *resultobj = 0;
12745 double arg1 = (double) 0.0 ;
12746 double arg2 = (double) 0.0 ;
12747 double arg3 = (double) 0.0 ;
12748 wxImage_HSVValue *result = 0 ;
12749 double val1 ;
12750 int ecode1 = 0 ;
12751 double val2 ;
12752 int ecode2 = 0 ;
12753 double val3 ;
12754 int ecode3 = 0 ;
12755 PyObject * obj0 = 0 ;
12756 PyObject * obj1 = 0 ;
12757 PyObject * obj2 = 0 ;
12758 char * kwnames[] = {
12759 (char *) "h",(char *) "s",(char *) "v", NULL
12760 };
12761
12762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12763 if (obj0) {
12764 ecode1 = SWIG_AsVal_double(obj0, &val1);
12765 if (!SWIG_IsOK(ecode1)) {
12766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12767 }
12768 arg1 = static_cast< double >(val1);
12769 }
12770 if (obj1) {
12771 ecode2 = SWIG_AsVal_double(obj1, &val2);
12772 if (!SWIG_IsOK(ecode2)) {
12773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12774 }
12775 arg2 = static_cast< double >(val2);
12776 }
12777 if (obj2) {
12778 ecode3 = SWIG_AsVal_double(obj2, &val3);
12779 if (!SWIG_IsOK(ecode3)) {
12780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12781 }
12782 arg3 = static_cast< double >(val3);
12783 }
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798 PyObject *resultobj = 0;
12799 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12800 double arg2 ;
12801 void *argp1 = 0 ;
12802 int res1 = 0 ;
12803 double val2 ;
12804 int ecode2 = 0 ;
12805 PyObject *swig_obj[2] ;
12806
12807 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12809 if (!SWIG_IsOK(res1)) {
12810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12811 }
12812 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12813 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12814 if (!SWIG_IsOK(ecode2)) {
12815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12816 }
12817 arg2 = static_cast< double >(val2);
12818 if (arg1) (arg1)->hue = arg2;
12819
12820 resultobj = SWIG_Py_Void();
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12828 PyObject *resultobj = 0;
12829 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12830 double result;
12831 void *argp1 = 0 ;
12832 int res1 = 0 ;
12833 PyObject *swig_obj[1] ;
12834
12835 if (!args) SWIG_fail;
12836 swig_obj[0] = args;
12837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12838 if (!SWIG_IsOK(res1)) {
12839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12840 }
12841 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12842 result = (double) ((arg1)->hue);
12843 resultobj = SWIG_From_double(static_cast< double >(result));
12844 return resultobj;
12845 fail:
12846 return NULL;
12847 }
12848
12849
12850 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 PyObject *resultobj = 0;
12852 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12853 double arg2 ;
12854 void *argp1 = 0 ;
12855 int res1 = 0 ;
12856 double val2 ;
12857 int ecode2 = 0 ;
12858 PyObject *swig_obj[2] ;
12859
12860 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12862 if (!SWIG_IsOK(res1)) {
12863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12864 }
12865 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12866 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12867 if (!SWIG_IsOK(ecode2)) {
12868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12869 }
12870 arg2 = static_cast< double >(val2);
12871 if (arg1) (arg1)->saturation = arg2;
12872
12873 resultobj = SWIG_Py_Void();
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12881 PyObject *resultobj = 0;
12882 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12883 double result;
12884 void *argp1 = 0 ;
12885 int res1 = 0 ;
12886 PyObject *swig_obj[1] ;
12887
12888 if (!args) SWIG_fail;
12889 swig_obj[0] = args;
12890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12891 if (!SWIG_IsOK(res1)) {
12892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12893 }
12894 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12895 result = (double) ((arg1)->saturation);
12896 resultobj = SWIG_From_double(static_cast< double >(result));
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 PyObject *resultobj = 0;
12905 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12906 double arg2 ;
12907 void *argp1 = 0 ;
12908 int res1 = 0 ;
12909 double val2 ;
12910 int ecode2 = 0 ;
12911 PyObject *swig_obj[2] ;
12912
12913 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12915 if (!SWIG_IsOK(res1)) {
12916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12917 }
12918 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12919 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12920 if (!SWIG_IsOK(ecode2)) {
12921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12922 }
12923 arg2 = static_cast< double >(val2);
12924 if (arg1) (arg1)->value = arg2;
12925
12926 resultobj = SWIG_Py_Void();
12927 return resultobj;
12928 fail:
12929 return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12934 PyObject *resultobj = 0;
12935 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12936 double result;
12937 void *argp1 = 0 ;
12938 int res1 = 0 ;
12939 PyObject *swig_obj[1] ;
12940
12941 if (!args) SWIG_fail;
12942 swig_obj[0] = args;
12943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12944 if (!SWIG_IsOK(res1)) {
12945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12946 }
12947 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12948 result = (double) ((arg1)->value);
12949 resultobj = SWIG_From_double(static_cast< double >(result));
12950 return resultobj;
12951 fail:
12952 return NULL;
12953 }
12954
12955
12956 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12957 PyObject *obj;
12958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12959 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12960 return SWIG_Py_Void();
12961 }
12962
12963 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12964 return SWIG_Python_InitShadowInstance(args);
12965 }
12966
12967 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12968 PyObject *resultobj = 0;
12969 wxString *arg1 = 0 ;
12970 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12971 int arg3 = (int) -1 ;
12972 wxImage *result = 0 ;
12973 bool temp1 = false ;
12974 long val2 ;
12975 int ecode2 = 0 ;
12976 int val3 ;
12977 int ecode3 = 0 ;
12978 PyObject * obj0 = 0 ;
12979 PyObject * obj1 = 0 ;
12980 PyObject * obj2 = 0 ;
12981 char * kwnames[] = {
12982 (char *) "name",(char *) "type",(char *) "index", NULL
12983 };
12984
12985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12986 {
12987 arg1 = wxString_in_helper(obj0);
12988 if (arg1 == NULL) SWIG_fail;
12989 temp1 = true;
12990 }
12991 if (obj1) {
12992 ecode2 = SWIG_AsVal_long(obj1, &val2);
12993 if (!SWIG_IsOK(ecode2)) {
12994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12995 }
12996 arg2 = static_cast< long >(val2);
12997 }
12998 if (obj2) {
12999 ecode3 = SWIG_AsVal_int(obj2, &val3);
13000 if (!SWIG_IsOK(ecode3)) {
13001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13002 }
13003 arg3 = static_cast< int >(val3);
13004 }
13005 {
13006 PyThreadState* __tstate = wxPyBeginAllowThreads();
13007 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13008 wxPyEndAllowThreads(__tstate);
13009 if (PyErr_Occurred()) SWIG_fail;
13010 }
13011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13012 {
13013 if (temp1)
13014 delete arg1;
13015 }
13016 return resultobj;
13017 fail:
13018 {
13019 if (temp1)
13020 delete arg1;
13021 }
13022 return NULL;
13023 }
13024
13025
13026 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13027 PyObject *resultobj = 0;
13028 wxImage *arg1 = (wxImage *) 0 ;
13029 void *argp1 = 0 ;
13030 int res1 = 0 ;
13031 PyObject *swig_obj[1] ;
13032
13033 if (!args) SWIG_fail;
13034 swig_obj[0] = args;
13035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13036 if (!SWIG_IsOK(res1)) {
13037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13038 }
13039 arg1 = reinterpret_cast< wxImage * >(argp1);
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 delete arg1;
13043
13044 wxPyEndAllowThreads(__tstate);
13045 if (PyErr_Occurred()) SWIG_fail;
13046 }
13047 resultobj = SWIG_Py_Void();
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 wxString *arg1 = 0 ;
13057 wxString *arg2 = 0 ;
13058 int arg3 = (int) -1 ;
13059 wxImage *result = 0 ;
13060 bool temp1 = false ;
13061 bool temp2 = false ;
13062 int val3 ;
13063 int ecode3 = 0 ;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 PyObject * obj2 = 0 ;
13067 char * kwnames[] = {
13068 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13069 };
13070
13071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13072 {
13073 arg1 = wxString_in_helper(obj0);
13074 if (arg1 == NULL) SWIG_fail;
13075 temp1 = true;
13076 }
13077 {
13078 arg2 = wxString_in_helper(obj1);
13079 if (arg2 == NULL) SWIG_fail;
13080 temp2 = true;
13081 }
13082 if (obj2) {
13083 ecode3 = SWIG_AsVal_int(obj2, &val3);
13084 if (!SWIG_IsOK(ecode3)) {
13085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13086 }
13087 arg3 = static_cast< int >(val3);
13088 }
13089 {
13090 PyThreadState* __tstate = wxPyBeginAllowThreads();
13091 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13096 {
13097 if (temp1)
13098 delete arg1;
13099 }
13100 {
13101 if (temp2)
13102 delete arg2;
13103 }
13104 return resultobj;
13105 fail:
13106 {
13107 if (temp1)
13108 delete arg1;
13109 }
13110 {
13111 if (temp2)
13112 delete arg2;
13113 }
13114 return NULL;
13115 }
13116
13117
13118 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13119 PyObject *resultobj = 0;
13120 wxInputStream *arg1 = 0 ;
13121 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13122 int arg3 = (int) -1 ;
13123 wxImage *result = 0 ;
13124 wxPyInputStream *temp1 ;
13125 bool created1 ;
13126 long val2 ;
13127 int ecode2 = 0 ;
13128 int val3 ;
13129 int ecode3 = 0 ;
13130 PyObject * obj0 = 0 ;
13131 PyObject * obj1 = 0 ;
13132 PyObject * obj2 = 0 ;
13133 char * kwnames[] = {
13134 (char *) "stream",(char *) "type",(char *) "index", NULL
13135 };
13136
13137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13138 {
13139 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13140 arg1 = temp1->m_wxis;
13141 created1 = false;
13142 } else {
13143 PyErr_Clear(); // clear the failure of the wxPyConvert above
13144 arg1 = wxPyCBInputStream_create(obj0, false);
13145 if (arg1 == NULL) {
13146 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13147 SWIG_fail;
13148 }
13149 created1 = true;
13150 }
13151 }
13152 if (obj1) {
13153 ecode2 = SWIG_AsVal_long(obj1, &val2);
13154 if (!SWIG_IsOK(ecode2)) {
13155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13156 }
13157 arg2 = static_cast< long >(val2);
13158 }
13159 if (obj2) {
13160 ecode3 = SWIG_AsVal_int(obj2, &val3);
13161 if (!SWIG_IsOK(ecode3)) {
13162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13163 }
13164 arg3 = static_cast< int >(val3);
13165 }
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13173 {
13174 if (created1) delete arg1;
13175 }
13176 return resultobj;
13177 fail:
13178 {
13179 if (created1) delete arg1;
13180 }
13181 return NULL;
13182 }
13183
13184
13185 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13186 PyObject *resultobj = 0;
13187 wxInputStream *arg1 = 0 ;
13188 wxString *arg2 = 0 ;
13189 int arg3 = (int) -1 ;
13190 wxImage *result = 0 ;
13191 wxPyInputStream *temp1 ;
13192 bool created1 ;
13193 bool temp2 = false ;
13194 int val3 ;
13195 int ecode3 = 0 ;
13196 PyObject * obj0 = 0 ;
13197 PyObject * obj1 = 0 ;
13198 PyObject * obj2 = 0 ;
13199 char * kwnames[] = {
13200 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13201 };
13202
13203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13204 {
13205 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13206 arg1 = temp1->m_wxis;
13207 created1 = false;
13208 } else {
13209 PyErr_Clear(); // clear the failure of the wxPyConvert above
13210 arg1 = wxPyCBInputStream_create(obj0, false);
13211 if (arg1 == NULL) {
13212 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13213 SWIG_fail;
13214 }
13215 created1 = true;
13216 }
13217 }
13218 {
13219 arg2 = wxString_in_helper(obj1);
13220 if (arg2 == NULL) SWIG_fail;
13221 temp2 = true;
13222 }
13223 if (obj2) {
13224 ecode3 = SWIG_AsVal_int(obj2, &val3);
13225 if (!SWIG_IsOK(ecode3)) {
13226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13227 }
13228 arg3 = static_cast< int >(val3);
13229 }
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13233 wxPyEndAllowThreads(__tstate);
13234 if (PyErr_Occurred()) SWIG_fail;
13235 }
13236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13237 {
13238 if (created1) delete arg1;
13239 }
13240 {
13241 if (temp2)
13242 delete arg2;
13243 }
13244 return resultobj;
13245 fail:
13246 {
13247 if (created1) delete arg1;
13248 }
13249 {
13250 if (temp2)
13251 delete arg2;
13252 }
13253 return NULL;
13254 }
13255
13256
13257 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj = 0;
13259 int arg1 = (int) 0 ;
13260 int arg2 = (int) 0 ;
13261 bool arg3 = (bool) true ;
13262 wxImage *result = 0 ;
13263 int val1 ;
13264 int ecode1 = 0 ;
13265 int val2 ;
13266 int ecode2 = 0 ;
13267 bool val3 ;
13268 int ecode3 = 0 ;
13269 PyObject * obj0 = 0 ;
13270 PyObject * obj1 = 0 ;
13271 PyObject * obj2 = 0 ;
13272 char * kwnames[] = {
13273 (char *) "width",(char *) "height",(char *) "clear", NULL
13274 };
13275
13276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13277 if (obj0) {
13278 ecode1 = SWIG_AsVal_int(obj0, &val1);
13279 if (!SWIG_IsOK(ecode1)) {
13280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13281 }
13282 arg1 = static_cast< int >(val1);
13283 }
13284 if (obj1) {
13285 ecode2 = SWIG_AsVal_int(obj1, &val2);
13286 if (!SWIG_IsOK(ecode2)) {
13287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13288 }
13289 arg2 = static_cast< int >(val2);
13290 }
13291 if (obj2) {
13292 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13293 if (!SWIG_IsOK(ecode3)) {
13294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13295 }
13296 arg3 = static_cast< bool >(val3);
13297 }
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj = 0;
13313 wxBitmap *arg1 = 0 ;
13314 wxImage *result = 0 ;
13315 void *argp1 = 0 ;
13316 int res1 = 0 ;
13317 PyObject * obj0 = 0 ;
13318 char * kwnames[] = {
13319 (char *) "bitmap", NULL
13320 };
13321
13322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13323 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13326 }
13327 if (!argp1) {
13328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13329 }
13330 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13331 {
13332 if (!wxPyCheckForApp()) SWIG_fail;
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13346 PyObject *resultobj = 0;
13347 int arg1 ;
13348 int arg2 ;
13349 buffer arg3 ;
13350 int arg4 ;
13351 wxImage *result = 0 ;
13352 int val1 ;
13353 int ecode1 = 0 ;
13354 int val2 ;
13355 int ecode2 = 0 ;
13356 PyObject * obj0 = 0 ;
13357 PyObject * obj1 = 0 ;
13358 PyObject * obj2 = 0 ;
13359 char * kwnames[] = {
13360 (char *) "width",(char *) "height",(char *) "data", NULL
13361 };
13362
13363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13364 ecode1 = SWIG_AsVal_int(obj0, &val1);
13365 if (!SWIG_IsOK(ecode1)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13367 }
13368 arg1 = static_cast< int >(val1);
13369 ecode2 = SWIG_AsVal_int(obj1, &val2);
13370 if (!SWIG_IsOK(ecode2)) {
13371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13372 }
13373 arg2 = static_cast< int >(val2);
13374 {
13375 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13376 }
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj = 0;
13392 int arg1 ;
13393 int arg2 ;
13394 buffer arg3 ;
13395 int arg4 ;
13396 buffer arg5 ;
13397 int arg6 ;
13398 wxImage *result = 0 ;
13399 int val1 ;
13400 int ecode1 = 0 ;
13401 int val2 ;
13402 int ecode2 = 0 ;
13403 PyObject * obj0 = 0 ;
13404 PyObject * obj1 = 0 ;
13405 PyObject * obj2 = 0 ;
13406 PyObject * obj3 = 0 ;
13407 char * kwnames[] = {
13408 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13409 };
13410
13411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13412 ecode1 = SWIG_AsVal_int(obj0, &val1);
13413 if (!SWIG_IsOK(ecode1)) {
13414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13415 }
13416 arg1 = static_cast< int >(val1);
13417 ecode2 = SWIG_AsVal_int(obj1, &val2);
13418 if (!SWIG_IsOK(ecode2)) {
13419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13420 }
13421 arg2 = static_cast< int >(val2);
13422 {
13423 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13424 }
13425 {
13426 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13427 }
13428 {
13429 PyThreadState* __tstate = wxPyBeginAllowThreads();
13430 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13431 wxPyEndAllowThreads(__tstate);
13432 if (PyErr_Occurred()) SWIG_fail;
13433 }
13434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13435 return resultobj;
13436 fail:
13437 return NULL;
13438 }
13439
13440
13441 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13442 PyObject *resultobj = 0;
13443 wxImage *arg1 = (wxImage *) 0 ;
13444 int arg2 ;
13445 int arg3 ;
13446 bool arg4 = (bool) true ;
13447 void *argp1 = 0 ;
13448 int res1 = 0 ;
13449 int val2 ;
13450 int ecode2 = 0 ;
13451 int val3 ;
13452 int ecode3 = 0 ;
13453 bool val4 ;
13454 int ecode4 = 0 ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 PyObject * obj2 = 0 ;
13458 PyObject * obj3 = 0 ;
13459 char * kwnames[] = {
13460 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13461 };
13462
13463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13465 if (!SWIG_IsOK(res1)) {
13466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13467 }
13468 arg1 = reinterpret_cast< wxImage * >(argp1);
13469 ecode2 = SWIG_AsVal_int(obj1, &val2);
13470 if (!SWIG_IsOK(ecode2)) {
13471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13472 }
13473 arg2 = static_cast< int >(val2);
13474 ecode3 = SWIG_AsVal_int(obj2, &val3);
13475 if (!SWIG_IsOK(ecode3)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13477 }
13478 arg3 = static_cast< int >(val3);
13479 if (obj3) {
13480 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13481 if (!SWIG_IsOK(ecode4)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13483 }
13484 arg4 = static_cast< bool >(val4);
13485 }
13486 {
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 (arg1)->Create(arg2,arg3,arg4);
13489 wxPyEndAllowThreads(__tstate);
13490 if (PyErr_Occurred()) SWIG_fail;
13491 }
13492 resultobj = SWIG_Py_Void();
13493 return resultobj;
13494 fail:
13495 return NULL;
13496 }
13497
13498
13499 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13500 PyObject *resultobj = 0;
13501 wxImage *arg1 = (wxImage *) 0 ;
13502 void *argp1 = 0 ;
13503 int res1 = 0 ;
13504 PyObject *swig_obj[1] ;
13505
13506 if (!args) SWIG_fail;
13507 swig_obj[0] = args;
13508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13509 if (!SWIG_IsOK(res1)) {
13510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13511 }
13512 arg1 = reinterpret_cast< wxImage * >(argp1);
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 (arg1)->Destroy();
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 resultobj = SWIG_Py_Void();
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj = 0;
13528 wxImage *arg1 = (wxImage *) 0 ;
13529 int arg2 ;
13530 int arg3 ;
13531 SwigValueWrapper<wxImage > result;
13532 void *argp1 = 0 ;
13533 int res1 = 0 ;
13534 int val2 ;
13535 int ecode2 = 0 ;
13536 int val3 ;
13537 int ecode3 = 0 ;
13538 PyObject * obj0 = 0 ;
13539 PyObject * obj1 = 0 ;
13540 PyObject * obj2 = 0 ;
13541 char * kwnames[] = {
13542 (char *) "self",(char *) "width",(char *) "height", NULL
13543 };
13544
13545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13547 if (!SWIG_IsOK(res1)) {
13548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13549 }
13550 arg1 = reinterpret_cast< wxImage * >(argp1);
13551 ecode2 = SWIG_AsVal_int(obj1, &val2);
13552 if (!SWIG_IsOK(ecode2)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13554 }
13555 arg2 = static_cast< int >(val2);
13556 ecode3 = SWIG_AsVal_int(obj2, &val3);
13557 if (!SWIG_IsOK(ecode3)) {
13558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13559 }
13560 arg3 = static_cast< int >(val3);
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (arg1)->Scale(arg2,arg3);
13564 wxPyEndAllowThreads(__tstate);
13565 if (PyErr_Occurred()) SWIG_fail;
13566 }
13567 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13568 return resultobj;
13569 fail:
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13575 PyObject *resultobj = 0;
13576 wxImage *arg1 = (wxImage *) 0 ;
13577 int arg2 ;
13578 int arg3 ;
13579 SwigValueWrapper<wxImage > result;
13580 void *argp1 = 0 ;
13581 int res1 = 0 ;
13582 int val2 ;
13583 int ecode2 = 0 ;
13584 int val3 ;
13585 int ecode3 = 0 ;
13586 PyObject * obj0 = 0 ;
13587 PyObject * obj1 = 0 ;
13588 PyObject * obj2 = 0 ;
13589 char * kwnames[] = {
13590 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13591 };
13592
13593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13595 if (!SWIG_IsOK(res1)) {
13596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13597 }
13598 arg1 = reinterpret_cast< wxImage * >(argp1);
13599 ecode2 = SWIG_AsVal_int(obj1, &val2);
13600 if (!SWIG_IsOK(ecode2)) {
13601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13602 }
13603 arg2 = static_cast< int >(val2);
13604 ecode3 = SWIG_AsVal_int(obj2, &val3);
13605 if (!SWIG_IsOK(ecode3)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13607 }
13608 arg3 = static_cast< int >(val3);
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 int arg2 ;
13626 int arg3 ;
13627 wxImage *result = 0 ;
13628 void *argp1 = 0 ;
13629 int res1 = 0 ;
13630 int val2 ;
13631 int ecode2 = 0 ;
13632 int val3 ;
13633 int ecode3 = 0 ;
13634 PyObject * obj0 = 0 ;
13635 PyObject * obj1 = 0 ;
13636 PyObject * obj2 = 0 ;
13637 char * kwnames[] = {
13638 (char *) "self",(char *) "width",(char *) "height", NULL
13639 };
13640
13641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13643 if (!SWIG_IsOK(res1)) {
13644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13645 }
13646 arg1 = reinterpret_cast< wxImage * >(argp1);
13647 ecode2 = SWIG_AsVal_int(obj1, &val2);
13648 if (!SWIG_IsOK(ecode2)) {
13649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13650 }
13651 arg2 = static_cast< int >(val2);
13652 ecode3 = SWIG_AsVal_int(obj2, &val3);
13653 if (!SWIG_IsOK(ecode3)) {
13654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13655 }
13656 arg3 = static_cast< int >(val3);
13657 {
13658 PyThreadState* __tstate = wxPyBeginAllowThreads();
13659 {
13660 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13661 result = (wxImage *) &_result_ref;
13662 }
13663 wxPyEndAllowThreads(__tstate);
13664 if (PyErr_Occurred()) SWIG_fail;
13665 }
13666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13667 return resultobj;
13668 fail:
13669 return NULL;
13670 }
13671
13672
13673 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13674 PyObject *resultobj = 0;
13675 wxImage *arg1 = (wxImage *) 0 ;
13676 wxSize *arg2 = 0 ;
13677 wxPoint *arg3 = 0 ;
13678 int arg4 = (int) -1 ;
13679 int arg5 = (int) -1 ;
13680 int arg6 = (int) -1 ;
13681 wxImage *result = 0 ;
13682 void *argp1 = 0 ;
13683 int res1 = 0 ;
13684 wxSize temp2 ;
13685 wxPoint temp3 ;
13686 int val4 ;
13687 int ecode4 = 0 ;
13688 int val5 ;
13689 int ecode5 = 0 ;
13690 int val6 ;
13691 int ecode6 = 0 ;
13692 PyObject * obj0 = 0 ;
13693 PyObject * obj1 = 0 ;
13694 PyObject * obj2 = 0 ;
13695 PyObject * obj3 = 0 ;
13696 PyObject * obj4 = 0 ;
13697 PyObject * obj5 = 0 ;
13698 char * kwnames[] = {
13699 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13700 };
13701
13702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13704 if (!SWIG_IsOK(res1)) {
13705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13706 }
13707 arg1 = reinterpret_cast< wxImage * >(argp1);
13708 {
13709 arg2 = &temp2;
13710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13711 }
13712 {
13713 arg3 = &temp3;
13714 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13715 }
13716 if (obj3) {
13717 ecode4 = SWIG_AsVal_int(obj3, &val4);
13718 if (!SWIG_IsOK(ecode4)) {
13719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13720 }
13721 arg4 = static_cast< int >(val4);
13722 }
13723 if (obj4) {
13724 ecode5 = SWIG_AsVal_int(obj4, &val5);
13725 if (!SWIG_IsOK(ecode5)) {
13726 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13727 }
13728 arg5 = static_cast< int >(val5);
13729 }
13730 if (obj5) {
13731 ecode6 = SWIG_AsVal_int(obj5, &val6);
13732 if (!SWIG_IsOK(ecode6)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13734 }
13735 arg6 = static_cast< int >(val6);
13736 }
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 {
13740 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13741 result = (wxImage *) &_result_ref;
13742 }
13743 wxPyEndAllowThreads(__tstate);
13744 if (PyErr_Occurred()) SWIG_fail;
13745 }
13746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13747 return resultobj;
13748 fail:
13749 return NULL;
13750 }
13751
13752
13753 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13754 PyObject *resultobj = 0;
13755 wxImage *arg1 = (wxImage *) 0 ;
13756 int arg2 ;
13757 int arg3 ;
13758 byte arg4 ;
13759 byte arg5 ;
13760 byte arg6 ;
13761 void *argp1 = 0 ;
13762 int res1 = 0 ;
13763 int val2 ;
13764 int ecode2 = 0 ;
13765 int val3 ;
13766 int ecode3 = 0 ;
13767 unsigned char val4 ;
13768 int ecode4 = 0 ;
13769 unsigned char val5 ;
13770 int ecode5 = 0 ;
13771 unsigned char val6 ;
13772 int ecode6 = 0 ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 PyObject * obj3 = 0 ;
13777 PyObject * obj4 = 0 ;
13778 PyObject * obj5 = 0 ;
13779 char * kwnames[] = {
13780 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13781 };
13782
13783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13787 }
13788 arg1 = reinterpret_cast< wxImage * >(argp1);
13789 ecode2 = SWIG_AsVal_int(obj1, &val2);
13790 if (!SWIG_IsOK(ecode2)) {
13791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13792 }
13793 arg2 = static_cast< int >(val2);
13794 ecode3 = SWIG_AsVal_int(obj2, &val3);
13795 if (!SWIG_IsOK(ecode3)) {
13796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13797 }
13798 arg3 = static_cast< int >(val3);
13799 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13800 if (!SWIG_IsOK(ecode4)) {
13801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13802 }
13803 arg4 = static_cast< byte >(val4);
13804 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13805 if (!SWIG_IsOK(ecode5)) {
13806 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13807 }
13808 arg5 = static_cast< byte >(val5);
13809 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13810 if (!SWIG_IsOK(ecode6)) {
13811 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13812 }
13813 arg6 = static_cast< byte >(val6);
13814 {
13815 PyThreadState* __tstate = wxPyBeginAllowThreads();
13816 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 resultobj = SWIG_Py_Void();
13821 return resultobj;
13822 fail:
13823 return NULL;
13824 }
13825
13826
13827 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13828 PyObject *resultobj = 0;
13829 wxImage *arg1 = (wxImage *) 0 ;
13830 wxRect *arg2 = 0 ;
13831 byte arg3 ;
13832 byte arg4 ;
13833 byte arg5 ;
13834 void *argp1 = 0 ;
13835 int res1 = 0 ;
13836 wxRect temp2 ;
13837 unsigned char val3 ;
13838 int ecode3 = 0 ;
13839 unsigned char val4 ;
13840 int ecode4 = 0 ;
13841 unsigned char val5 ;
13842 int ecode5 = 0 ;
13843 PyObject * obj0 = 0 ;
13844 PyObject * obj1 = 0 ;
13845 PyObject * obj2 = 0 ;
13846 PyObject * obj3 = 0 ;
13847 PyObject * obj4 = 0 ;
13848 char * kwnames[] = {
13849 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13850 };
13851
13852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13854 if (!SWIG_IsOK(res1)) {
13855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13856 }
13857 arg1 = reinterpret_cast< wxImage * >(argp1);
13858 {
13859 arg2 = &temp2;
13860 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13861 }
13862 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13863 if (!SWIG_IsOK(ecode3)) {
13864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13865 }
13866 arg3 = static_cast< byte >(val3);
13867 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13868 if (!SWIG_IsOK(ecode4)) {
13869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13870 }
13871 arg4 = static_cast< byte >(val4);
13872 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13873 if (!SWIG_IsOK(ecode5)) {
13874 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13875 }
13876 arg5 = static_cast< byte >(val5);
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_Py_Void();
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxImage *arg1 = (wxImage *) 0 ;
13893 int arg2 ;
13894 int arg3 ;
13895 byte result;
13896 void *argp1 = 0 ;
13897 int res1 = 0 ;
13898 int val2 ;
13899 int ecode2 = 0 ;
13900 int val3 ;
13901 int ecode3 = 0 ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "self",(char *) "x",(char *) "y", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13911 if (!SWIG_IsOK(res1)) {
13912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13913 }
13914 arg1 = reinterpret_cast< wxImage * >(argp1);
13915 ecode2 = SWIG_AsVal_int(obj1, &val2);
13916 if (!SWIG_IsOK(ecode2)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13918 }
13919 arg2 = static_cast< int >(val2);
13920 ecode3 = SWIG_AsVal_int(obj2, &val3);
13921 if (!SWIG_IsOK(ecode3)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13923 }
13924 arg3 = static_cast< int >(val3);
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 result = (byte)(arg1)->GetRed(arg2,arg3);
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj = 0;
13940 wxImage *arg1 = (wxImage *) 0 ;
13941 int arg2 ;
13942 int arg3 ;
13943 byte result;
13944 void *argp1 = 0 ;
13945 int res1 = 0 ;
13946 int val2 ;
13947 int ecode2 = 0 ;
13948 int val3 ;
13949 int ecode3 = 0 ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13952 PyObject * obj2 = 0 ;
13953 char * kwnames[] = {
13954 (char *) "self",(char *) "x",(char *) "y", NULL
13955 };
13956
13957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13959 if (!SWIG_IsOK(res1)) {
13960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13961 }
13962 arg1 = reinterpret_cast< wxImage * >(argp1);
13963 ecode2 = SWIG_AsVal_int(obj1, &val2);
13964 if (!SWIG_IsOK(ecode2)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13966 }
13967 arg2 = static_cast< int >(val2);
13968 ecode3 = SWIG_AsVal_int(obj2, &val3);
13969 if (!SWIG_IsOK(ecode3)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13971 }
13972 arg3 = static_cast< int >(val3);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (byte)(arg1)->GetGreen(arg2,arg3);
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj = 0;
13988 wxImage *arg1 = (wxImage *) 0 ;
13989 int arg2 ;
13990 int arg3 ;
13991 byte result;
13992 void *argp1 = 0 ;
13993 int res1 = 0 ;
13994 int val2 ;
13995 int ecode2 = 0 ;
13996 int val3 ;
13997 int ecode3 = 0 ;
13998 PyObject * obj0 = 0 ;
13999 PyObject * obj1 = 0 ;
14000 PyObject * obj2 = 0 ;
14001 char * kwnames[] = {
14002 (char *) "self",(char *) "x",(char *) "y", NULL
14003 };
14004
14005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14007 if (!SWIG_IsOK(res1)) {
14008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14009 }
14010 arg1 = reinterpret_cast< wxImage * >(argp1);
14011 ecode2 = SWIG_AsVal_int(obj1, &val2);
14012 if (!SWIG_IsOK(ecode2)) {
14013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14014 }
14015 arg2 = static_cast< int >(val2);
14016 ecode3 = SWIG_AsVal_int(obj2, &val3);
14017 if (!SWIG_IsOK(ecode3)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14019 }
14020 arg3 = static_cast< int >(val3);
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 result = (byte)(arg1)->GetBlue(arg2,arg3);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14028 return resultobj;
14029 fail:
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14035 PyObject *resultobj = 0;
14036 wxImage *arg1 = (wxImage *) 0 ;
14037 int arg2 ;
14038 int arg3 ;
14039 byte arg4 ;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 int val2 ;
14043 int ecode2 = 0 ;
14044 int val3 ;
14045 int ecode3 = 0 ;
14046 unsigned char val4 ;
14047 int ecode4 = 0 ;
14048 PyObject * obj0 = 0 ;
14049 PyObject * obj1 = 0 ;
14050 PyObject * obj2 = 0 ;
14051 PyObject * obj3 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14054 };
14055
14056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14060 }
14061 arg1 = reinterpret_cast< wxImage * >(argp1);
14062 ecode2 = SWIG_AsVal_int(obj1, &val2);
14063 if (!SWIG_IsOK(ecode2)) {
14064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14065 }
14066 arg2 = static_cast< int >(val2);
14067 ecode3 = SWIG_AsVal_int(obj2, &val3);
14068 if (!SWIG_IsOK(ecode3)) {
14069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14070 }
14071 arg3 = static_cast< int >(val3);
14072 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14073 if (!SWIG_IsOK(ecode4)) {
14074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14075 }
14076 arg4 = static_cast< byte >(val4);
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 (arg1)->SetAlpha(arg2,arg3,arg4);
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 resultobj = SWIG_Py_Void();
14084 return resultobj;
14085 fail:
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxImage *arg1 = (wxImage *) 0 ;
14093 int arg2 ;
14094 int arg3 ;
14095 byte result;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 int val2 ;
14099 int ecode2 = 0 ;
14100 int val3 ;
14101 int ecode3 = 0 ;
14102 PyObject * obj0 = 0 ;
14103 PyObject * obj1 = 0 ;
14104 PyObject * obj2 = 0 ;
14105 char * kwnames[] = {
14106 (char *) "self",(char *) "x",(char *) "y", NULL
14107 };
14108
14109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14111 if (!SWIG_IsOK(res1)) {
14112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14113 }
14114 arg1 = reinterpret_cast< wxImage * >(argp1);
14115 ecode2 = SWIG_AsVal_int(obj1, &val2);
14116 if (!SWIG_IsOK(ecode2)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14118 }
14119 arg2 = static_cast< int >(val2);
14120 ecode3 = SWIG_AsVal_int(obj2, &val3);
14121 if (!SWIG_IsOK(ecode3)) {
14122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14123 }
14124 arg3 = static_cast< int >(val3);
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14132 return resultobj;
14133 fail:
14134 return NULL;
14135 }
14136
14137
14138 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14139 PyObject *resultobj = 0;
14140 wxImage *arg1 = (wxImage *) 0 ;
14141 bool result;
14142 void *argp1 = 0 ;
14143 int res1 = 0 ;
14144 PyObject *swig_obj[1] ;
14145
14146 if (!args) SWIG_fail;
14147 swig_obj[0] = args;
14148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14149 if (!SWIG_IsOK(res1)) {
14150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14151 }
14152 arg1 = reinterpret_cast< wxImage * >(argp1);
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 result = (bool)(arg1)->HasAlpha();
14156 wxPyEndAllowThreads(__tstate);
14157 if (PyErr_Occurred()) SWIG_fail;
14158 }
14159 {
14160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14161 }
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14169 PyObject *resultobj = 0;
14170 wxImage *arg1 = (wxImage *) 0 ;
14171 void *argp1 = 0 ;
14172 int res1 = 0 ;
14173 PyObject *swig_obj[1] ;
14174
14175 if (!args) SWIG_fail;
14176 swig_obj[0] = args;
14177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14178 if (!SWIG_IsOK(res1)) {
14179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14180 }
14181 arg1 = reinterpret_cast< wxImage * >(argp1);
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 (arg1)->InitAlpha();
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 resultobj = SWIG_Py_Void();
14189 return resultobj;
14190 fail:
14191 return NULL;
14192 }
14193
14194
14195 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14196 PyObject *resultobj = 0;
14197 wxImage *arg1 = (wxImage *) 0 ;
14198 int arg2 ;
14199 int arg3 ;
14200 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14201 bool result;
14202 void *argp1 = 0 ;
14203 int res1 = 0 ;
14204 int val2 ;
14205 int ecode2 = 0 ;
14206 int val3 ;
14207 int ecode3 = 0 ;
14208 unsigned char val4 ;
14209 int ecode4 = 0 ;
14210 PyObject * obj0 = 0 ;
14211 PyObject * obj1 = 0 ;
14212 PyObject * obj2 = 0 ;
14213 PyObject * obj3 = 0 ;
14214 char * kwnames[] = {
14215 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14216 };
14217
14218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14220 if (!SWIG_IsOK(res1)) {
14221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14222 }
14223 arg1 = reinterpret_cast< wxImage * >(argp1);
14224 ecode2 = SWIG_AsVal_int(obj1, &val2);
14225 if (!SWIG_IsOK(ecode2)) {
14226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14227 }
14228 arg2 = static_cast< int >(val2);
14229 ecode3 = SWIG_AsVal_int(obj2, &val3);
14230 if (!SWIG_IsOK(ecode3)) {
14231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14232 }
14233 arg3 = static_cast< int >(val3);
14234 if (obj3) {
14235 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14236 if (!SWIG_IsOK(ecode4)) {
14237 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14238 }
14239 arg4 = static_cast< byte >(val4);
14240 }
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 {
14248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14249 }
14250 return resultobj;
14251 fail:
14252 return NULL;
14253 }
14254
14255
14256 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14257 PyObject *resultobj = 0;
14258 wxImage *arg1 = (wxImage *) 0 ;
14259 byte *arg2 = (byte *) 0 ;
14260 byte *arg3 = (byte *) 0 ;
14261 byte *arg4 = (byte *) 0 ;
14262 byte arg5 = (byte) 0 ;
14263 byte arg6 = (byte) 0 ;
14264 byte arg7 = (byte) 0 ;
14265 bool result;
14266 void *argp1 = 0 ;
14267 int res1 = 0 ;
14268 byte temp2 ;
14269 int res2 = SWIG_TMPOBJ ;
14270 byte temp3 ;
14271 int res3 = SWIG_TMPOBJ ;
14272 byte temp4 ;
14273 int res4 = SWIG_TMPOBJ ;
14274 unsigned char val5 ;
14275 int ecode5 = 0 ;
14276 unsigned char val6 ;
14277 int ecode6 = 0 ;
14278 unsigned char val7 ;
14279 int ecode7 = 0 ;
14280 PyObject * obj0 = 0 ;
14281 PyObject * obj1 = 0 ;
14282 PyObject * obj2 = 0 ;
14283 PyObject * obj3 = 0 ;
14284 char * kwnames[] = {
14285 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14286 };
14287
14288 arg2 = &temp2;
14289 arg3 = &temp3;
14290 arg4 = &temp4;
14291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14293 if (!SWIG_IsOK(res1)) {
14294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14295 }
14296 arg1 = reinterpret_cast< wxImage * >(argp1);
14297 if (obj1) {
14298 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14299 if (!SWIG_IsOK(ecode5)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14301 }
14302 arg5 = static_cast< byte >(val5);
14303 }
14304 if (obj2) {
14305 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14306 if (!SWIG_IsOK(ecode6)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14308 }
14309 arg6 = static_cast< byte >(val6);
14310 }
14311 if (obj3) {
14312 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14313 if (!SWIG_IsOK(ecode7)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14315 }
14316 arg7 = static_cast< byte >(val7);
14317 }
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 {
14325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14326 }
14327 if (SWIG_IsTmpObj(res2)) {
14328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14329 } else {
14330 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14332 }
14333 if (SWIG_IsTmpObj(res3)) {
14334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14335 } else {
14336 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14337 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14338 }
14339 if (SWIG_IsTmpObj(res4)) {
14340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14341 } else {
14342 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14344 }
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14352 PyObject *resultobj = 0;
14353 wxImage *arg1 = (wxImage *) 0 ;
14354 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14355 bool result;
14356 void *argp1 = 0 ;
14357 int res1 = 0 ;
14358 unsigned char val2 ;
14359 int ecode2 = 0 ;
14360 PyObject * obj0 = 0 ;
14361 PyObject * obj1 = 0 ;
14362 char * kwnames[] = {
14363 (char *) "self",(char *) "threshold", NULL
14364 };
14365
14366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14368 if (!SWIG_IsOK(res1)) {
14369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14370 }
14371 arg1 = reinterpret_cast< wxImage * >(argp1);
14372 if (obj1) {
14373 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14374 if (!SWIG_IsOK(ecode2)) {
14375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14376 }
14377 arg2 = static_cast< byte >(val2);
14378 }
14379 {
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 {
14386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14387 }
14388 return resultobj;
14389 fail:
14390 return NULL;
14391 }
14392
14393
14394 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14395 PyObject *resultobj = 0;
14396 wxImage *arg1 = (wxImage *) 0 ;
14397 byte arg2 ;
14398 byte arg3 ;
14399 byte arg4 ;
14400 bool result;
14401 void *argp1 = 0 ;
14402 int res1 = 0 ;
14403 unsigned char val2 ;
14404 int ecode2 = 0 ;
14405 unsigned char val3 ;
14406 int ecode3 = 0 ;
14407 unsigned char val4 ;
14408 int ecode4 = 0 ;
14409 PyObject * obj0 = 0 ;
14410 PyObject * obj1 = 0 ;
14411 PyObject * obj2 = 0 ;
14412 PyObject * obj3 = 0 ;
14413 char * kwnames[] = {
14414 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14415 };
14416
14417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14419 if (!SWIG_IsOK(res1)) {
14420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14421 }
14422 arg1 = reinterpret_cast< wxImage * >(argp1);
14423 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14424 if (!SWIG_IsOK(ecode2)) {
14425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14426 }
14427 arg2 = static_cast< byte >(val2);
14428 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14429 if (!SWIG_IsOK(ecode3)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14431 }
14432 arg3 = static_cast< byte >(val3);
14433 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14434 if (!SWIG_IsOK(ecode4)) {
14435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14436 }
14437 arg4 = static_cast< byte >(val4);
14438 {
14439 PyThreadState* __tstate = wxPyBeginAllowThreads();
14440 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14441 wxPyEndAllowThreads(__tstate);
14442 if (PyErr_Occurred()) SWIG_fail;
14443 }
14444 {
14445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14446 }
14447 return resultobj;
14448 fail:
14449 return NULL;
14450 }
14451
14452
14453 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14454 PyObject *resultobj = 0;
14455 wxImage *arg1 = (wxImage *) 0 ;
14456 wxImage *arg2 = 0 ;
14457 byte arg3 ;
14458 byte arg4 ;
14459 byte arg5 ;
14460 bool result;
14461 void *argp1 = 0 ;
14462 int res1 = 0 ;
14463 void *argp2 = 0 ;
14464 int res2 = 0 ;
14465 unsigned char val3 ;
14466 int ecode3 = 0 ;
14467 unsigned char val4 ;
14468 int ecode4 = 0 ;
14469 unsigned char val5 ;
14470 int ecode5 = 0 ;
14471 PyObject * obj0 = 0 ;
14472 PyObject * obj1 = 0 ;
14473 PyObject * obj2 = 0 ;
14474 PyObject * obj3 = 0 ;
14475 PyObject * obj4 = 0 ;
14476 char * kwnames[] = {
14477 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14478 };
14479
14480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14482 if (!SWIG_IsOK(res1)) {
14483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14484 }
14485 arg1 = reinterpret_cast< wxImage * >(argp1);
14486 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14487 if (!SWIG_IsOK(res2)) {
14488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14489 }
14490 if (!argp2) {
14491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14492 }
14493 arg2 = reinterpret_cast< wxImage * >(argp2);
14494 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14495 if (!SWIG_IsOK(ecode3)) {
14496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14497 }
14498 arg3 = static_cast< byte >(val3);
14499 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14500 if (!SWIG_IsOK(ecode4)) {
14501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14502 }
14503 arg4 = static_cast< byte >(val4);
14504 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14505 if (!SWIG_IsOK(ecode5)) {
14506 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14507 }
14508 arg5 = static_cast< byte >(val5);
14509 {
14510 PyThreadState* __tstate = wxPyBeginAllowThreads();
14511 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 {
14516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14517 }
14518 return resultobj;
14519 fail:
14520 return NULL;
14521 }
14522
14523
14524 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14525 PyObject *resultobj = 0;
14526 wxString *arg1 = 0 ;
14527 bool result;
14528 bool temp1 = false ;
14529 PyObject * obj0 = 0 ;
14530 char * kwnames[] = {
14531 (char *) "filename", NULL
14532 };
14533
14534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14535 {
14536 arg1 = wxString_in_helper(obj0);
14537 if (arg1 == NULL) SWIG_fail;
14538 temp1 = true;
14539 }
14540 {
14541 PyThreadState* __tstate = wxPyBeginAllowThreads();
14542 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 {
14547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14548 }
14549 {
14550 if (temp1)
14551 delete arg1;
14552 }
14553 return resultobj;
14554 fail:
14555 {
14556 if (temp1)
14557 delete arg1;
14558 }
14559 return NULL;
14560 }
14561
14562
14563 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj = 0;
14565 wxString *arg1 = 0 ;
14566 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14567 int result;
14568 bool temp1 = false ;
14569 long val2 ;
14570 int ecode2 = 0 ;
14571 PyObject * obj0 = 0 ;
14572 PyObject * obj1 = 0 ;
14573 char * kwnames[] = {
14574 (char *) "filename",(char *) "type", NULL
14575 };
14576
14577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14578 {
14579 arg1 = wxString_in_helper(obj0);
14580 if (arg1 == NULL) SWIG_fail;
14581 temp1 = true;
14582 }
14583 if (obj1) {
14584 ecode2 = SWIG_AsVal_long(obj1, &val2);
14585 if (!SWIG_IsOK(ecode2)) {
14586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14587 }
14588 arg2 = static_cast< long >(val2);
14589 }
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 resultobj = SWIG_From_int(static_cast< int >(result));
14597 {
14598 if (temp1)
14599 delete arg1;
14600 }
14601 return resultobj;
14602 fail:
14603 {
14604 if (temp1)
14605 delete arg1;
14606 }
14607 return NULL;
14608 }
14609
14610
14611 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14612 PyObject *resultobj = 0;
14613 wxImage *arg1 = (wxImage *) 0 ;
14614 wxString *arg2 = 0 ;
14615 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14616 int arg4 = (int) -1 ;
14617 bool result;
14618 void *argp1 = 0 ;
14619 int res1 = 0 ;
14620 bool temp2 = false ;
14621 long val3 ;
14622 int ecode3 = 0 ;
14623 int val4 ;
14624 int ecode4 = 0 ;
14625 PyObject * obj0 = 0 ;
14626 PyObject * obj1 = 0 ;
14627 PyObject * obj2 = 0 ;
14628 PyObject * obj3 = 0 ;
14629 char * kwnames[] = {
14630 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14631 };
14632
14633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14635 if (!SWIG_IsOK(res1)) {
14636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14637 }
14638 arg1 = reinterpret_cast< wxImage * >(argp1);
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 if (obj2) {
14645 ecode3 = SWIG_AsVal_long(obj2, &val3);
14646 if (!SWIG_IsOK(ecode3)) {
14647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14648 }
14649 arg3 = static_cast< long >(val3);
14650 }
14651 if (obj3) {
14652 ecode4 = SWIG_AsVal_int(obj3, &val4);
14653 if (!SWIG_IsOK(ecode4)) {
14654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14655 }
14656 arg4 = static_cast< int >(val4);
14657 }
14658 {
14659 PyThreadState* __tstate = wxPyBeginAllowThreads();
14660 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 {
14665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14666 }
14667 {
14668 if (temp2)
14669 delete arg2;
14670 }
14671 return resultobj;
14672 fail:
14673 {
14674 if (temp2)
14675 delete arg2;
14676 }
14677 return NULL;
14678 }
14679
14680
14681 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14682 PyObject *resultobj = 0;
14683 wxImage *arg1 = (wxImage *) 0 ;
14684 wxString *arg2 = 0 ;
14685 wxString *arg3 = 0 ;
14686 int arg4 = (int) -1 ;
14687 bool result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 bool temp2 = false ;
14691 bool temp3 = false ;
14692 int val4 ;
14693 int ecode4 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 PyObject * obj2 = 0 ;
14697 PyObject * obj3 = 0 ;
14698 char * kwnames[] = {
14699 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14700 };
14701
14702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14704 if (!SWIG_IsOK(res1)) {
14705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14706 }
14707 arg1 = reinterpret_cast< wxImage * >(argp1);
14708 {
14709 arg2 = wxString_in_helper(obj1);
14710 if (arg2 == NULL) SWIG_fail;
14711 temp2 = true;
14712 }
14713 {
14714 arg3 = wxString_in_helper(obj2);
14715 if (arg3 == NULL) SWIG_fail;
14716 temp3 = true;
14717 }
14718 if (obj3) {
14719 ecode4 = SWIG_AsVal_int(obj3, &val4);
14720 if (!SWIG_IsOK(ecode4)) {
14721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14722 }
14723 arg4 = static_cast< int >(val4);
14724 }
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 {
14732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14733 }
14734 {
14735 if (temp2)
14736 delete arg2;
14737 }
14738 {
14739 if (temp3)
14740 delete arg3;
14741 }
14742 return resultobj;
14743 fail:
14744 {
14745 if (temp2)
14746 delete arg2;
14747 }
14748 {
14749 if (temp3)
14750 delete arg3;
14751 }
14752 return NULL;
14753 }
14754
14755
14756 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj = 0;
14758 wxImage *arg1 = (wxImage *) 0 ;
14759 wxString *arg2 = 0 ;
14760 int arg3 ;
14761 bool result;
14762 void *argp1 = 0 ;
14763 int res1 = 0 ;
14764 bool temp2 = false ;
14765 int val3 ;
14766 int ecode3 = 0 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 PyObject * obj2 = 0 ;
14770 char * kwnames[] = {
14771 (char *) "self",(char *) "name",(char *) "type", NULL
14772 };
14773
14774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14776 if (!SWIG_IsOK(res1)) {
14777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14778 }
14779 arg1 = reinterpret_cast< wxImage * >(argp1);
14780 {
14781 arg2 = wxString_in_helper(obj1);
14782 if (arg2 == NULL) SWIG_fail;
14783 temp2 = true;
14784 }
14785 ecode3 = SWIG_AsVal_int(obj2, &val3);
14786 if (!SWIG_IsOK(ecode3)) {
14787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14788 }
14789 arg3 = static_cast< int >(val3);
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 {
14797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14798 }
14799 {
14800 if (temp2)
14801 delete arg2;
14802 }
14803 return resultobj;
14804 fail:
14805 {
14806 if (temp2)
14807 delete arg2;
14808 }
14809 return NULL;
14810 }
14811
14812
14813 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj = 0;
14815 wxImage *arg1 = (wxImage *) 0 ;
14816 wxString *arg2 = 0 ;
14817 wxString *arg3 = 0 ;
14818 bool result;
14819 void *argp1 = 0 ;
14820 int res1 = 0 ;
14821 bool temp2 = false ;
14822 bool temp3 = false ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 char * kwnames[] = {
14827 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14828 };
14829
14830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14834 }
14835 arg1 = reinterpret_cast< wxImage * >(argp1);
14836 {
14837 arg2 = wxString_in_helper(obj1);
14838 if (arg2 == NULL) SWIG_fail;
14839 temp2 = true;
14840 }
14841 {
14842 arg3 = wxString_in_helper(obj2);
14843 if (arg3 == NULL) SWIG_fail;
14844 temp3 = true;
14845 }
14846 {
14847 PyThreadState* __tstate = wxPyBeginAllowThreads();
14848 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14849 wxPyEndAllowThreads(__tstate);
14850 if (PyErr_Occurred()) SWIG_fail;
14851 }
14852 {
14853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14854 }
14855 {
14856 if (temp2)
14857 delete arg2;
14858 }
14859 {
14860 if (temp3)
14861 delete arg3;
14862 }
14863 return resultobj;
14864 fail:
14865 {
14866 if (temp2)
14867 delete arg2;
14868 }
14869 {
14870 if (temp3)
14871 delete arg3;
14872 }
14873 return NULL;
14874 }
14875
14876
14877 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14878 PyObject *resultobj = 0;
14879 wxInputStream *arg1 = 0 ;
14880 bool result;
14881 wxPyInputStream *temp1 ;
14882 bool created1 ;
14883 PyObject * obj0 = 0 ;
14884 char * kwnames[] = {
14885 (char *) "stream", NULL
14886 };
14887
14888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14889 {
14890 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14891 arg1 = temp1->m_wxis;
14892 created1 = false;
14893 } else {
14894 PyErr_Clear(); // clear the failure of the wxPyConvert above
14895 arg1 = wxPyCBInputStream_create(obj0, false);
14896 if (arg1 == NULL) {
14897 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14898 SWIG_fail;
14899 }
14900 created1 = true;
14901 }
14902 }
14903 {
14904 PyThreadState* __tstate = wxPyBeginAllowThreads();
14905 result = (bool)wxImage::CanRead(*arg1);
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 {
14910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14911 }
14912 {
14913 if (created1) delete arg1;
14914 }
14915 return resultobj;
14916 fail:
14917 {
14918 if (created1) delete arg1;
14919 }
14920 return NULL;
14921 }
14922
14923
14924 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14925 PyObject *resultobj = 0;
14926 wxImage *arg1 = (wxImage *) 0 ;
14927 wxInputStream *arg2 = 0 ;
14928 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14929 int arg4 = (int) -1 ;
14930 bool result;
14931 void *argp1 = 0 ;
14932 int res1 = 0 ;
14933 wxPyInputStream *temp2 ;
14934 bool created2 ;
14935 long val3 ;
14936 int ecode3 = 0 ;
14937 int val4 ;
14938 int ecode4 = 0 ;
14939 PyObject * obj0 = 0 ;
14940 PyObject * obj1 = 0 ;
14941 PyObject * obj2 = 0 ;
14942 PyObject * obj3 = 0 ;
14943 char * kwnames[] = {
14944 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14945 };
14946
14947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14949 if (!SWIG_IsOK(res1)) {
14950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14951 }
14952 arg1 = reinterpret_cast< wxImage * >(argp1);
14953 {
14954 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14955 arg2 = temp2->m_wxis;
14956 created2 = false;
14957 } else {
14958 PyErr_Clear(); // clear the failure of the wxPyConvert above
14959 arg2 = wxPyCBInputStream_create(obj1, false);
14960 if (arg2 == NULL) {
14961 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14962 SWIG_fail;
14963 }
14964 created2 = true;
14965 }
14966 }
14967 if (obj2) {
14968 ecode3 = SWIG_AsVal_long(obj2, &val3);
14969 if (!SWIG_IsOK(ecode3)) {
14970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14971 }
14972 arg3 = static_cast< long >(val3);
14973 }
14974 if (obj3) {
14975 ecode4 = SWIG_AsVal_int(obj3, &val4);
14976 if (!SWIG_IsOK(ecode4)) {
14977 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14978 }
14979 arg4 = static_cast< int >(val4);
14980 }
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 {
14988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14989 }
14990 {
14991 if (created2) delete arg2;
14992 }
14993 return resultobj;
14994 fail:
14995 {
14996 if (created2) delete arg2;
14997 }
14998 return NULL;
14999 }
15000
15001
15002 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15003 PyObject *resultobj = 0;
15004 wxImage *arg1 = (wxImage *) 0 ;
15005 wxInputStream *arg2 = 0 ;
15006 wxString *arg3 = 0 ;
15007 int arg4 = (int) -1 ;
15008 bool result;
15009 void *argp1 = 0 ;
15010 int res1 = 0 ;
15011 wxPyInputStream *temp2 ;
15012 bool created2 ;
15013 bool temp3 = false ;
15014 int val4 ;
15015 int ecode4 = 0 ;
15016 PyObject * obj0 = 0 ;
15017 PyObject * obj1 = 0 ;
15018 PyObject * obj2 = 0 ;
15019 PyObject * obj3 = 0 ;
15020 char * kwnames[] = {
15021 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15022 };
15023
15024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15028 }
15029 arg1 = reinterpret_cast< wxImage * >(argp1);
15030 {
15031 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15032 arg2 = temp2->m_wxis;
15033 created2 = false;
15034 } else {
15035 PyErr_Clear(); // clear the failure of the wxPyConvert above
15036 arg2 = wxPyCBInputStream_create(obj1, false);
15037 if (arg2 == NULL) {
15038 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15039 SWIG_fail;
15040 }
15041 created2 = true;
15042 }
15043 }
15044 {
15045 arg3 = wxString_in_helper(obj2);
15046 if (arg3 == NULL) SWIG_fail;
15047 temp3 = true;
15048 }
15049 if (obj3) {
15050 ecode4 = SWIG_AsVal_int(obj3, &val4);
15051 if (!SWIG_IsOK(ecode4)) {
15052 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15053 }
15054 arg4 = static_cast< int >(val4);
15055 }
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 {
15063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15064 }
15065 {
15066 if (created2) delete arg2;
15067 }
15068 {
15069 if (temp3)
15070 delete arg3;
15071 }
15072 return resultobj;
15073 fail:
15074 {
15075 if (created2) delete arg2;
15076 }
15077 {
15078 if (temp3)
15079 delete arg3;
15080 }
15081 return NULL;
15082 }
15083
15084
15085 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15086 PyObject *resultobj = 0;
15087 wxImage *arg1 = (wxImage *) 0 ;
15088 bool result;
15089 void *argp1 = 0 ;
15090 int res1 = 0 ;
15091 PyObject *swig_obj[1] ;
15092
15093 if (!args) SWIG_fail;
15094 swig_obj[0] = args;
15095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15096 if (!SWIG_IsOK(res1)) {
15097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15098 }
15099 arg1 = reinterpret_cast< wxImage * >(argp1);
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 result = (bool)(arg1)->Ok();
15103 wxPyEndAllowThreads(__tstate);
15104 if (PyErr_Occurred()) SWIG_fail;
15105 }
15106 {
15107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15108 }
15109 return resultobj;
15110 fail:
15111 return NULL;
15112 }
15113
15114
15115 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15116 PyObject *resultobj = 0;
15117 wxImage *arg1 = (wxImage *) 0 ;
15118 int result;
15119 void *argp1 = 0 ;
15120 int res1 = 0 ;
15121 PyObject *swig_obj[1] ;
15122
15123 if (!args) SWIG_fail;
15124 swig_obj[0] = args;
15125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15126 if (!SWIG_IsOK(res1)) {
15127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15128 }
15129 arg1 = reinterpret_cast< wxImage * >(argp1);
15130 {
15131 PyThreadState* __tstate = wxPyBeginAllowThreads();
15132 result = (int)(arg1)->GetWidth();
15133 wxPyEndAllowThreads(__tstate);
15134 if (PyErr_Occurred()) SWIG_fail;
15135 }
15136 resultobj = SWIG_From_int(static_cast< int >(result));
15137 return resultobj;
15138 fail:
15139 return NULL;
15140 }
15141
15142
15143 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15144 PyObject *resultobj = 0;
15145 wxImage *arg1 = (wxImage *) 0 ;
15146 int result;
15147 void *argp1 = 0 ;
15148 int res1 = 0 ;
15149 PyObject *swig_obj[1] ;
15150
15151 if (!args) SWIG_fail;
15152 swig_obj[0] = args;
15153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15154 if (!SWIG_IsOK(res1)) {
15155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15156 }
15157 arg1 = reinterpret_cast< wxImage * >(argp1);
15158 {
15159 PyThreadState* __tstate = wxPyBeginAllowThreads();
15160 result = (int)(arg1)->GetHeight();
15161 wxPyEndAllowThreads(__tstate);
15162 if (PyErr_Occurred()) SWIG_fail;
15163 }
15164 resultobj = SWIG_From_int(static_cast< int >(result));
15165 return resultobj;
15166 fail:
15167 return NULL;
15168 }
15169
15170
15171 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15172 PyObject *resultobj = 0;
15173 wxImage *arg1 = (wxImage *) 0 ;
15174 wxSize result;
15175 void *argp1 = 0 ;
15176 int res1 = 0 ;
15177 PyObject *swig_obj[1] ;
15178
15179 if (!args) SWIG_fail;
15180 swig_obj[0] = args;
15181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15182 if (!SWIG_IsOK(res1)) {
15183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15184 }
15185 arg1 = reinterpret_cast< wxImage * >(argp1);
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = wxImage_GetSize(arg1);
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15200 PyObject *resultobj = 0;
15201 wxImage *arg1 = (wxImage *) 0 ;
15202 wxRect *arg2 = 0 ;
15203 SwigValueWrapper<wxImage > result;
15204 void *argp1 = 0 ;
15205 int res1 = 0 ;
15206 wxRect temp2 ;
15207 PyObject * obj0 = 0 ;
15208 PyObject * obj1 = 0 ;
15209 char * kwnames[] = {
15210 (char *) "self",(char *) "rect", NULL
15211 };
15212
15213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15215 if (!SWIG_IsOK(res1)) {
15216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15217 }
15218 arg1 = reinterpret_cast< wxImage * >(argp1);
15219 {
15220 arg2 = &temp2;
15221 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15222 }
15223 {
15224 PyThreadState* __tstate = wxPyBeginAllowThreads();
15225 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15226 wxPyEndAllowThreads(__tstate);
15227 if (PyErr_Occurred()) SWIG_fail;
15228 }
15229 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15230 return resultobj;
15231 fail:
15232 return NULL;
15233 }
15234
15235
15236 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj = 0;
15238 wxImage *arg1 = (wxImage *) 0 ;
15239 wxSize *arg2 = 0 ;
15240 wxPoint *arg3 = 0 ;
15241 int arg4 = (int) -1 ;
15242 int arg5 = (int) -1 ;
15243 int arg6 = (int) -1 ;
15244 SwigValueWrapper<wxImage > result;
15245 void *argp1 = 0 ;
15246 int res1 = 0 ;
15247 wxSize temp2 ;
15248 wxPoint temp3 ;
15249 int val4 ;
15250 int ecode4 = 0 ;
15251 int val5 ;
15252 int ecode5 = 0 ;
15253 int val6 ;
15254 int ecode6 = 0 ;
15255 PyObject * obj0 = 0 ;
15256 PyObject * obj1 = 0 ;
15257 PyObject * obj2 = 0 ;
15258 PyObject * obj3 = 0 ;
15259 PyObject * obj4 = 0 ;
15260 PyObject * obj5 = 0 ;
15261 char * kwnames[] = {
15262 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15263 };
15264
15265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15267 if (!SWIG_IsOK(res1)) {
15268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15269 }
15270 arg1 = reinterpret_cast< wxImage * >(argp1);
15271 {
15272 arg2 = &temp2;
15273 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15274 }
15275 {
15276 arg3 = &temp3;
15277 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15278 }
15279 if (obj3) {
15280 ecode4 = SWIG_AsVal_int(obj3, &val4);
15281 if (!SWIG_IsOK(ecode4)) {
15282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15283 }
15284 arg4 = static_cast< int >(val4);
15285 }
15286 if (obj4) {
15287 ecode5 = SWIG_AsVal_int(obj4, &val5);
15288 if (!SWIG_IsOK(ecode5)) {
15289 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15290 }
15291 arg5 = static_cast< int >(val5);
15292 }
15293 if (obj5) {
15294 ecode6 = SWIG_AsVal_int(obj5, &val6);
15295 if (!SWIG_IsOK(ecode6)) {
15296 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15297 }
15298 arg6 = static_cast< int >(val6);
15299 }
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15314 PyObject *resultobj = 0;
15315 wxImage *arg1 = (wxImage *) 0 ;
15316 SwigValueWrapper<wxImage > result;
15317 void *argp1 = 0 ;
15318 int res1 = 0 ;
15319 PyObject *swig_obj[1] ;
15320
15321 if (!args) SWIG_fail;
15322 swig_obj[0] = args;
15323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15324 if (!SWIG_IsOK(res1)) {
15325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15326 }
15327 arg1 = reinterpret_cast< wxImage * >(argp1);
15328 {
15329 PyThreadState* __tstate = wxPyBeginAllowThreads();
15330 result = (arg1)->Copy();
15331 wxPyEndAllowThreads(__tstate);
15332 if (PyErr_Occurred()) SWIG_fail;
15333 }
15334 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15335 return resultobj;
15336 fail:
15337 return NULL;
15338 }
15339
15340
15341 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15342 PyObject *resultobj = 0;
15343 wxImage *arg1 = (wxImage *) 0 ;
15344 wxImage *arg2 = 0 ;
15345 int arg3 ;
15346 int arg4 ;
15347 void *argp1 = 0 ;
15348 int res1 = 0 ;
15349 void *argp2 = 0 ;
15350 int res2 = 0 ;
15351 int val3 ;
15352 int ecode3 = 0 ;
15353 int val4 ;
15354 int ecode4 = 0 ;
15355 PyObject * obj0 = 0 ;
15356 PyObject * obj1 = 0 ;
15357 PyObject * obj2 = 0 ;
15358 PyObject * obj3 = 0 ;
15359 char * kwnames[] = {
15360 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15361 };
15362
15363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15365 if (!SWIG_IsOK(res1)) {
15366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15367 }
15368 arg1 = reinterpret_cast< wxImage * >(argp1);
15369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15370 if (!SWIG_IsOK(res2)) {
15371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15372 }
15373 if (!argp2) {
15374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15375 }
15376 arg2 = reinterpret_cast< wxImage * >(argp2);
15377 ecode3 = SWIG_AsVal_int(obj2, &val3);
15378 if (!SWIG_IsOK(ecode3)) {
15379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15380 }
15381 arg3 = static_cast< int >(val3);
15382 ecode4 = SWIG_AsVal_int(obj3, &val4);
15383 if (!SWIG_IsOK(ecode4)) {
15384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15385 }
15386 arg4 = static_cast< int >(val4);
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15390 wxPyEndAllowThreads(__tstate);
15391 if (PyErr_Occurred()) SWIG_fail;
15392 }
15393 resultobj = SWIG_Py_Void();
15394 return resultobj;
15395 fail:
15396 return NULL;
15397 }
15398
15399
15400 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15401 PyObject *resultobj = 0;
15402 wxImage *arg1 = (wxImage *) 0 ;
15403 PyObject *result = 0 ;
15404 void *argp1 = 0 ;
15405 int res1 = 0 ;
15406 PyObject *swig_obj[1] ;
15407
15408 if (!args) SWIG_fail;
15409 swig_obj[0] = args;
15410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15411 if (!SWIG_IsOK(res1)) {
15412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15413 }
15414 arg1 = reinterpret_cast< wxImage * >(argp1);
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 result = (PyObject *)wxImage_GetData(arg1);
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 resultobj = result;
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj = 0;
15430 wxImage *arg1 = (wxImage *) 0 ;
15431 buffer arg2 ;
15432 int arg3 ;
15433 void *argp1 = 0 ;
15434 int res1 = 0 ;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char * kwnames[] = {
15438 (char *) "self",(char *) "data", NULL
15439 };
15440
15441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15443 if (!SWIG_IsOK(res1)) {
15444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15445 }
15446 arg1 = reinterpret_cast< wxImage * >(argp1);
15447 {
15448 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15449 }
15450 {
15451 PyThreadState* __tstate = wxPyBeginAllowThreads();
15452 wxImage_SetData(arg1,arg2,arg3);
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 resultobj = SWIG_Py_Void();
15457 return resultobj;
15458 fail:
15459 return NULL;
15460 }
15461
15462
15463 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15464 PyObject *resultobj = 0;
15465 wxImage *arg1 = (wxImage *) 0 ;
15466 PyObject *result = 0 ;
15467 void *argp1 = 0 ;
15468 int res1 = 0 ;
15469 PyObject *swig_obj[1] ;
15470
15471 if (!args) SWIG_fail;
15472 swig_obj[0] = args;
15473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15474 if (!SWIG_IsOK(res1)) {
15475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15476 }
15477 arg1 = reinterpret_cast< wxImage * >(argp1);
15478 {
15479 PyThreadState* __tstate = wxPyBeginAllowThreads();
15480 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15481 wxPyEndAllowThreads(__tstate);
15482 if (PyErr_Occurred()) SWIG_fail;
15483 }
15484 resultobj = result;
15485 return resultobj;
15486 fail:
15487 return NULL;
15488 }
15489
15490
15491 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15492 PyObject *resultobj = 0;
15493 wxImage *arg1 = (wxImage *) 0 ;
15494 buffer arg2 ;
15495 int arg3 ;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 PyObject * obj0 = 0 ;
15499 PyObject * obj1 = 0 ;
15500 char * kwnames[] = {
15501 (char *) "self",(char *) "data", NULL
15502 };
15503
15504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15506 if (!SWIG_IsOK(res1)) {
15507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15508 }
15509 arg1 = reinterpret_cast< wxImage * >(argp1);
15510 {
15511 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15512 }
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 wxImage_SetDataBuffer(arg1,arg2,arg3);
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 resultobj = SWIG_Py_Void();
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15527 PyObject *resultobj = 0;
15528 wxImage *arg1 = (wxImage *) 0 ;
15529 PyObject *result = 0 ;
15530 void *argp1 = 0 ;
15531 int res1 = 0 ;
15532 PyObject *swig_obj[1] ;
15533
15534 if (!args) SWIG_fail;
15535 swig_obj[0] = args;
15536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15537 if (!SWIG_IsOK(res1)) {
15538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15539 }
15540 arg1 = reinterpret_cast< wxImage * >(argp1);
15541 {
15542 PyThreadState* __tstate = wxPyBeginAllowThreads();
15543 result = (PyObject *)wxImage_GetAlphaData(arg1);
15544 wxPyEndAllowThreads(__tstate);
15545 if (PyErr_Occurred()) SWIG_fail;
15546 }
15547 resultobj = result;
15548 return resultobj;
15549 fail:
15550 return NULL;
15551 }
15552
15553
15554 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15555 PyObject *resultobj = 0;
15556 wxImage *arg1 = (wxImage *) 0 ;
15557 buffer arg2 ;
15558 int arg3 ;
15559 void *argp1 = 0 ;
15560 int res1 = 0 ;
15561 PyObject * obj0 = 0 ;
15562 PyObject * obj1 = 0 ;
15563 char * kwnames[] = {
15564 (char *) "self",(char *) "alpha", NULL
15565 };
15566
15567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15569 if (!SWIG_IsOK(res1)) {
15570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15571 }
15572 arg1 = reinterpret_cast< wxImage * >(argp1);
15573 {
15574 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15575 }
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 wxImage_SetAlphaData(arg1,arg2,arg3);
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 resultobj = SWIG_Py_Void();
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15590 PyObject *resultobj = 0;
15591 wxImage *arg1 = (wxImage *) 0 ;
15592 PyObject *result = 0 ;
15593 void *argp1 = 0 ;
15594 int res1 = 0 ;
15595 PyObject *swig_obj[1] ;
15596
15597 if (!args) SWIG_fail;
15598 swig_obj[0] = args;
15599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15602 }
15603 arg1 = reinterpret_cast< wxImage * >(argp1);
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 resultobj = result;
15611 return resultobj;
15612 fail:
15613 return NULL;
15614 }
15615
15616
15617 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15618 PyObject *resultobj = 0;
15619 wxImage *arg1 = (wxImage *) 0 ;
15620 buffer arg2 ;
15621 int arg3 ;
15622 void *argp1 = 0 ;
15623 int res1 = 0 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 char * kwnames[] = {
15627 (char *) "self",(char *) "alpha", NULL
15628 };
15629
15630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15634 }
15635 arg1 = reinterpret_cast< wxImage * >(argp1);
15636 {
15637 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15638 }
15639 {
15640 PyThreadState* __tstate = wxPyBeginAllowThreads();
15641 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15642 wxPyEndAllowThreads(__tstate);
15643 if (PyErr_Occurred()) SWIG_fail;
15644 }
15645 resultobj = SWIG_Py_Void();
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15653 PyObject *resultobj = 0;
15654 wxImage *arg1 = (wxImage *) 0 ;
15655 byte arg2 ;
15656 byte arg3 ;
15657 byte arg4 ;
15658 void *argp1 = 0 ;
15659 int res1 = 0 ;
15660 unsigned char val2 ;
15661 int ecode2 = 0 ;
15662 unsigned char val3 ;
15663 int ecode3 = 0 ;
15664 unsigned char val4 ;
15665 int ecode4 = 0 ;
15666 PyObject * obj0 = 0 ;
15667 PyObject * obj1 = 0 ;
15668 PyObject * obj2 = 0 ;
15669 PyObject * obj3 = 0 ;
15670 char * kwnames[] = {
15671 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15672 };
15673
15674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15676 if (!SWIG_IsOK(res1)) {
15677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15678 }
15679 arg1 = reinterpret_cast< wxImage * >(argp1);
15680 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15681 if (!SWIG_IsOK(ecode2)) {
15682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15683 }
15684 arg2 = static_cast< byte >(val2);
15685 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15686 if (!SWIG_IsOK(ecode3)) {
15687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15688 }
15689 arg3 = static_cast< byte >(val3);
15690 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15691 if (!SWIG_IsOK(ecode4)) {
15692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15693 }
15694 arg4 = static_cast< byte >(val4);
15695 {
15696 PyThreadState* __tstate = wxPyBeginAllowThreads();
15697 (arg1)->SetMaskColour(arg2,arg3,arg4);
15698 wxPyEndAllowThreads(__tstate);
15699 if (PyErr_Occurred()) SWIG_fail;
15700 }
15701 resultobj = SWIG_Py_Void();
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15709 PyObject *resultobj = 0;
15710 wxImage *arg1 = (wxImage *) 0 ;
15711 byte *arg2 = (byte *) 0 ;
15712 byte *arg3 = (byte *) 0 ;
15713 byte *arg4 = (byte *) 0 ;
15714 void *argp1 = 0 ;
15715 int res1 = 0 ;
15716 byte temp2 ;
15717 int res2 = SWIG_TMPOBJ ;
15718 byte temp3 ;
15719 int res3 = SWIG_TMPOBJ ;
15720 byte temp4 ;
15721 int res4 = SWIG_TMPOBJ ;
15722 PyObject *swig_obj[1] ;
15723
15724 arg2 = &temp2;
15725 arg3 = &temp3;
15726 arg4 = &temp4;
15727 if (!args) SWIG_fail;
15728 swig_obj[0] = args;
15729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15730 if (!SWIG_IsOK(res1)) {
15731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15732 }
15733 arg1 = reinterpret_cast< wxImage * >(argp1);
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15737 wxPyEndAllowThreads(__tstate);
15738 if (PyErr_Occurred()) SWIG_fail;
15739 }
15740 resultobj = SWIG_Py_Void();
15741 if (SWIG_IsTmpObj(res2)) {
15742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15743 } else {
15744 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15746 }
15747 if (SWIG_IsTmpObj(res3)) {
15748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15749 } else {
15750 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15752 }
15753 if (SWIG_IsTmpObj(res4)) {
15754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15755 } else {
15756 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15758 }
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxImage *arg1 = (wxImage *) 0 ;
15768 byte result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15778 }
15779 arg1 = reinterpret_cast< wxImage * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (byte)(arg1)->GetMaskRed();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxImage *arg1 = (wxImage *) 0 ;
15796 byte result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15806 }
15807 arg1 = reinterpret_cast< wxImage * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (byte)(arg1)->GetMaskGreen();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxImage *arg1 = (wxImage *) 0 ;
15824 byte result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15834 }
15835 arg1 = reinterpret_cast< wxImage * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (byte)(arg1)->GetMaskBlue();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15850 PyObject *resultobj = 0;
15851 wxImage *arg1 = (wxImage *) 0 ;
15852 bool arg2 = (bool) true ;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 bool val2 ;
15856 int ecode2 = 0 ;
15857 PyObject * obj0 = 0 ;
15858 PyObject * obj1 = 0 ;
15859 char * kwnames[] = {
15860 (char *) "self",(char *) "mask", NULL
15861 };
15862
15863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15865 if (!SWIG_IsOK(res1)) {
15866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15867 }
15868 arg1 = reinterpret_cast< wxImage * >(argp1);
15869 if (obj1) {
15870 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15871 if (!SWIG_IsOK(ecode2)) {
15872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15873 }
15874 arg2 = static_cast< bool >(val2);
15875 }
15876 {
15877 PyThreadState* __tstate = wxPyBeginAllowThreads();
15878 (arg1)->SetMask(arg2);
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 resultobj = SWIG_Py_Void();
15883 return resultobj;
15884 fail:
15885 return NULL;
15886 }
15887
15888
15889 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15890 PyObject *resultobj = 0;
15891 wxImage *arg1 = (wxImage *) 0 ;
15892 bool result;
15893 void *argp1 = 0 ;
15894 int res1 = 0 ;
15895 PyObject *swig_obj[1] ;
15896
15897 if (!args) SWIG_fail;
15898 swig_obj[0] = args;
15899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15900 if (!SWIG_IsOK(res1)) {
15901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15902 }
15903 arg1 = reinterpret_cast< wxImage * >(argp1);
15904 {
15905 PyThreadState* __tstate = wxPyBeginAllowThreads();
15906 result = (bool)(arg1)->HasMask();
15907 wxPyEndAllowThreads(__tstate);
15908 if (PyErr_Occurred()) SWIG_fail;
15909 }
15910 {
15911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15912 }
15913 return resultobj;
15914 fail:
15915 return NULL;
15916 }
15917
15918
15919 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15920 PyObject *resultobj = 0;
15921 wxImage *arg1 = (wxImage *) 0 ;
15922 double arg2 ;
15923 wxPoint *arg3 = 0 ;
15924 bool arg4 = (bool) true ;
15925 wxPoint *arg5 = (wxPoint *) NULL ;
15926 SwigValueWrapper<wxImage > result;
15927 void *argp1 = 0 ;
15928 int res1 = 0 ;
15929 double val2 ;
15930 int ecode2 = 0 ;
15931 wxPoint temp3 ;
15932 bool val4 ;
15933 int ecode4 = 0 ;
15934 void *argp5 = 0 ;
15935 int res5 = 0 ;
15936 PyObject * obj0 = 0 ;
15937 PyObject * obj1 = 0 ;
15938 PyObject * obj2 = 0 ;
15939 PyObject * obj3 = 0 ;
15940 PyObject * obj4 = 0 ;
15941 char * kwnames[] = {
15942 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15943 };
15944
15945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15947 if (!SWIG_IsOK(res1)) {
15948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15949 }
15950 arg1 = reinterpret_cast< wxImage * >(argp1);
15951 ecode2 = SWIG_AsVal_double(obj1, &val2);
15952 if (!SWIG_IsOK(ecode2)) {
15953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15954 }
15955 arg2 = static_cast< double >(val2);
15956 {
15957 arg3 = &temp3;
15958 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15959 }
15960 if (obj3) {
15961 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15962 if (!SWIG_IsOK(ecode4)) {
15963 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15964 }
15965 arg4 = static_cast< bool >(val4);
15966 }
15967 if (obj4) {
15968 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15969 if (!SWIG_IsOK(res5)) {
15970 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15971 }
15972 arg5 = reinterpret_cast< wxPoint * >(argp5);
15973 }
15974 {
15975 PyThreadState* __tstate = wxPyBeginAllowThreads();
15976 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15977 wxPyEndAllowThreads(__tstate);
15978 if (PyErr_Occurred()) SWIG_fail;
15979 }
15980 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15981 return resultobj;
15982 fail:
15983 return NULL;
15984 }
15985
15986
15987 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15988 PyObject *resultobj = 0;
15989 wxImage *arg1 = (wxImage *) 0 ;
15990 bool arg2 = (bool) true ;
15991 SwigValueWrapper<wxImage > result;
15992 void *argp1 = 0 ;
15993 int res1 = 0 ;
15994 bool val2 ;
15995 int ecode2 = 0 ;
15996 PyObject * obj0 = 0 ;
15997 PyObject * obj1 = 0 ;
15998 char * kwnames[] = {
15999 (char *) "self",(char *) "clockwise", NULL
16000 };
16001
16002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16004 if (!SWIG_IsOK(res1)) {
16005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16006 }
16007 arg1 = reinterpret_cast< wxImage * >(argp1);
16008 if (obj1) {
16009 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16010 if (!SWIG_IsOK(ecode2)) {
16011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16012 }
16013 arg2 = static_cast< bool >(val2);
16014 }
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 result = (arg1)->Rotate90(arg2);
16018 wxPyEndAllowThreads(__tstate);
16019 if (PyErr_Occurred()) SWIG_fail;
16020 }
16021 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16029 PyObject *resultobj = 0;
16030 wxImage *arg1 = (wxImage *) 0 ;
16031 bool arg2 = (bool) true ;
16032 SwigValueWrapper<wxImage > result;
16033 void *argp1 = 0 ;
16034 int res1 = 0 ;
16035 bool val2 ;
16036 int ecode2 = 0 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char * kwnames[] = {
16040 (char *) "self",(char *) "horizontally", NULL
16041 };
16042
16043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16045 if (!SWIG_IsOK(res1)) {
16046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16047 }
16048 arg1 = reinterpret_cast< wxImage * >(argp1);
16049 if (obj1) {
16050 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16051 if (!SWIG_IsOK(ecode2)) {
16052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16053 }
16054 arg2 = static_cast< bool >(val2);
16055 }
16056 {
16057 PyThreadState* __tstate = wxPyBeginAllowThreads();
16058 result = (arg1)->Mirror(arg2);
16059 wxPyEndAllowThreads(__tstate);
16060 if (PyErr_Occurred()) SWIG_fail;
16061 }
16062 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16063 return resultobj;
16064 fail:
16065 return NULL;
16066 }
16067
16068
16069 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16070 PyObject *resultobj = 0;
16071 wxImage *arg1 = (wxImage *) 0 ;
16072 byte arg2 ;
16073 byte arg3 ;
16074 byte arg4 ;
16075 byte arg5 ;
16076 byte arg6 ;
16077 byte arg7 ;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 unsigned char val2 ;
16081 int ecode2 = 0 ;
16082 unsigned char val3 ;
16083 int ecode3 = 0 ;
16084 unsigned char val4 ;
16085 int ecode4 = 0 ;
16086 unsigned char val5 ;
16087 int ecode5 = 0 ;
16088 unsigned char val6 ;
16089 int ecode6 = 0 ;
16090 unsigned char val7 ;
16091 int ecode7 = 0 ;
16092 PyObject * obj0 = 0 ;
16093 PyObject * obj1 = 0 ;
16094 PyObject * obj2 = 0 ;
16095 PyObject * obj3 = 0 ;
16096 PyObject * obj4 = 0 ;
16097 PyObject * obj5 = 0 ;
16098 PyObject * obj6 = 0 ;
16099 char * kwnames[] = {
16100 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16101 };
16102
16103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16105 if (!SWIG_IsOK(res1)) {
16106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16107 }
16108 arg1 = reinterpret_cast< wxImage * >(argp1);
16109 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16110 if (!SWIG_IsOK(ecode2)) {
16111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16112 }
16113 arg2 = static_cast< byte >(val2);
16114 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16115 if (!SWIG_IsOK(ecode3)) {
16116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16117 }
16118 arg3 = static_cast< byte >(val3);
16119 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16120 if (!SWIG_IsOK(ecode4)) {
16121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16122 }
16123 arg4 = static_cast< byte >(val4);
16124 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16125 if (!SWIG_IsOK(ecode5)) {
16126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16127 }
16128 arg5 = static_cast< byte >(val5);
16129 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16130 if (!SWIG_IsOK(ecode6)) {
16131 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16132 }
16133 arg6 = static_cast< byte >(val6);
16134 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16135 if (!SWIG_IsOK(ecode7)) {
16136 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16137 }
16138 arg7 = static_cast< byte >(val7);
16139 {
16140 PyThreadState* __tstate = wxPyBeginAllowThreads();
16141 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 resultobj = SWIG_Py_Void();
16146 return resultobj;
16147 fail:
16148 return NULL;
16149 }
16150
16151
16152 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16153 PyObject *resultobj = 0;
16154 wxImage *arg1 = (wxImage *) 0 ;
16155 double arg2 = (double) 0.299 ;
16156 double arg3 = (double) 0.587 ;
16157 double arg4 = (double) 0.114 ;
16158 SwigValueWrapper<wxImage > result;
16159 void *argp1 = 0 ;
16160 int res1 = 0 ;
16161 double val2 ;
16162 int ecode2 = 0 ;
16163 double val3 ;
16164 int ecode3 = 0 ;
16165 double val4 ;
16166 int ecode4 = 0 ;
16167 PyObject * obj0 = 0 ;
16168 PyObject * obj1 = 0 ;
16169 PyObject * obj2 = 0 ;
16170 PyObject * obj3 = 0 ;
16171 char * kwnames[] = {
16172 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16173 };
16174
16175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16179 }
16180 arg1 = reinterpret_cast< wxImage * >(argp1);
16181 if (obj1) {
16182 ecode2 = SWIG_AsVal_double(obj1, &val2);
16183 if (!SWIG_IsOK(ecode2)) {
16184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16185 }
16186 arg2 = static_cast< double >(val2);
16187 }
16188 if (obj2) {
16189 ecode3 = SWIG_AsVal_double(obj2, &val3);
16190 if (!SWIG_IsOK(ecode3)) {
16191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16192 }
16193 arg3 = static_cast< double >(val3);
16194 }
16195 if (obj3) {
16196 ecode4 = SWIG_AsVal_double(obj3, &val4);
16197 if (!SWIG_IsOK(ecode4)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16199 }
16200 arg4 = static_cast< double >(val4);
16201 }
16202 {
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj = 0;
16217 wxImage *arg1 = (wxImage *) 0 ;
16218 byte arg2 ;
16219 byte arg3 ;
16220 byte arg4 ;
16221 SwigValueWrapper<wxImage > result;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 unsigned char val2 ;
16225 int ecode2 = 0 ;
16226 unsigned char val3 ;
16227 int ecode3 = 0 ;
16228 unsigned char val4 ;
16229 int ecode4 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 PyObject * obj1 = 0 ;
16232 PyObject * obj2 = 0 ;
16233 PyObject * obj3 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16240 if (!SWIG_IsOK(res1)) {
16241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16242 }
16243 arg1 = reinterpret_cast< wxImage * >(argp1);
16244 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16245 if (!SWIG_IsOK(ecode2)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16247 }
16248 arg2 = static_cast< byte >(val2);
16249 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16250 if (!SWIG_IsOK(ecode3)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16252 }
16253 arg3 = static_cast< byte >(val3);
16254 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16255 if (!SWIG_IsOK(ecode4)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16257 }
16258 arg4 = static_cast< byte >(val4);
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj = 0;
16274 wxImage *arg1 = (wxImage *) 0 ;
16275 wxString *arg2 = 0 ;
16276 wxString *arg3 = 0 ;
16277 void *argp1 = 0 ;
16278 int res1 = 0 ;
16279 bool temp2 = false ;
16280 bool temp3 = false ;
16281 PyObject * obj0 = 0 ;
16282 PyObject * obj1 = 0 ;
16283 PyObject * obj2 = 0 ;
16284 char * kwnames[] = {
16285 (char *) "self",(char *) "name",(char *) "value", NULL
16286 };
16287
16288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16290 if (!SWIG_IsOK(res1)) {
16291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16292 }
16293 arg1 = reinterpret_cast< wxImage * >(argp1);
16294 {
16295 arg2 = wxString_in_helper(obj1);
16296 if (arg2 == NULL) SWIG_fail;
16297 temp2 = true;
16298 }
16299 {
16300 arg3 = wxString_in_helper(obj2);
16301 if (arg3 == NULL) SWIG_fail;
16302 temp3 = true;
16303 }
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 resultobj = SWIG_Py_Void();
16311 {
16312 if (temp2)
16313 delete arg2;
16314 }
16315 {
16316 if (temp3)
16317 delete arg3;
16318 }
16319 return resultobj;
16320 fail:
16321 {
16322 if (temp2)
16323 delete arg2;
16324 }
16325 {
16326 if (temp3)
16327 delete arg3;
16328 }
16329 return NULL;
16330 }
16331
16332
16333 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16334 PyObject *resultobj = 0;
16335 wxImage *arg1 = (wxImage *) 0 ;
16336 wxString *arg2 = 0 ;
16337 int arg3 ;
16338 void *argp1 = 0 ;
16339 int res1 = 0 ;
16340 bool temp2 = false ;
16341 int val3 ;
16342 int ecode3 = 0 ;
16343 PyObject * obj0 = 0 ;
16344 PyObject * obj1 = 0 ;
16345 PyObject * obj2 = 0 ;
16346 char * kwnames[] = {
16347 (char *) "self",(char *) "name",(char *) "value", NULL
16348 };
16349
16350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16354 }
16355 arg1 = reinterpret_cast< wxImage * >(argp1);
16356 {
16357 arg2 = wxString_in_helper(obj1);
16358 if (arg2 == NULL) SWIG_fail;
16359 temp2 = true;
16360 }
16361 ecode3 = SWIG_AsVal_int(obj2, &val3);
16362 if (!SWIG_IsOK(ecode3)) {
16363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16364 }
16365 arg3 = static_cast< int >(val3);
16366 {
16367 PyThreadState* __tstate = wxPyBeginAllowThreads();
16368 (arg1)->SetOption((wxString const &)*arg2,arg3);
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 resultobj = SWIG_Py_Void();
16373 {
16374 if (temp2)
16375 delete arg2;
16376 }
16377 return resultobj;
16378 fail:
16379 {
16380 if (temp2)
16381 delete arg2;
16382 }
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj = 0;
16389 wxImage *arg1 = (wxImage *) 0 ;
16390 wxString *arg2 = 0 ;
16391 wxString result;
16392 void *argp1 = 0 ;
16393 int res1 = 0 ;
16394 bool temp2 = false ;
16395 PyObject * obj0 = 0 ;
16396 PyObject * obj1 = 0 ;
16397 char * kwnames[] = {
16398 (char *) "self",(char *) "name", NULL
16399 };
16400
16401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16403 if (!SWIG_IsOK(res1)) {
16404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16405 }
16406 arg1 = reinterpret_cast< wxImage * >(argp1);
16407 {
16408 arg2 = wxString_in_helper(obj1);
16409 if (arg2 == NULL) SWIG_fail;
16410 temp2 = true;
16411 }
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16415 wxPyEndAllowThreads(__tstate);
16416 if (PyErr_Occurred()) SWIG_fail;
16417 }
16418 {
16419 #if wxUSE_UNICODE
16420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16421 #else
16422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16423 #endif
16424 }
16425 {
16426 if (temp2)
16427 delete arg2;
16428 }
16429 return resultobj;
16430 fail:
16431 {
16432 if (temp2)
16433 delete arg2;
16434 }
16435 return NULL;
16436 }
16437
16438
16439 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16440 PyObject *resultobj = 0;
16441 wxImage *arg1 = (wxImage *) 0 ;
16442 wxString *arg2 = 0 ;
16443 int result;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 bool temp2 = false ;
16447 PyObject * obj0 = 0 ;
16448 PyObject * obj1 = 0 ;
16449 char * kwnames[] = {
16450 (char *) "self",(char *) "name", NULL
16451 };
16452
16453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16455 if (!SWIG_IsOK(res1)) {
16456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16457 }
16458 arg1 = reinterpret_cast< wxImage * >(argp1);
16459 {
16460 arg2 = wxString_in_helper(obj1);
16461 if (arg2 == NULL) SWIG_fail;
16462 temp2 = true;
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 resultobj = SWIG_From_int(static_cast< int >(result));
16471 {
16472 if (temp2)
16473 delete arg2;
16474 }
16475 return resultobj;
16476 fail:
16477 {
16478 if (temp2)
16479 delete arg2;
16480 }
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = 0;
16487 wxImage *arg1 = (wxImage *) 0 ;
16488 wxString *arg2 = 0 ;
16489 bool result;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 bool temp2 = false ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 char * kwnames[] = {
16496 (char *) "self",(char *) "name", NULL
16497 };
16498
16499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16501 if (!SWIG_IsOK(res1)) {
16502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16503 }
16504 arg1 = reinterpret_cast< wxImage * >(argp1);
16505 {
16506 arg2 = wxString_in_helper(obj1);
16507 if (arg2 == NULL) SWIG_fail;
16508 temp2 = true;
16509 }
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16518 }
16519 {
16520 if (temp2)
16521 delete arg2;
16522 }
16523 return resultobj;
16524 fail:
16525 {
16526 if (temp2)
16527 delete arg2;
16528 }
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxImage *arg1 = (wxImage *) 0 ;
16536 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16537 unsigned long result;
16538 void *argp1 = 0 ;
16539 int res1 = 0 ;
16540 unsigned long val2 ;
16541 int ecode2 = 0 ;
16542 PyObject * obj0 = 0 ;
16543 PyObject * obj1 = 0 ;
16544 char * kwnames[] = {
16545 (char *) "self",(char *) "stopafter", NULL
16546 };
16547
16548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16550 if (!SWIG_IsOK(res1)) {
16551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16552 }
16553 arg1 = reinterpret_cast< wxImage * >(argp1);
16554 if (obj1) {
16555 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16556 if (!SWIG_IsOK(ecode2)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16558 }
16559 arg2 = static_cast< unsigned long >(val2);
16560 }
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = (unsigned long)(arg1)->CountColours(arg2);
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxImage *arg1 = (wxImage *) 0 ;
16577 wxImageHistogram *arg2 = 0 ;
16578 unsigned long result;
16579 void *argp1 = 0 ;
16580 int res1 = 0 ;
16581 void *argp2 = 0 ;
16582 int res2 = 0 ;
16583 PyObject * obj0 = 0 ;
16584 PyObject * obj1 = 0 ;
16585 char * kwnames[] = {
16586 (char *) "self",(char *) "h", NULL
16587 };
16588
16589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16591 if (!SWIG_IsOK(res1)) {
16592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16593 }
16594 arg1 = reinterpret_cast< wxImage * >(argp1);
16595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16596 if (!SWIG_IsOK(res2)) {
16597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16598 }
16599 if (!argp2) {
16600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16601 }
16602 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16603 {
16604 PyThreadState* __tstate = wxPyBeginAllowThreads();
16605 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16606 wxPyEndAllowThreads(__tstate);
16607 if (PyErr_Occurred()) SWIG_fail;
16608 }
16609 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj = 0;
16618 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16619 void *argp1 = 0 ;
16620 int res1 = 0 ;
16621 PyObject * obj0 = 0 ;
16622 char * kwnames[] = {
16623 (char *) "handler", NULL
16624 };
16625
16626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16630 }
16631 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 wxImage::AddHandler(arg1);
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_Py_Void();
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj = 0;
16647 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16648 void *argp1 = 0 ;
16649 int res1 = 0 ;
16650 PyObject * obj0 = 0 ;
16651 char * kwnames[] = {
16652 (char *) "handler", NULL
16653 };
16654
16655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16657 if (!SWIG_IsOK(res1)) {
16658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16659 }
16660 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16661 {
16662 PyThreadState* __tstate = wxPyBeginAllowThreads();
16663 wxImage::InsertHandler(arg1);
16664 wxPyEndAllowThreads(__tstate);
16665 if (PyErr_Occurred()) SWIG_fail;
16666 }
16667 resultobj = SWIG_Py_Void();
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16675 PyObject *resultobj = 0;
16676 wxString *arg1 = 0 ;
16677 bool result;
16678 bool temp1 = false ;
16679 PyObject * obj0 = 0 ;
16680 char * kwnames[] = {
16681 (char *) "name", NULL
16682 };
16683
16684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16685 {
16686 arg1 = wxString_in_helper(obj0);
16687 if (arg1 == NULL) SWIG_fail;
16688 temp1 = true;
16689 }
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 {
16697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16698 }
16699 {
16700 if (temp1)
16701 delete arg1;
16702 }
16703 return resultobj;
16704 fail:
16705 {
16706 if (temp1)
16707 delete arg1;
16708 }
16709 return NULL;
16710 }
16711
16712
16713 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16714 PyObject *resultobj = 0;
16715 PyObject *result = 0 ;
16716
16717 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (PyObject *)wxImage_GetHandlers();
16721 wxPyEndAllowThreads(__tstate);
16722 if (PyErr_Occurred()) SWIG_fail;
16723 }
16724 resultobj = result;
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16732 PyObject *resultobj = 0;
16733 wxString result;
16734
16735 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = wxImage::GetImageExtWildcard();
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 {
16743 #if wxUSE_UNICODE
16744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16745 #else
16746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16747 #endif
16748 }
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj = 0;
16757 wxImage *arg1 = (wxImage *) 0 ;
16758 int arg2 = (int) -1 ;
16759 wxBitmap result;
16760 void *argp1 = 0 ;
16761 int res1 = 0 ;
16762 int val2 ;
16763 int ecode2 = 0 ;
16764 PyObject * obj0 = 0 ;
16765 PyObject * obj1 = 0 ;
16766 char * kwnames[] = {
16767 (char *) "self",(char *) "depth", NULL
16768 };
16769
16770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16772 if (!SWIG_IsOK(res1)) {
16773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16774 }
16775 arg1 = reinterpret_cast< wxImage * >(argp1);
16776 if (obj1) {
16777 ecode2 = SWIG_AsVal_int(obj1, &val2);
16778 if (!SWIG_IsOK(ecode2)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16780 }
16781 arg2 = static_cast< int >(val2);
16782 }
16783 {
16784 if (!wxPyCheckForApp()) SWIG_fail;
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 result = wxImage_ConvertToBitmap(arg1,arg2);
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16791 return resultobj;
16792 fail:
16793 return NULL;
16794 }
16795
16796
16797 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj = 0;
16799 wxImage *arg1 = (wxImage *) 0 ;
16800 byte arg2 ;
16801 byte arg3 ;
16802 byte arg4 ;
16803 wxBitmap result;
16804 void *argp1 = 0 ;
16805 int res1 = 0 ;
16806 unsigned char val2 ;
16807 int ecode2 = 0 ;
16808 unsigned char val3 ;
16809 int ecode3 = 0 ;
16810 unsigned char val4 ;
16811 int ecode4 = 0 ;
16812 PyObject * obj0 = 0 ;
16813 PyObject * obj1 = 0 ;
16814 PyObject * obj2 = 0 ;
16815 PyObject * obj3 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16824 }
16825 arg1 = reinterpret_cast< wxImage * >(argp1);
16826 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16827 if (!SWIG_IsOK(ecode2)) {
16828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16829 }
16830 arg2 = static_cast< byte >(val2);
16831 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16832 if (!SWIG_IsOK(ecode3)) {
16833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16834 }
16835 arg3 = static_cast< byte >(val3);
16836 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16837 if (!SWIG_IsOK(ecode4)) {
16838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16839 }
16840 arg4 = static_cast< byte >(val4);
16841 {
16842 if (!wxPyCheckForApp()) SWIG_fail;
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj = 0;
16857 wxImage *arg1 = (wxImage *) 0 ;
16858 double arg2 ;
16859 void *argp1 = 0 ;
16860 int res1 = 0 ;
16861 double val2 ;
16862 int ecode2 = 0 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 char * kwnames[] = {
16866 (char *) "self",(char *) "angle", NULL
16867 };
16868
16869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16873 }
16874 arg1 = reinterpret_cast< wxImage * >(argp1);
16875 ecode2 = SWIG_AsVal_double(obj1, &val2);
16876 if (!SWIG_IsOK(ecode2)) {
16877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16878 }
16879 arg2 = static_cast< double >(val2);
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 (arg1)->RotateHue(arg2);
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 resultobj = SWIG_Py_Void();
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj = 0;
16895 wxImage_RGBValue arg1 ;
16896 wxImage_HSVValue result;
16897 void *argp1 ;
16898 int res1 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 char * kwnames[] = {
16901 (char *) "rgb", NULL
16902 };
16903
16904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16905 {
16906 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16909 }
16910 if (!argp1) {
16911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16912 } else {
16913 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16914 arg1 = *temp;
16915 if (SWIG_IsNewObj(res1)) delete temp;
16916 }
16917 }
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 result = wxImage::RGBtoHSV(arg1);
16921 wxPyEndAllowThreads(__tstate);
16922 if (PyErr_Occurred()) SWIG_fail;
16923 }
16924 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj = 0;
16933 wxImage_HSVValue arg1 ;
16934 wxImage_RGBValue result;
16935 void *argp1 ;
16936 int res1 = 0 ;
16937 PyObject * obj0 = 0 ;
16938 char * kwnames[] = {
16939 (char *) "hsv", NULL
16940 };
16941
16942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16943 {
16944 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16945 if (!SWIG_IsOK(res1)) {
16946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16947 }
16948 if (!argp1) {
16949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16950 } else {
16951 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16952 arg1 = *temp;
16953 if (SWIG_IsNewObj(res1)) delete temp;
16954 }
16955 }
16956 {
16957 PyThreadState* __tstate = wxPyBeginAllowThreads();
16958 result = wxImage::HSVtoRGB(arg1);
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16970 PyObject *obj;
16971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16972 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16973 return SWIG_Py_Void();
16974 }
16975
16976 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16977 return SWIG_Python_InitShadowInstance(args);
16978 }
16979
16980 SWIGINTERN int NullImage_set(PyObject *) {
16981 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16982 return 1;
16983 }
16984
16985
16986 SWIGINTERN PyObject *NullImage_get(void) {
16987 PyObject *pyobj = 0;
16988
16989 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16990 return pyobj;
16991 }
16992
16993
16994 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16995 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16996 return 1;
16997 }
16998
16999
17000 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17001 PyObject *pyobj = 0;
17002
17003 {
17004 #if wxUSE_UNICODE
17005 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17006 #else
17007 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17008 #endif
17009 }
17010 return pyobj;
17011 }
17012
17013
17014 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17015 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17016 return 1;
17017 }
17018
17019
17020 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17021 PyObject *pyobj = 0;
17022
17023 {
17024 #if wxUSE_UNICODE
17025 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17026 #else
17027 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17028 #endif
17029 }
17030 return pyobj;
17031 }
17032
17033
17034 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17035 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17036 return 1;
17037 }
17038
17039
17040 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17041 PyObject *pyobj = 0;
17042
17043 {
17044 #if wxUSE_UNICODE
17045 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17046 #else
17047 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17048 #endif
17049 }
17050 return pyobj;
17051 }
17052
17053
17054 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17055 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17056 return 1;
17057 }
17058
17059
17060 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17061 PyObject *pyobj = 0;
17062
17063 {
17064 #if wxUSE_UNICODE
17065 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17066 #else
17067 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17068 #endif
17069 }
17070 return pyobj;
17071 }
17072
17073
17074 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17075 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17076 return 1;
17077 }
17078
17079
17080 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17081 PyObject *pyobj = 0;
17082
17083 {
17084 #if wxUSE_UNICODE
17085 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17086 #else
17087 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17088 #endif
17089 }
17090 return pyobj;
17091 }
17092
17093
17094 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17095 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17096 return 1;
17097 }
17098
17099
17100 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17101 PyObject *pyobj = 0;
17102
17103 {
17104 #if wxUSE_UNICODE
17105 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17106 #else
17107 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17108 #endif
17109 }
17110 return pyobj;
17111 }
17112
17113
17114 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17115 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17116 return 1;
17117 }
17118
17119
17120 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17121 PyObject *pyobj = 0;
17122
17123 {
17124 #if wxUSE_UNICODE
17125 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17126 #else
17127 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17128 #endif
17129 }
17130 return pyobj;
17131 }
17132
17133
17134 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17135 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17136 return 1;
17137 }
17138
17139
17140 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17141 PyObject *pyobj = 0;
17142
17143 {
17144 #if wxUSE_UNICODE
17145 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17146 #else
17147 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17148 #endif
17149 }
17150 return pyobj;
17151 }
17152
17153
17154 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17155 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17156 return 1;
17157 }
17158
17159
17160 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17161 PyObject *pyobj = 0;
17162
17163 {
17164 #if wxUSE_UNICODE
17165 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17166 #else
17167 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17168 #endif
17169 }
17170 return pyobj;
17171 }
17172
17173
17174 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17175 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17176 return 1;
17177 }
17178
17179
17180 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17181 PyObject *pyobj = 0;
17182
17183 {
17184 #if wxUSE_UNICODE
17185 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17186 #else
17187 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17188 #endif
17189 }
17190 return pyobj;
17191 }
17192
17193
17194 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17195 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17196 return 1;
17197 }
17198
17199
17200 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17201 PyObject *pyobj = 0;
17202
17203 {
17204 #if wxUSE_UNICODE
17205 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17206 #else
17207 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17208 #endif
17209 }
17210 return pyobj;
17211 }
17212
17213
17214 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17215 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17216 return 1;
17217 }
17218
17219
17220 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17221 PyObject *pyobj = 0;
17222
17223 {
17224 #if wxUSE_UNICODE
17225 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17226 #else
17227 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17228 #endif
17229 }
17230 return pyobj;
17231 }
17232
17233
17234 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17235 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17236 return 1;
17237 }
17238
17239
17240 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17241 PyObject *pyobj = 0;
17242
17243 {
17244 #if wxUSE_UNICODE
17245 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17246 #else
17247 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17248 #endif
17249 }
17250 return pyobj;
17251 }
17252
17253
17254 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17255 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17256 return 1;
17257 }
17258
17259
17260 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17261 PyObject *pyobj = 0;
17262
17263 {
17264 #if wxUSE_UNICODE
17265 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17266 #else
17267 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17268 #endif
17269 }
17270 return pyobj;
17271 }
17272
17273
17274 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17275 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17276 return 1;
17277 }
17278
17279
17280 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17281 PyObject *pyobj = 0;
17282
17283 {
17284 #if wxUSE_UNICODE
17285 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17286 #else
17287 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17288 #endif
17289 }
17290 return pyobj;
17291 }
17292
17293
17294 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17295 PyObject *resultobj = 0;
17296 wxBMPHandler *result = 0 ;
17297
17298 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17299 {
17300 PyThreadState* __tstate = wxPyBeginAllowThreads();
17301 result = (wxBMPHandler *)new wxBMPHandler();
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17313 PyObject *obj;
17314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17315 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17316 return SWIG_Py_Void();
17317 }
17318
17319 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 return SWIG_Python_InitShadowInstance(args);
17321 }
17322
17323 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 PyObject *resultobj = 0;
17325 wxICOHandler *result = 0 ;
17326
17327 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17328 {
17329 PyThreadState* __tstate = wxPyBeginAllowThreads();
17330 result = (wxICOHandler *)new wxICOHandler();
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17335 return resultobj;
17336 fail:
17337 return NULL;
17338 }
17339
17340
17341 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17342 PyObject *obj;
17343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17344 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17345 return SWIG_Py_Void();
17346 }
17347
17348 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17349 return SWIG_Python_InitShadowInstance(args);
17350 }
17351
17352 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17353 PyObject *resultobj = 0;
17354 wxCURHandler *result = 0 ;
17355
17356 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (wxCURHandler *)new wxCURHandler();
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17364 return resultobj;
17365 fail:
17366 return NULL;
17367 }
17368
17369
17370 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17371 PyObject *obj;
17372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17373 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17374 return SWIG_Py_Void();
17375 }
17376
17377 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17378 return SWIG_Python_InitShadowInstance(args);
17379 }
17380
17381 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17382 PyObject *resultobj = 0;
17383 wxANIHandler *result = 0 ;
17384
17385 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17386 {
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = (wxANIHandler *)new wxANIHandler();
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17400 PyObject *obj;
17401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17402 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17403 return SWIG_Py_Void();
17404 }
17405
17406 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17407 return SWIG_Python_InitShadowInstance(args);
17408 }
17409
17410 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17411 PyObject *resultobj = 0;
17412 wxPNGHandler *result = 0 ;
17413
17414 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (wxPNGHandler *)new wxPNGHandler();
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17429 PyObject *obj;
17430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17431 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17432 return SWIG_Py_Void();
17433 }
17434
17435 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17436 return SWIG_Python_InitShadowInstance(args);
17437 }
17438
17439 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 PyObject *resultobj = 0;
17441 wxGIFHandler *result = 0 ;
17442
17443 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (wxGIFHandler *)new wxGIFHandler();
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 PyObject *obj;
17459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17460 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17461 return SWIG_Py_Void();
17462 }
17463
17464 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17465 return SWIG_Python_InitShadowInstance(args);
17466 }
17467
17468 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 PyObject *resultobj = 0;
17470 wxPCXHandler *result = 0 ;
17471
17472 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17473 {
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 result = (wxPCXHandler *)new wxPCXHandler();
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 PyObject *obj;
17488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17489 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17490 return SWIG_Py_Void();
17491 }
17492
17493 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 return SWIG_Python_InitShadowInstance(args);
17495 }
17496
17497 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17498 PyObject *resultobj = 0;
17499 wxJPEGHandler *result = 0 ;
17500
17501 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17502 {
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 result = (wxJPEGHandler *)new wxJPEGHandler();
17505 wxPyEndAllowThreads(__tstate);
17506 if (PyErr_Occurred()) SWIG_fail;
17507 }
17508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 PyObject *obj;
17517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17518 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17519 return SWIG_Py_Void();
17520 }
17521
17522 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17523 return SWIG_Python_InitShadowInstance(args);
17524 }
17525
17526 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17527 PyObject *resultobj = 0;
17528 wxPNMHandler *result = 0 ;
17529
17530 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17531 {
17532 PyThreadState* __tstate = wxPyBeginAllowThreads();
17533 result = (wxPNMHandler *)new wxPNMHandler();
17534 wxPyEndAllowThreads(__tstate);
17535 if (PyErr_Occurred()) SWIG_fail;
17536 }
17537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17538 return resultobj;
17539 fail:
17540 return NULL;
17541 }
17542
17543
17544 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17545 PyObject *obj;
17546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17547 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17548 return SWIG_Py_Void();
17549 }
17550
17551 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 return SWIG_Python_InitShadowInstance(args);
17553 }
17554
17555 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17556 PyObject *resultobj = 0;
17557 wxXPMHandler *result = 0 ;
17558
17559 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = (wxXPMHandler *)new wxXPMHandler();
17563 wxPyEndAllowThreads(__tstate);
17564 if (PyErr_Occurred()) SWIG_fail;
17565 }
17566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 PyObject *obj;
17575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17576 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17577 return SWIG_Py_Void();
17578 }
17579
17580 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 return SWIG_Python_InitShadowInstance(args);
17582 }
17583
17584 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17585 PyObject *resultobj = 0;
17586 wxTIFFHandler *result = 0 ;
17587
17588 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17589 {
17590 PyThreadState* __tstate = wxPyBeginAllowThreads();
17591 result = (wxTIFFHandler *)new wxTIFFHandler();
17592 wxPyEndAllowThreads(__tstate);
17593 if (PyErr_Occurred()) SWIG_fail;
17594 }
17595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17596 return resultobj;
17597 fail:
17598 return NULL;
17599 }
17600
17601
17602 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 PyObject *obj;
17604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17605 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17606 return SWIG_Py_Void();
17607 }
17608
17609 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 return SWIG_Python_InitShadowInstance(args);
17611 }
17612
17613 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj = 0;
17615 wxImage *arg1 = 0 ;
17616 wxImage *arg2 = 0 ;
17617 int arg3 = (int) 236 ;
17618 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17619 bool result;
17620 void *argp1 = 0 ;
17621 int res1 = 0 ;
17622 void *argp2 = 0 ;
17623 int res2 = 0 ;
17624 int val3 ;
17625 int ecode3 = 0 ;
17626 int val4 ;
17627 int ecode4 = 0 ;
17628 PyObject * obj0 = 0 ;
17629 PyObject * obj1 = 0 ;
17630 PyObject * obj2 = 0 ;
17631 PyObject * obj3 = 0 ;
17632 char * kwnames[] = {
17633 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17634 };
17635
17636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17637 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17638 if (!SWIG_IsOK(res1)) {
17639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17640 }
17641 if (!argp1) {
17642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17643 }
17644 arg1 = reinterpret_cast< wxImage * >(argp1);
17645 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17646 if (!SWIG_IsOK(res2)) {
17647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17648 }
17649 if (!argp2) {
17650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17651 }
17652 arg2 = reinterpret_cast< wxImage * >(argp2);
17653 if (obj2) {
17654 ecode3 = SWIG_AsVal_int(obj2, &val3);
17655 if (!SWIG_IsOK(ecode3)) {
17656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17657 }
17658 arg3 = static_cast< int >(val3);
17659 }
17660 if (obj3) {
17661 ecode4 = SWIG_AsVal_int(obj3, &val4);
17662 if (!SWIG_IsOK(ecode4)) {
17663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17664 }
17665 arg4 = static_cast< int >(val4);
17666 }
17667 {
17668 PyThreadState* __tstate = wxPyBeginAllowThreads();
17669 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17670 wxPyEndAllowThreads(__tstate);
17671 if (PyErr_Occurred()) SWIG_fail;
17672 }
17673 {
17674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17675 }
17676 return resultobj;
17677 fail:
17678 return NULL;
17679 }
17680
17681
17682 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17683 PyObject *obj;
17684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17685 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17686 return SWIG_Py_Void();
17687 }
17688
17689 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 PyObject *resultobj = 0;
17691 wxEvtHandler *result = 0 ;
17692
17693 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 result = (wxEvtHandler *)new wxEvtHandler();
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17701 return resultobj;
17702 fail:
17703 return NULL;
17704 }
17705
17706
17707 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17708 PyObject *resultobj = 0;
17709 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17710 wxEvtHandler *result = 0 ;
17711 void *argp1 = 0 ;
17712 int res1 = 0 ;
17713 PyObject *swig_obj[1] ;
17714
17715 if (!args) SWIG_fail;
17716 swig_obj[0] = args;
17717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17718 if (!SWIG_IsOK(res1)) {
17719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17720 }
17721 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17722 {
17723 PyThreadState* __tstate = wxPyBeginAllowThreads();
17724 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 {
17729 resultobj = wxPyMake_wxObject(result, 0);
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17738 PyObject *resultobj = 0;
17739 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17740 wxEvtHandler *result = 0 ;
17741 void *argp1 = 0 ;
17742 int res1 = 0 ;
17743 PyObject *swig_obj[1] ;
17744
17745 if (!args) SWIG_fail;
17746 swig_obj[0] = args;
17747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17748 if (!SWIG_IsOK(res1)) {
17749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17750 }
17751 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 {
17759 resultobj = wxPyMake_wxObject(result, 0);
17760 }
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj = 0;
17769 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17770 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 void *argp2 = 0 ;
17774 int res2 = 0 ;
17775 PyObject * obj0 = 0 ;
17776 PyObject * obj1 = 0 ;
17777 char * kwnames[] = {
17778 (char *) "self",(char *) "handler", NULL
17779 };
17780
17781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17783 if (!SWIG_IsOK(res1)) {
17784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17785 }
17786 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17788 if (!SWIG_IsOK(res2)) {
17789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17790 }
17791 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 (arg1)->SetNextHandler(arg2);
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 resultobj = SWIG_Py_Void();
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17806 PyObject *resultobj = 0;
17807 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17808 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17809 void *argp1 = 0 ;
17810 int res1 = 0 ;
17811 void *argp2 = 0 ;
17812 int res2 = 0 ;
17813 PyObject * obj0 = 0 ;
17814 PyObject * obj1 = 0 ;
17815 char * kwnames[] = {
17816 (char *) "self",(char *) "handler", NULL
17817 };
17818
17819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17821 if (!SWIG_IsOK(res1)) {
17822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17823 }
17824 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17826 if (!SWIG_IsOK(res2)) {
17827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17828 }
17829 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17830 {
17831 PyThreadState* __tstate = wxPyBeginAllowThreads();
17832 (arg1)->SetPreviousHandler(arg2);
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 resultobj = SWIG_Py_Void();
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17844 PyObject *resultobj = 0;
17845 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17846 bool result;
17847 void *argp1 = 0 ;
17848 int res1 = 0 ;
17849 PyObject *swig_obj[1] ;
17850
17851 if (!args) SWIG_fail;
17852 swig_obj[0] = args;
17853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17854 if (!SWIG_IsOK(res1)) {
17855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17856 }
17857 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17858 {
17859 PyThreadState* __tstate = wxPyBeginAllowThreads();
17860 result = (bool)(arg1)->GetEvtHandlerEnabled();
17861 wxPyEndAllowThreads(__tstate);
17862 if (PyErr_Occurred()) SWIG_fail;
17863 }
17864 {
17865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj = 0;
17875 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17876 bool arg2 ;
17877 void *argp1 = 0 ;
17878 int res1 = 0 ;
17879 bool val2 ;
17880 int ecode2 = 0 ;
17881 PyObject * obj0 = 0 ;
17882 PyObject * obj1 = 0 ;
17883 char * kwnames[] = {
17884 (char *) "self",(char *) "enabled", NULL
17885 };
17886
17887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17889 if (!SWIG_IsOK(res1)) {
17890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17891 }
17892 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17894 if (!SWIG_IsOK(ecode2)) {
17895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17896 }
17897 arg2 = static_cast< bool >(val2);
17898 {
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 (arg1)->SetEvtHandlerEnabled(arg2);
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 resultobj = SWIG_Py_Void();
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj = 0;
17913 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17914 wxEvent *arg2 = 0 ;
17915 bool result;
17916 void *argp1 = 0 ;
17917 int res1 = 0 ;
17918 void *argp2 = 0 ;
17919 int res2 = 0 ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 char * kwnames[] = {
17923 (char *) "self",(char *) "event", NULL
17924 };
17925
17926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17930 }
17931 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17933 if (!SWIG_IsOK(res2)) {
17934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17935 }
17936 if (!argp2) {
17937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17938 }
17939 arg2 = reinterpret_cast< wxEvent * >(argp2);
17940 {
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 result = (bool)(arg1)->ProcessEvent(*arg2);
17943 wxPyEndAllowThreads(__tstate);
17944 if (PyErr_Occurred()) SWIG_fail;
17945 }
17946 {
17947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17948 }
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj = 0;
17957 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17958 wxEvent *arg2 = 0 ;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 void *argp2 = 0 ;
17962 int res2 = 0 ;
17963 PyObject * obj0 = 0 ;
17964 PyObject * obj1 = 0 ;
17965 char * kwnames[] = {
17966 (char *) "self",(char *) "event", NULL
17967 };
17968
17969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17971 if (!SWIG_IsOK(res1)) {
17972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17973 }
17974 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17976 if (!SWIG_IsOK(res2)) {
17977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17978 }
17979 if (!argp2) {
17980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17981 }
17982 arg2 = reinterpret_cast< wxEvent * >(argp2);
17983 {
17984 PyThreadState* __tstate = wxPyBeginAllowThreads();
17985 (arg1)->AddPendingEvent(*arg2);
17986 wxPyEndAllowThreads(__tstate);
17987 if (PyErr_Occurred()) SWIG_fail;
17988 }
17989 resultobj = SWIG_Py_Void();
17990 return resultobj;
17991 fail:
17992 return NULL;
17993 }
17994
17995
17996 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17997 PyObject *resultobj = 0;
17998 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17999 void *argp1 = 0 ;
18000 int res1 = 0 ;
18001 PyObject *swig_obj[1] ;
18002
18003 if (!args) SWIG_fail;
18004 swig_obj[0] = args;
18005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18006 if (!SWIG_IsOK(res1)) {
18007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18008 }
18009 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 (arg1)->ProcessPendingEvents();
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 resultobj = SWIG_Py_Void();
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj = 0;
18025 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18026 int arg2 ;
18027 int arg3 ;
18028 int arg4 ;
18029 PyObject *arg5 = (PyObject *) 0 ;
18030 void *argp1 = 0 ;
18031 int res1 = 0 ;
18032 int val2 ;
18033 int ecode2 = 0 ;
18034 int val3 ;
18035 int ecode3 = 0 ;
18036 int val4 ;
18037 int ecode4 = 0 ;
18038 PyObject * obj0 = 0 ;
18039 PyObject * obj1 = 0 ;
18040 PyObject * obj2 = 0 ;
18041 PyObject * obj3 = 0 ;
18042 PyObject * obj4 = 0 ;
18043 char * kwnames[] = {
18044 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18045 };
18046
18047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18049 if (!SWIG_IsOK(res1)) {
18050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18051 }
18052 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18053 ecode2 = SWIG_AsVal_int(obj1, &val2);
18054 if (!SWIG_IsOK(ecode2)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18056 }
18057 arg2 = static_cast< int >(val2);
18058 ecode3 = SWIG_AsVal_int(obj2, &val3);
18059 if (!SWIG_IsOK(ecode3)) {
18060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18061 }
18062 arg3 = static_cast< int >(val3);
18063 ecode4 = SWIG_AsVal_int(obj3, &val4);
18064 if (!SWIG_IsOK(ecode4)) {
18065 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18066 }
18067 arg4 = static_cast< int >(val4);
18068 arg5 = obj4;
18069 {
18070 PyThreadState* __tstate = wxPyBeginAllowThreads();
18071 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 resultobj = SWIG_Py_Void();
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18083 PyObject *resultobj = 0;
18084 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18085 int arg2 ;
18086 int arg3 = (int) -1 ;
18087 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18088 bool result;
18089 void *argp1 = 0 ;
18090 int res1 = 0 ;
18091 int val2 ;
18092 int ecode2 = 0 ;
18093 int val3 ;
18094 int ecode3 = 0 ;
18095 int val4 ;
18096 int ecode4 = 0 ;
18097 PyObject * obj0 = 0 ;
18098 PyObject * obj1 = 0 ;
18099 PyObject * obj2 = 0 ;
18100 PyObject * obj3 = 0 ;
18101 char * kwnames[] = {
18102 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18103 };
18104
18105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18107 if (!SWIG_IsOK(res1)) {
18108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18109 }
18110 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18111 ecode2 = SWIG_AsVal_int(obj1, &val2);
18112 if (!SWIG_IsOK(ecode2)) {
18113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18114 }
18115 arg2 = static_cast< int >(val2);
18116 if (obj2) {
18117 ecode3 = SWIG_AsVal_int(obj2, &val3);
18118 if (!SWIG_IsOK(ecode3)) {
18119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18120 }
18121 arg3 = static_cast< int >(val3);
18122 }
18123 if (obj3) {
18124 ecode4 = SWIG_AsVal_int(obj3, &val4);
18125 if (!SWIG_IsOK(ecode4)) {
18126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18127 }
18128 arg4 = static_cast< wxEventType >(val4);
18129 }
18130 {
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 {
18137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18138 }
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj = 0;
18147 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18148 PyObject *arg2 = (PyObject *) 0 ;
18149 bool arg3 = (bool) true ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 bool val3 ;
18153 int ecode3 = 0 ;
18154 PyObject * obj0 = 0 ;
18155 PyObject * obj1 = 0 ;
18156 PyObject * obj2 = 0 ;
18157 char * kwnames[] = {
18158 (char *) "self",(char *) "_self",(char *) "incref", NULL
18159 };
18160
18161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18165 }
18166 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18167 arg2 = obj1;
18168 if (obj2) {
18169 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18170 if (!SWIG_IsOK(ecode3)) {
18171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18172 }
18173 arg3 = static_cast< bool >(val3);
18174 }
18175 {
18176 PyThreadState* __tstate = wxPyBeginAllowThreads();
18177 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18178 wxPyEndAllowThreads(__tstate);
18179 if (PyErr_Occurred()) SWIG_fail;
18180 }
18181 resultobj = SWIG_Py_Void();
18182 return resultobj;
18183 fail:
18184 return NULL;
18185 }
18186
18187
18188 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18189 PyObject *obj;
18190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18191 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18192 return SWIG_Py_Void();
18193 }
18194
18195 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18196 return SWIG_Python_InitShadowInstance(args);
18197 }
18198
18199 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxEventType result;
18202
18203 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 result = (wxEventType)wxNewEventType();
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 resultobj = SWIG_From_int(static_cast< int >(result));
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18218 PyObject *resultobj = 0;
18219 wxEvent *arg1 = (wxEvent *) 0 ;
18220 void *argp1 = 0 ;
18221 int res1 = 0 ;
18222 PyObject *swig_obj[1] ;
18223
18224 if (!args) SWIG_fail;
18225 swig_obj[0] = args;
18226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18227 if (!SWIG_IsOK(res1)) {
18228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18229 }
18230 arg1 = reinterpret_cast< wxEvent * >(argp1);
18231 {
18232 PyThreadState* __tstate = wxPyBeginAllowThreads();
18233 delete arg1;
18234
18235 wxPyEndAllowThreads(__tstate);
18236 if (PyErr_Occurred()) SWIG_fail;
18237 }
18238 resultobj = SWIG_Py_Void();
18239 return resultobj;
18240 fail:
18241 return NULL;
18242 }
18243
18244
18245 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj = 0;
18247 wxEvent *arg1 = (wxEvent *) 0 ;
18248 wxEventType arg2 ;
18249 void *argp1 = 0 ;
18250 int res1 = 0 ;
18251 int val2 ;
18252 int ecode2 = 0 ;
18253 PyObject * obj0 = 0 ;
18254 PyObject * obj1 = 0 ;
18255 char * kwnames[] = {
18256 (char *) "self",(char *) "typ", NULL
18257 };
18258
18259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18261 if (!SWIG_IsOK(res1)) {
18262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18263 }
18264 arg1 = reinterpret_cast< wxEvent * >(argp1);
18265 ecode2 = SWIG_AsVal_int(obj1, &val2);
18266 if (!SWIG_IsOK(ecode2)) {
18267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18268 }
18269 arg2 = static_cast< wxEventType >(val2);
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 (arg1)->SetEventType(arg2);
18273 wxPyEndAllowThreads(__tstate);
18274 if (PyErr_Occurred()) SWIG_fail;
18275 }
18276 resultobj = SWIG_Py_Void();
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18284 PyObject *resultobj = 0;
18285 wxEvent *arg1 = (wxEvent *) 0 ;
18286 wxEventType result;
18287 void *argp1 = 0 ;
18288 int res1 = 0 ;
18289 PyObject *swig_obj[1] ;
18290
18291 if (!args) SWIG_fail;
18292 swig_obj[0] = args;
18293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18296 }
18297 arg1 = reinterpret_cast< wxEvent * >(argp1);
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 resultobj = SWIG_From_int(static_cast< int >(result));
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18312 PyObject *resultobj = 0;
18313 wxEvent *arg1 = (wxEvent *) 0 ;
18314 wxObject *result = 0 ;
18315 void *argp1 = 0 ;
18316 int res1 = 0 ;
18317 PyObject *swig_obj[1] ;
18318
18319 if (!args) SWIG_fail;
18320 swig_obj[0] = args;
18321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18322 if (!SWIG_IsOK(res1)) {
18323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18324 }
18325 arg1 = reinterpret_cast< wxEvent * >(argp1);
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 {
18333 resultobj = wxPyMake_wxObject(result, (bool)0);
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj = 0;
18343 wxEvent *arg1 = (wxEvent *) 0 ;
18344 wxObject *arg2 = (wxObject *) 0 ;
18345 void *argp1 = 0 ;
18346 int res1 = 0 ;
18347 void *argp2 = 0 ;
18348 int res2 = 0 ;
18349 PyObject * obj0 = 0 ;
18350 PyObject * obj1 = 0 ;
18351 char * kwnames[] = {
18352 (char *) "self",(char *) "obj", NULL
18353 };
18354
18355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18357 if (!SWIG_IsOK(res1)) {
18358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18359 }
18360 arg1 = reinterpret_cast< wxEvent * >(argp1);
18361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18362 if (!SWIG_IsOK(res2)) {
18363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18364 }
18365 arg2 = reinterpret_cast< wxObject * >(argp2);
18366 {
18367 PyThreadState* __tstate = wxPyBeginAllowThreads();
18368 (arg1)->SetEventObject(arg2);
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 resultobj = SWIG_Py_Void();
18373 return resultobj;
18374 fail:
18375 return NULL;
18376 }
18377
18378
18379 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18380 PyObject *resultobj = 0;
18381 wxEvent *arg1 = (wxEvent *) 0 ;
18382 long result;
18383 void *argp1 = 0 ;
18384 int res1 = 0 ;
18385 PyObject *swig_obj[1] ;
18386
18387 if (!args) SWIG_fail;
18388 swig_obj[0] = args;
18389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18390 if (!SWIG_IsOK(res1)) {
18391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18392 }
18393 arg1 = reinterpret_cast< wxEvent * >(argp1);
18394 {
18395 PyThreadState* __tstate = wxPyBeginAllowThreads();
18396 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18397 wxPyEndAllowThreads(__tstate);
18398 if (PyErr_Occurred()) SWIG_fail;
18399 }
18400 resultobj = SWIG_From_long(static_cast< long >(result));
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18408 PyObject *resultobj = 0;
18409 wxEvent *arg1 = (wxEvent *) 0 ;
18410 long arg2 = (long) 0 ;
18411 void *argp1 = 0 ;
18412 int res1 = 0 ;
18413 long val2 ;
18414 int ecode2 = 0 ;
18415 PyObject * obj0 = 0 ;
18416 PyObject * obj1 = 0 ;
18417 char * kwnames[] = {
18418 (char *) "self",(char *) "ts", NULL
18419 };
18420
18421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18423 if (!SWIG_IsOK(res1)) {
18424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18425 }
18426 arg1 = reinterpret_cast< wxEvent * >(argp1);
18427 if (obj1) {
18428 ecode2 = SWIG_AsVal_long(obj1, &val2);
18429 if (!SWIG_IsOK(ecode2)) {
18430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18431 }
18432 arg2 = static_cast< long >(val2);
18433 }
18434 {
18435 PyThreadState* __tstate = wxPyBeginAllowThreads();
18436 (arg1)->SetTimestamp(arg2);
18437 wxPyEndAllowThreads(__tstate);
18438 if (PyErr_Occurred()) SWIG_fail;
18439 }
18440 resultobj = SWIG_Py_Void();
18441 return resultobj;
18442 fail:
18443 return NULL;
18444 }
18445
18446
18447 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18448 PyObject *resultobj = 0;
18449 wxEvent *arg1 = (wxEvent *) 0 ;
18450 int result;
18451 void *argp1 = 0 ;
18452 int res1 = 0 ;
18453 PyObject *swig_obj[1] ;
18454
18455 if (!args) SWIG_fail;
18456 swig_obj[0] = args;
18457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18458 if (!SWIG_IsOK(res1)) {
18459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18460 }
18461 arg1 = reinterpret_cast< wxEvent * >(argp1);
18462 {
18463 PyThreadState* __tstate = wxPyBeginAllowThreads();
18464 result = (int)((wxEvent const *)arg1)->GetId();
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 resultobj = SWIG_From_int(static_cast< int >(result));
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18476 PyObject *resultobj = 0;
18477 wxEvent *arg1 = (wxEvent *) 0 ;
18478 int arg2 ;
18479 void *argp1 = 0 ;
18480 int res1 = 0 ;
18481 int val2 ;
18482 int ecode2 = 0 ;
18483 PyObject * obj0 = 0 ;
18484 PyObject * obj1 = 0 ;
18485 char * kwnames[] = {
18486 (char *) "self",(char *) "Id", NULL
18487 };
18488
18489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18491 if (!SWIG_IsOK(res1)) {
18492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18493 }
18494 arg1 = reinterpret_cast< wxEvent * >(argp1);
18495 ecode2 = SWIG_AsVal_int(obj1, &val2);
18496 if (!SWIG_IsOK(ecode2)) {
18497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18498 }
18499 arg2 = static_cast< int >(val2);
18500 {
18501 PyThreadState* __tstate = wxPyBeginAllowThreads();
18502 (arg1)->SetId(arg2);
18503 wxPyEndAllowThreads(__tstate);
18504 if (PyErr_Occurred()) SWIG_fail;
18505 }
18506 resultobj = SWIG_Py_Void();
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18514 PyObject *resultobj = 0;
18515 wxEvent *arg1 = (wxEvent *) 0 ;
18516 bool result;
18517 void *argp1 = 0 ;
18518 int res1 = 0 ;
18519 PyObject *swig_obj[1] ;
18520
18521 if (!args) SWIG_fail;
18522 swig_obj[0] = args;
18523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18524 if (!SWIG_IsOK(res1)) {
18525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18526 }
18527 arg1 = reinterpret_cast< wxEvent * >(argp1);
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18531 wxPyEndAllowThreads(__tstate);
18532 if (PyErr_Occurred()) SWIG_fail;
18533 }
18534 {
18535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18536 }
18537 return resultobj;
18538 fail:
18539 return NULL;
18540 }
18541
18542
18543 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj = 0;
18545 wxEvent *arg1 = (wxEvent *) 0 ;
18546 bool arg2 = (bool) true ;
18547 void *argp1 = 0 ;
18548 int res1 = 0 ;
18549 bool val2 ;
18550 int ecode2 = 0 ;
18551 PyObject * obj0 = 0 ;
18552 PyObject * obj1 = 0 ;
18553 char * kwnames[] = {
18554 (char *) "self",(char *) "skip", NULL
18555 };
18556
18557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18559 if (!SWIG_IsOK(res1)) {
18560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18561 }
18562 arg1 = reinterpret_cast< wxEvent * >(argp1);
18563 if (obj1) {
18564 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18565 if (!SWIG_IsOK(ecode2)) {
18566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18567 }
18568 arg2 = static_cast< bool >(val2);
18569 }
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 (arg1)->Skip(arg2);
18573 wxPyEndAllowThreads(__tstate);
18574 if (PyErr_Occurred()) SWIG_fail;
18575 }
18576 resultobj = SWIG_Py_Void();
18577 return resultobj;
18578 fail:
18579 return NULL;
18580 }
18581
18582
18583 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18584 PyObject *resultobj = 0;
18585 wxEvent *arg1 = (wxEvent *) 0 ;
18586 bool result;
18587 void *argp1 = 0 ;
18588 int res1 = 0 ;
18589 PyObject *swig_obj[1] ;
18590
18591 if (!args) SWIG_fail;
18592 swig_obj[0] = args;
18593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18594 if (!SWIG_IsOK(res1)) {
18595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18596 }
18597 arg1 = reinterpret_cast< wxEvent * >(argp1);
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18601 wxPyEndAllowThreads(__tstate);
18602 if (PyErr_Occurred()) SWIG_fail;
18603 }
18604 {
18605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18606 }
18607 return resultobj;
18608 fail:
18609 return NULL;
18610 }
18611
18612
18613 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18614 PyObject *resultobj = 0;
18615 wxEvent *arg1 = (wxEvent *) 0 ;
18616 bool result;
18617 void *argp1 = 0 ;
18618 int res1 = 0 ;
18619 PyObject *swig_obj[1] ;
18620
18621 if (!args) SWIG_fail;
18622 swig_obj[0] = args;
18623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18624 if (!SWIG_IsOK(res1)) {
18625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18626 }
18627 arg1 = reinterpret_cast< wxEvent * >(argp1);
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 {
18635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18636 }
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxEvent *arg1 = (wxEvent *) 0 ;
18646 int result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvent * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (int)(arg1)->StopPropagation();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_From_int(static_cast< int >(result));
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj = 0;
18673 wxEvent *arg1 = (wxEvent *) 0 ;
18674 int arg2 ;
18675 void *argp1 = 0 ;
18676 int res1 = 0 ;
18677 int val2 ;
18678 int ecode2 = 0 ;
18679 PyObject * obj0 = 0 ;
18680 PyObject * obj1 = 0 ;
18681 char * kwnames[] = {
18682 (char *) "self",(char *) "propagationLevel", NULL
18683 };
18684
18685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18687 if (!SWIG_IsOK(res1)) {
18688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18689 }
18690 arg1 = reinterpret_cast< wxEvent * >(argp1);
18691 ecode2 = SWIG_AsVal_int(obj1, &val2);
18692 if (!SWIG_IsOK(ecode2)) {
18693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18694 }
18695 arg2 = static_cast< int >(val2);
18696 {
18697 PyThreadState* __tstate = wxPyBeginAllowThreads();
18698 (arg1)->ResumePropagation(arg2);
18699 wxPyEndAllowThreads(__tstate);
18700 if (PyErr_Occurred()) SWIG_fail;
18701 }
18702 resultobj = SWIG_Py_Void();
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18710 PyObject *resultobj = 0;
18711 wxEvent *arg1 = (wxEvent *) 0 ;
18712 wxEvent *result = 0 ;
18713 void *argp1 = 0 ;
18714 int res1 = 0 ;
18715 PyObject *swig_obj[1] ;
18716
18717 if (!args) SWIG_fail;
18718 swig_obj[0] = args;
18719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvent * >(argp1);
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (wxEvent *)(arg1)->Clone();
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18738 PyObject *obj;
18739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18740 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18741 return SWIG_Py_Void();
18742 }
18743
18744 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18745 PyObject *resultobj = 0;
18746 wxEvent *arg1 = 0 ;
18747 wxPropagationDisabler *result = 0 ;
18748 void *argp1 = 0 ;
18749 int res1 = 0 ;
18750 PyObject * obj0 = 0 ;
18751 char * kwnames[] = {
18752 (char *) "event", NULL
18753 };
18754
18755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18756 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18757 if (!SWIG_IsOK(res1)) {
18758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18759 }
18760 if (!argp1) {
18761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18762 }
18763 arg1 = reinterpret_cast< wxEvent * >(argp1);
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18767 wxPyEndAllowThreads(__tstate);
18768 if (PyErr_Occurred()) SWIG_fail;
18769 }
18770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18771 return resultobj;
18772 fail:
18773 return NULL;
18774 }
18775
18776
18777 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18778 PyObject *resultobj = 0;
18779 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18780 void *argp1 = 0 ;
18781 int res1 = 0 ;
18782 PyObject *swig_obj[1] ;
18783
18784 if (!args) SWIG_fail;
18785 swig_obj[0] = args;
18786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18787 if (!SWIG_IsOK(res1)) {
18788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18789 }
18790 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 delete arg1;
18794
18795 wxPyEndAllowThreads(__tstate);
18796 if (PyErr_Occurred()) SWIG_fail;
18797 }
18798 resultobj = SWIG_Py_Void();
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18806 PyObject *obj;
18807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18808 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18809 return SWIG_Py_Void();
18810 }
18811
18812 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18813 return SWIG_Python_InitShadowInstance(args);
18814 }
18815
18816 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18817 PyObject *resultobj = 0;
18818 wxEvent *arg1 = 0 ;
18819 wxPropagateOnce *result = 0 ;
18820 void *argp1 = 0 ;
18821 int res1 = 0 ;
18822 PyObject * obj0 = 0 ;
18823 char * kwnames[] = {
18824 (char *) "event", NULL
18825 };
18826
18827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18828 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18829 if (!SWIG_IsOK(res1)) {
18830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18831 }
18832 if (!argp1) {
18833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18834 }
18835 arg1 = reinterpret_cast< wxEvent * >(argp1);
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18843 return resultobj;
18844 fail:
18845 return NULL;
18846 }
18847
18848
18849 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18850 PyObject *resultobj = 0;
18851 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 PyObject *swig_obj[1] ;
18855
18856 if (!args) SWIG_fail;
18857 swig_obj[0] = args;
18858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18861 }
18862 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 delete arg1;
18866
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 resultobj = SWIG_Py_Void();
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18878 PyObject *obj;
18879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18880 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18881 return SWIG_Py_Void();
18882 }
18883
18884 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18885 return SWIG_Python_InitShadowInstance(args);
18886 }
18887
18888 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18889 PyObject *resultobj = 0;
18890 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18891 int arg2 = (int) 0 ;
18892 wxCommandEvent *result = 0 ;
18893 int val1 ;
18894 int ecode1 = 0 ;
18895 int val2 ;
18896 int ecode2 = 0 ;
18897 PyObject * obj0 = 0 ;
18898 PyObject * obj1 = 0 ;
18899 char * kwnames[] = {
18900 (char *) "commandType",(char *) "winid", NULL
18901 };
18902
18903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18904 if (obj0) {
18905 ecode1 = SWIG_AsVal_int(obj0, &val1);
18906 if (!SWIG_IsOK(ecode1)) {
18907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18908 }
18909 arg1 = static_cast< wxEventType >(val1);
18910 }
18911 if (obj1) {
18912 ecode2 = SWIG_AsVal_int(obj1, &val2);
18913 if (!SWIG_IsOK(ecode2)) {
18914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18915 }
18916 arg2 = static_cast< int >(val2);
18917 }
18918 {
18919 PyThreadState* __tstate = wxPyBeginAllowThreads();
18920 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18921 wxPyEndAllowThreads(__tstate);
18922 if (PyErr_Occurred()) SWIG_fail;
18923 }
18924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18925 return resultobj;
18926 fail:
18927 return NULL;
18928 }
18929
18930
18931 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18932 PyObject *resultobj = 0;
18933 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18934 int result;
18935 void *argp1 = 0 ;
18936 int res1 = 0 ;
18937 PyObject *swig_obj[1] ;
18938
18939 if (!args) SWIG_fail;
18940 swig_obj[0] = args;
18941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18942 if (!SWIG_IsOK(res1)) {
18943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18944 }
18945 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18946 {
18947 PyThreadState* __tstate = wxPyBeginAllowThreads();
18948 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18949 wxPyEndAllowThreads(__tstate);
18950 if (PyErr_Occurred()) SWIG_fail;
18951 }
18952 resultobj = SWIG_From_int(static_cast< int >(result));
18953 return resultobj;
18954 fail:
18955 return NULL;
18956 }
18957
18958
18959 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18960 PyObject *resultobj = 0;
18961 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18962 wxString *arg2 = 0 ;
18963 void *argp1 = 0 ;
18964 int res1 = 0 ;
18965 bool temp2 = false ;
18966 PyObject * obj0 = 0 ;
18967 PyObject * obj1 = 0 ;
18968 char * kwnames[] = {
18969 (char *) "self",(char *) "s", NULL
18970 };
18971
18972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18974 if (!SWIG_IsOK(res1)) {
18975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18976 }
18977 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18978 {
18979 arg2 = wxString_in_helper(obj1);
18980 if (arg2 == NULL) SWIG_fail;
18981 temp2 = true;
18982 }
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 (arg1)->SetString((wxString const &)*arg2);
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 resultobj = SWIG_Py_Void();
18990 {
18991 if (temp2)
18992 delete arg2;
18993 }
18994 return resultobj;
18995 fail:
18996 {
18997 if (temp2)
18998 delete arg2;
18999 }
19000 return NULL;
19001 }
19002
19003
19004 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19005 PyObject *resultobj = 0;
19006 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19007 wxString result;
19008 void *argp1 = 0 ;
19009 int res1 = 0 ;
19010 PyObject *swig_obj[1] ;
19011
19012 if (!args) SWIG_fail;
19013 swig_obj[0] = args;
19014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19015 if (!SWIG_IsOK(res1)) {
19016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19017 }
19018 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = ((wxCommandEvent const *)arg1)->GetString();
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 #if wxUSE_UNICODE
19027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19028 #else
19029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19030 #endif
19031 }
19032 return resultobj;
19033 fail:
19034 return NULL;
19035 }
19036
19037
19038 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19039 PyObject *resultobj = 0;
19040 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19041 bool result;
19042 void *argp1 = 0 ;
19043 int res1 = 0 ;
19044 PyObject *swig_obj[1] ;
19045
19046 if (!args) SWIG_fail;
19047 swig_obj[0] = args;
19048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19051 }
19052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 {
19060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19061 }
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19069 PyObject *resultobj = 0;
19070 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19071 bool result;
19072 void *argp1 = 0 ;
19073 int res1 = 0 ;
19074 PyObject *swig_obj[1] ;
19075
19076 if (!args) SWIG_fail;
19077 swig_obj[0] = args;
19078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19079 if (!SWIG_IsOK(res1)) {
19080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19081 }
19082 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19083 {
19084 PyThreadState* __tstate = wxPyBeginAllowThreads();
19085 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19086 wxPyEndAllowThreads(__tstate);
19087 if (PyErr_Occurred()) SWIG_fail;
19088 }
19089 {
19090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19091 }
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = 0;
19100 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19101 long arg2 ;
19102 void *argp1 = 0 ;
19103 int res1 = 0 ;
19104 long val2 ;
19105 int ecode2 = 0 ;
19106 PyObject * obj0 = 0 ;
19107 PyObject * obj1 = 0 ;
19108 char * kwnames[] = {
19109 (char *) "self",(char *) "extraLong", NULL
19110 };
19111
19112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19114 if (!SWIG_IsOK(res1)) {
19115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19116 }
19117 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19118 ecode2 = SWIG_AsVal_long(obj1, &val2);
19119 if (!SWIG_IsOK(ecode2)) {
19120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19121 }
19122 arg2 = static_cast< long >(val2);
19123 {
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 (arg1)->SetExtraLong(arg2);
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = SWIG_Py_Void();
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19137 PyObject *resultobj = 0;
19138 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19139 long result;
19140 void *argp1 = 0 ;
19141 int res1 = 0 ;
19142 PyObject *swig_obj[1] ;
19143
19144 if (!args) SWIG_fail;
19145 swig_obj[0] = args;
19146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19147 if (!SWIG_IsOK(res1)) {
19148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19149 }
19150 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = SWIG_From_long(static_cast< long >(result));
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19165 PyObject *resultobj = 0;
19166 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19167 int arg2 ;
19168 void *argp1 = 0 ;
19169 int res1 = 0 ;
19170 int val2 ;
19171 int ecode2 = 0 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 char * kwnames[] = {
19175 (char *) "self",(char *) "i", NULL
19176 };
19177
19178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19180 if (!SWIG_IsOK(res1)) {
19181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19182 }
19183 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19184 ecode2 = SWIG_AsVal_int(obj1, &val2);
19185 if (!SWIG_IsOK(ecode2)) {
19186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19187 }
19188 arg2 = static_cast< int >(val2);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 (arg1)->SetInt(arg2);
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_Py_Void();
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19203 PyObject *resultobj = 0;
19204 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19205 int result;
19206 void *argp1 = 0 ;
19207 int res1 = 0 ;
19208 PyObject *swig_obj[1] ;
19209
19210 if (!args) SWIG_fail;
19211 swig_obj[0] = args;
19212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19213 if (!SWIG_IsOK(res1)) {
19214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19215 }
19216 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19217 {
19218 PyThreadState* __tstate = wxPyBeginAllowThreads();
19219 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 resultobj = SWIG_From_int(static_cast< int >(result));
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19231 PyObject *resultobj = 0;
19232 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19233 PyObject *result = 0 ;
19234 void *argp1 = 0 ;
19235 int res1 = 0 ;
19236 PyObject *swig_obj[1] ;
19237
19238 if (!args) SWIG_fail;
19239 swig_obj[0] = args;
19240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19241 if (!SWIG_IsOK(res1)) {
19242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19243 }
19244 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 resultobj = result;
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj = 0;
19260 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19261 PyObject *arg2 = (PyObject *) 0 ;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 PyObject * obj0 = 0 ;
19265 PyObject * obj1 = 0 ;
19266 char * kwnames[] = {
19267 (char *) "self",(char *) "clientData", NULL
19268 };
19269
19270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19272 if (!SWIG_IsOK(res1)) {
19273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19274 }
19275 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19276 arg2 = obj1;
19277 {
19278 PyThreadState* __tstate = wxPyBeginAllowThreads();
19279 wxCommandEvent_SetClientData(arg1,arg2);
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 resultobj = SWIG_Py_Void();
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19291 PyObject *resultobj = 0;
19292 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19293 wxEvent *result = 0 ;
19294 void *argp1 = 0 ;
19295 int res1 = 0 ;
19296 PyObject *swig_obj[1] ;
19297
19298 if (!args) SWIG_fail;
19299 swig_obj[0] = args;
19300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19301 if (!SWIG_IsOK(res1)) {
19302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19303 }
19304 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19305 {
19306 PyThreadState* __tstate = wxPyBeginAllowThreads();
19307 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19312 return resultobj;
19313 fail:
19314 return NULL;
19315 }
19316
19317
19318 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19319 PyObject *obj;
19320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19321 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19322 return SWIG_Py_Void();
19323 }
19324
19325 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19326 return SWIG_Python_InitShadowInstance(args);
19327 }
19328
19329 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj = 0;
19331 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19332 int arg2 = (int) 0 ;
19333 wxNotifyEvent *result = 0 ;
19334 int val1 ;
19335 int ecode1 = 0 ;
19336 int val2 ;
19337 int ecode2 = 0 ;
19338 PyObject * obj0 = 0 ;
19339 PyObject * obj1 = 0 ;
19340 char * kwnames[] = {
19341 (char *) "commandType",(char *) "winid", NULL
19342 };
19343
19344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19345 if (obj0) {
19346 ecode1 = SWIG_AsVal_int(obj0, &val1);
19347 if (!SWIG_IsOK(ecode1)) {
19348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19349 }
19350 arg1 = static_cast< wxEventType >(val1);
19351 }
19352 if (obj1) {
19353 ecode2 = SWIG_AsVal_int(obj1, &val2);
19354 if (!SWIG_IsOK(ecode2)) {
19355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19356 }
19357 arg2 = static_cast< int >(val2);
19358 }
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19366 return resultobj;
19367 fail:
19368 return NULL;
19369 }
19370
19371
19372 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19373 PyObject *resultobj = 0;
19374 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19375 void *argp1 = 0 ;
19376 int res1 = 0 ;
19377 PyObject *swig_obj[1] ;
19378
19379 if (!args) SWIG_fail;
19380 swig_obj[0] = args;
19381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19382 if (!SWIG_IsOK(res1)) {
19383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19384 }
19385 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 (arg1)->Veto();
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 resultobj = SWIG_Py_Void();
19393 return resultobj;
19394 fail:
19395 return NULL;
19396 }
19397
19398
19399 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19400 PyObject *resultobj = 0;
19401 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19402 void *argp1 = 0 ;
19403 int res1 = 0 ;
19404 PyObject *swig_obj[1] ;
19405
19406 if (!args) SWIG_fail;
19407 swig_obj[0] = args;
19408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19409 if (!SWIG_IsOK(res1)) {
19410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19411 }
19412 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 (arg1)->Allow();
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 resultobj = SWIG_Py_Void();
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19427 PyObject *resultobj = 0;
19428 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19429 bool result;
19430 void *argp1 = 0 ;
19431 int res1 = 0 ;
19432 PyObject *swig_obj[1] ;
19433
19434 if (!args) SWIG_fail;
19435 swig_obj[0] = args;
19436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (bool)(arg1)->IsAllowed();
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 {
19448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19449 }
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19457 PyObject *obj;
19458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19459 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19460 return SWIG_Py_Void();
19461 }
19462
19463 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19464 return SWIG_Python_InitShadowInstance(args);
19465 }
19466
19467 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj = 0;
19469 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19470 int arg2 = (int) 0 ;
19471 int arg3 = (int) 0 ;
19472 int arg4 = (int) 0 ;
19473 wxScrollEvent *result = 0 ;
19474 int val1 ;
19475 int ecode1 = 0 ;
19476 int val2 ;
19477 int ecode2 = 0 ;
19478 int val3 ;
19479 int ecode3 = 0 ;
19480 int val4 ;
19481 int ecode4 = 0 ;
19482 PyObject * obj0 = 0 ;
19483 PyObject * obj1 = 0 ;
19484 PyObject * obj2 = 0 ;
19485 PyObject * obj3 = 0 ;
19486 char * kwnames[] = {
19487 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19488 };
19489
19490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19491 if (obj0) {
19492 ecode1 = SWIG_AsVal_int(obj0, &val1);
19493 if (!SWIG_IsOK(ecode1)) {
19494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19495 }
19496 arg1 = static_cast< wxEventType >(val1);
19497 }
19498 if (obj1) {
19499 ecode2 = SWIG_AsVal_int(obj1, &val2);
19500 if (!SWIG_IsOK(ecode2)) {
19501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19502 }
19503 arg2 = static_cast< int >(val2);
19504 }
19505 if (obj2) {
19506 ecode3 = SWIG_AsVal_int(obj2, &val3);
19507 if (!SWIG_IsOK(ecode3)) {
19508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19509 }
19510 arg3 = static_cast< int >(val3);
19511 }
19512 if (obj3) {
19513 ecode4 = SWIG_AsVal_int(obj3, &val4);
19514 if (!SWIG_IsOK(ecode4)) {
19515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19516 }
19517 arg4 = static_cast< int >(val4);
19518 }
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19533 PyObject *resultobj = 0;
19534 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19535 int result;
19536 void *argp1 = 0 ;
19537 int res1 = 0 ;
19538 PyObject *swig_obj[1] ;
19539
19540 if (!args) SWIG_fail;
19541 swig_obj[0] = args;
19542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19545 }
19546 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_From_int(static_cast< int >(result));
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19563 int result;
19564 void *argp1 = 0 ;
19565 int res1 = 0 ;
19566 PyObject *swig_obj[1] ;
19567
19568 if (!args) SWIG_fail;
19569 swig_obj[0] = args;
19570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19571 if (!SWIG_IsOK(res1)) {
19572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19573 }
19574 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19575 {
19576 PyThreadState* __tstate = wxPyBeginAllowThreads();
19577 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 resultobj = SWIG_From_int(static_cast< int >(result));
19582 return resultobj;
19583 fail:
19584 return NULL;
19585 }
19586
19587
19588 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19589 PyObject *resultobj = 0;
19590 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19591 int arg2 ;
19592 void *argp1 = 0 ;
19593 int res1 = 0 ;
19594 int val2 ;
19595 int ecode2 = 0 ;
19596 PyObject * obj0 = 0 ;
19597 PyObject * obj1 = 0 ;
19598 char * kwnames[] = {
19599 (char *) "self",(char *) "orient", NULL
19600 };
19601
19602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19604 if (!SWIG_IsOK(res1)) {
19605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19606 }
19607 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19608 ecode2 = SWIG_AsVal_int(obj1, &val2);
19609 if (!SWIG_IsOK(ecode2)) {
19610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19611 }
19612 arg2 = static_cast< int >(val2);
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 (arg1)->SetOrientation(arg2);
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_Py_Void();
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19629 int arg2 ;
19630 void *argp1 = 0 ;
19631 int res1 = 0 ;
19632 int val2 ;
19633 int ecode2 = 0 ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 char * kwnames[] = {
19637 (char *) "self",(char *) "pos", NULL
19638 };
19639
19640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19642 if (!SWIG_IsOK(res1)) {
19643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19644 }
19645 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19646 ecode2 = SWIG_AsVal_int(obj1, &val2);
19647 if (!SWIG_IsOK(ecode2)) {
19648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19649 }
19650 arg2 = static_cast< int >(val2);
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->SetPosition(arg2);
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 resultobj = SWIG_Py_Void();
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19665 PyObject *obj;
19666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19667 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19668 return SWIG_Py_Void();
19669 }
19670
19671 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19672 return SWIG_Python_InitShadowInstance(args);
19673 }
19674
19675 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19676 PyObject *resultobj = 0;
19677 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19678 int arg2 = (int) 0 ;
19679 int arg3 = (int) 0 ;
19680 wxScrollWinEvent *result = 0 ;
19681 int val1 ;
19682 int ecode1 = 0 ;
19683 int val2 ;
19684 int ecode2 = 0 ;
19685 int val3 ;
19686 int ecode3 = 0 ;
19687 PyObject * obj0 = 0 ;
19688 PyObject * obj1 = 0 ;
19689 PyObject * obj2 = 0 ;
19690 char * kwnames[] = {
19691 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19692 };
19693
19694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19695 if (obj0) {
19696 ecode1 = SWIG_AsVal_int(obj0, &val1);
19697 if (!SWIG_IsOK(ecode1)) {
19698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19699 }
19700 arg1 = static_cast< wxEventType >(val1);
19701 }
19702 if (obj1) {
19703 ecode2 = SWIG_AsVal_int(obj1, &val2);
19704 if (!SWIG_IsOK(ecode2)) {
19705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19706 }
19707 arg2 = static_cast< int >(val2);
19708 }
19709 if (obj2) {
19710 ecode3 = SWIG_AsVal_int(obj2, &val3);
19711 if (!SWIG_IsOK(ecode3)) {
19712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19713 }
19714 arg3 = static_cast< int >(val3);
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19730 PyObject *resultobj = 0;
19731 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19732 int result;
19733 void *argp1 = 0 ;
19734 int res1 = 0 ;
19735 PyObject *swig_obj[1] ;
19736
19737 if (!args) SWIG_fail;
19738 swig_obj[0] = args;
19739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19740 if (!SWIG_IsOK(res1)) {
19741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19742 }
19743 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 resultobj = SWIG_From_int(static_cast< int >(result));
19751 return resultobj;
19752 fail:
19753 return NULL;
19754 }
19755
19756
19757 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19758 PyObject *resultobj = 0;
19759 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19760 int result;
19761 void *argp1 = 0 ;
19762 int res1 = 0 ;
19763 PyObject *swig_obj[1] ;
19764
19765 if (!args) SWIG_fail;
19766 swig_obj[0] = args;
19767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19768 if (!SWIG_IsOK(res1)) {
19769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19770 }
19771 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19775 wxPyEndAllowThreads(__tstate);
19776 if (PyErr_Occurred()) SWIG_fail;
19777 }
19778 resultobj = SWIG_From_int(static_cast< int >(result));
19779 return resultobj;
19780 fail:
19781 return NULL;
19782 }
19783
19784
19785 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19786 PyObject *resultobj = 0;
19787 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19788 int arg2 ;
19789 void *argp1 = 0 ;
19790 int res1 = 0 ;
19791 int val2 ;
19792 int ecode2 = 0 ;
19793 PyObject * obj0 = 0 ;
19794 PyObject * obj1 = 0 ;
19795 char * kwnames[] = {
19796 (char *) "self",(char *) "orient", NULL
19797 };
19798
19799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19801 if (!SWIG_IsOK(res1)) {
19802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19803 }
19804 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19805 ecode2 = SWIG_AsVal_int(obj1, &val2);
19806 if (!SWIG_IsOK(ecode2)) {
19807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19808 }
19809 arg2 = static_cast< int >(val2);
19810 {
19811 PyThreadState* __tstate = wxPyBeginAllowThreads();
19812 (arg1)->SetOrientation(arg2);
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 resultobj = SWIG_Py_Void();
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19826 int arg2 ;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 int val2 ;
19830 int ecode2 = 0 ;
19831 PyObject * obj0 = 0 ;
19832 PyObject * obj1 = 0 ;
19833 char * kwnames[] = {
19834 (char *) "self",(char *) "pos", NULL
19835 };
19836
19837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19841 }
19842 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19843 ecode2 = SWIG_AsVal_int(obj1, &val2);
19844 if (!SWIG_IsOK(ecode2)) {
19845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19846 }
19847 arg2 = static_cast< int >(val2);
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 (arg1)->SetPosition(arg2);
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 resultobj = SWIG_Py_Void();
19855 return resultobj;
19856 fail:
19857 return NULL;
19858 }
19859
19860
19861 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19862 PyObject *obj;
19863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19864 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19865 return SWIG_Py_Void();
19866 }
19867
19868 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19869 return SWIG_Python_InitShadowInstance(args);
19870 }
19871
19872 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj = 0;
19874 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19875 wxMouseEvent *result = 0 ;
19876 int val1 ;
19877 int ecode1 = 0 ;
19878 PyObject * obj0 = 0 ;
19879 char * kwnames[] = {
19880 (char *) "mouseType", NULL
19881 };
19882
19883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19884 if (obj0) {
19885 ecode1 = SWIG_AsVal_int(obj0, &val1);
19886 if (!SWIG_IsOK(ecode1)) {
19887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19888 }
19889 arg1 = static_cast< wxEventType >(val1);
19890 }
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 {
19898 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19899 }
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19907 PyObject *resultobj = 0;
19908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19909 bool result;
19910 void *argp1 = 0 ;
19911 int res1 = 0 ;
19912 PyObject *swig_obj[1] ;
19913
19914 if (!args) SWIG_fail;
19915 swig_obj[0] = args;
19916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19917 if (!SWIG_IsOK(res1)) {
19918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19919 }
19920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 {
19928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19929 }
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj = 0;
19938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19939 int arg2 = (int) wxMOUSE_BTN_ANY ;
19940 bool result;
19941 void *argp1 = 0 ;
19942 int res1 = 0 ;
19943 int val2 ;
19944 int ecode2 = 0 ;
19945 PyObject * obj0 = 0 ;
19946 PyObject * obj1 = 0 ;
19947 char * kwnames[] = {
19948 (char *) "self",(char *) "but", NULL
19949 };
19950
19951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19953 if (!SWIG_IsOK(res1)) {
19954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19955 }
19956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19957 if (obj1) {
19958 ecode2 = SWIG_AsVal_int(obj1, &val2);
19959 if (!SWIG_IsOK(ecode2)) {
19960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19961 }
19962 arg2 = static_cast< int >(val2);
19963 }
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19967 wxPyEndAllowThreads(__tstate);
19968 if (PyErr_Occurred()) SWIG_fail;
19969 }
19970 {
19971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19972 }
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj = 0;
19981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19982 int arg2 = (int) wxMOUSE_BTN_ANY ;
19983 bool result;
19984 void *argp1 = 0 ;
19985 int res1 = 0 ;
19986 int val2 ;
19987 int ecode2 = 0 ;
19988 PyObject * obj0 = 0 ;
19989 PyObject * obj1 = 0 ;
19990 char * kwnames[] = {
19991 (char *) "self",(char *) "but", NULL
19992 };
19993
19994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19996 if (!SWIG_IsOK(res1)) {
19997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19998 }
19999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20000 if (obj1) {
20001 ecode2 = SWIG_AsVal_int(obj1, &val2);
20002 if (!SWIG_IsOK(ecode2)) {
20003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20004 }
20005 arg2 = static_cast< int >(val2);
20006 }
20007 {
20008 PyThreadState* __tstate = wxPyBeginAllowThreads();
20009 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 {
20014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20015 }
20016 return resultobj;
20017 fail:
20018 return NULL;
20019 }
20020
20021
20022 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20023 PyObject *resultobj = 0;
20024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20025 int arg2 = (int) wxMOUSE_BTN_ANY ;
20026 bool result;
20027 void *argp1 = 0 ;
20028 int res1 = 0 ;
20029 int val2 ;
20030 int ecode2 = 0 ;
20031 PyObject * obj0 = 0 ;
20032 PyObject * obj1 = 0 ;
20033 char * kwnames[] = {
20034 (char *) "self",(char *) "but", NULL
20035 };
20036
20037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20039 if (!SWIG_IsOK(res1)) {
20040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20041 }
20042 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20043 if (obj1) {
20044 ecode2 = SWIG_AsVal_int(obj1, &val2);
20045 if (!SWIG_IsOK(ecode2)) {
20046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20047 }
20048 arg2 = static_cast< int >(val2);
20049 }
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20053 wxPyEndAllowThreads(__tstate);
20054 if (PyErr_Occurred()) SWIG_fail;
20055 }
20056 {
20057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20058 }
20059 return resultobj;
20060 fail:
20061 return NULL;
20062 }
20063
20064
20065 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj = 0;
20067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20068 int arg2 ;
20069 bool result;
20070 void *argp1 = 0 ;
20071 int res1 = 0 ;
20072 int val2 ;
20073 int ecode2 = 0 ;
20074 PyObject * obj0 = 0 ;
20075 PyObject * obj1 = 0 ;
20076 char * kwnames[] = {
20077 (char *) "self",(char *) "button", NULL
20078 };
20079
20080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20082 if (!SWIG_IsOK(res1)) {
20083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20084 }
20085 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20086 ecode2 = SWIG_AsVal_int(obj1, &val2);
20087 if (!SWIG_IsOK(ecode2)) {
20088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20089 }
20090 arg2 = static_cast< int >(val2);
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20094 wxPyEndAllowThreads(__tstate);
20095 if (PyErr_Occurred()) SWIG_fail;
20096 }
20097 {
20098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20099 }
20100 return resultobj;
20101 fail:
20102 return NULL;
20103 }
20104
20105
20106 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20107 PyObject *resultobj = 0;
20108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20109 int arg2 ;
20110 bool result;
20111 void *argp1 = 0 ;
20112 int res1 = 0 ;
20113 int val2 ;
20114 int ecode2 = 0 ;
20115 PyObject * obj0 = 0 ;
20116 PyObject * obj1 = 0 ;
20117 char * kwnames[] = {
20118 (char *) "self",(char *) "but", NULL
20119 };
20120
20121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20123 if (!SWIG_IsOK(res1)) {
20124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20125 }
20126 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20127 ecode2 = SWIG_AsVal_int(obj1, &val2);
20128 if (!SWIG_IsOK(ecode2)) {
20129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20130 }
20131 arg2 = static_cast< int >(val2);
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 {
20139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20140 }
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *resultobj = 0;
20149 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20150 int result;
20151 void *argp1 = 0 ;
20152 int res1 = 0 ;
20153 PyObject *swig_obj[1] ;
20154
20155 if (!args) SWIG_fail;
20156 swig_obj[0] = args;
20157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20158 if (!SWIG_IsOK(res1)) {
20159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20160 }
20161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 resultobj = SWIG_From_int(static_cast< int >(result));
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 PyObject *resultobj = 0;
20177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20178 bool result;
20179 void *argp1 = 0 ;
20180 int res1 = 0 ;
20181 PyObject *swig_obj[1] ;
20182
20183 if (!args) SWIG_fail;
20184 swig_obj[0] = args;
20185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20186 if (!SWIG_IsOK(res1)) {
20187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20188 }
20189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20190 {
20191 PyThreadState* __tstate = wxPyBeginAllowThreads();
20192 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 {
20197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20198 }
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206 PyObject *resultobj = 0;
20207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20208 bool result;
20209 void *argp1 = 0 ;
20210 int res1 = 0 ;
20211 PyObject *swig_obj[1] ;
20212
20213 if (!args) SWIG_fail;
20214 swig_obj[0] = args;
20215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20216 if (!SWIG_IsOK(res1)) {
20217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20218 }
20219 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 {
20227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20228 }
20229 return resultobj;
20230 fail:
20231 return NULL;
20232 }
20233
20234
20235 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20236 PyObject *resultobj = 0;
20237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20238 bool result;
20239 void *argp1 = 0 ;
20240 int res1 = 0 ;
20241 PyObject *swig_obj[1] ;
20242
20243 if (!args) SWIG_fail;
20244 swig_obj[0] = args;
20245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20246 if (!SWIG_IsOK(res1)) {
20247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20248 }
20249 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 {
20257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20258 }
20259 return resultobj;
20260 fail:
20261 return NULL;
20262 }
20263
20264
20265 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20266 PyObject *resultobj = 0;
20267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20268 bool result;
20269 void *argp1 = 0 ;
20270 int res1 = 0 ;
20271 PyObject *swig_obj[1] ;
20272
20273 if (!args) SWIG_fail;
20274 swig_obj[0] = args;
20275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20276 if (!SWIG_IsOK(res1)) {
20277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20278 }
20279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20283 wxPyEndAllowThreads(__tstate);
20284 if (PyErr_Occurred()) SWIG_fail;
20285 }
20286 {
20287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20288 }
20289 return resultobj;
20290 fail:
20291 return NULL;
20292 }
20293
20294
20295 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20296 PyObject *resultobj = 0;
20297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20298 bool result;
20299 void *argp1 = 0 ;
20300 int res1 = 0 ;
20301 PyObject *swig_obj[1] ;
20302
20303 if (!args) SWIG_fail;
20304 swig_obj[0] = args;
20305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20306 if (!SWIG_IsOK(res1)) {
20307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20308 }
20309 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 {
20317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20318 }
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 PyObject *resultobj = 0;
20327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20328 bool result;
20329 void *argp1 = 0 ;
20330 int res1 = 0 ;
20331 PyObject *swig_obj[1] ;
20332
20333 if (!args) SWIG_fail;
20334 swig_obj[0] = args;
20335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20336 if (!SWIG_IsOK(res1)) {
20337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20338 }
20339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 {
20347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20348 }
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20356 PyObject *resultobj = 0;
20357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20358 bool result;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 PyObject *swig_obj[1] ;
20362
20363 if (!args) SWIG_fail;
20364 swig_obj[0] = args;
20365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20366 if (!SWIG_IsOK(res1)) {
20367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20368 }
20369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20373 wxPyEndAllowThreads(__tstate);
20374 if (PyErr_Occurred()) SWIG_fail;
20375 }
20376 {
20377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20378 }
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 PyObject *resultobj = 0;
20387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20388 bool result;
20389 void *argp1 = 0 ;
20390 int res1 = 0 ;
20391 PyObject *swig_obj[1] ;
20392
20393 if (!args) SWIG_fail;
20394 swig_obj[0] = args;
20395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20396 if (!SWIG_IsOK(res1)) {
20397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20398 }
20399 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 PyObject *resultobj = 0;
20417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20418 bool result;
20419 void *argp1 = 0 ;
20420 int res1 = 0 ;
20421 PyObject *swig_obj[1] ;
20422
20423 if (!args) SWIG_fail;
20424 swig_obj[0] = args;
20425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20426 if (!SWIG_IsOK(res1)) {
20427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20428 }
20429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20448 bool result;
20449 void *argp1 = 0 ;
20450 int res1 = 0 ;
20451 PyObject *swig_obj[1] ;
20452
20453 if (!args) SWIG_fail;
20454 swig_obj[0] = args;
20455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20456 if (!SWIG_IsOK(res1)) {
20457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20458 }
20459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20478 bool result;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 PyObject *swig_obj[1] ;
20482
20483 if (!args) SWIG_fail;
20484 swig_obj[0] = args;
20485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20488 }
20489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20506 PyObject *resultobj = 0;
20507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20508 bool result;
20509 void *argp1 = 0 ;
20510 int res1 = 0 ;
20511 PyObject *swig_obj[1] ;
20512
20513 if (!args) SWIG_fail;
20514 swig_obj[0] = args;
20515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20518 }
20519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20520 {
20521 PyThreadState* __tstate = wxPyBeginAllowThreads();
20522 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 {
20527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20528 }
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20536 PyObject *resultobj = 0;
20537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20538 bool result;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 PyObject *swig_obj[1] ;
20542
20543 if (!args) SWIG_fail;
20544 swig_obj[0] = args;
20545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20546 if (!SWIG_IsOK(res1)) {
20547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20548 }
20549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20550 {
20551 PyThreadState* __tstate = wxPyBeginAllowThreads();
20552 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 {
20557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20566 PyObject *resultobj = 0;
20567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 PyObject *swig_obj[1] ;
20572
20573 if (!args) SWIG_fail;
20574 swig_obj[0] = args;
20575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20578 }
20579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20596 PyObject *resultobj = 0;
20597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20598 bool result;
20599 void *argp1 = 0 ;
20600 int res1 = 0 ;
20601 PyObject *swig_obj[1] ;
20602
20603 if (!args) SWIG_fail;
20604 swig_obj[0] = args;
20605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20608 }
20609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (bool)(arg1)->LeftIsDown();
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20618 }
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20626 PyObject *resultobj = 0;
20627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20628 bool result;
20629 void *argp1 = 0 ;
20630 int res1 = 0 ;
20631 PyObject *swig_obj[1] ;
20632
20633 if (!args) SWIG_fail;
20634 swig_obj[0] = args;
20635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20636 if (!SWIG_IsOK(res1)) {
20637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20638 }
20639 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 result = (bool)(arg1)->MiddleIsDown();
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 {
20647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20648 }
20649 return resultobj;
20650 fail:
20651 return NULL;
20652 }
20653
20654
20655 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20656 PyObject *resultobj = 0;
20657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20658 bool result;
20659 void *argp1 = 0 ;
20660 int res1 = 0 ;
20661 PyObject *swig_obj[1] ;
20662
20663 if (!args) SWIG_fail;
20664 swig_obj[0] = args;
20665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20666 if (!SWIG_IsOK(res1)) {
20667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20668 }
20669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20670 {
20671 PyThreadState* __tstate = wxPyBeginAllowThreads();
20672 result = (bool)(arg1)->RightIsDown();
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20678 }
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20686 PyObject *resultobj = 0;
20687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20688 bool result;
20689 void *argp1 = 0 ;
20690 int res1 = 0 ;
20691 PyObject *swig_obj[1] ;
20692
20693 if (!args) SWIG_fail;
20694 swig_obj[0] = args;
20695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20696 if (!SWIG_IsOK(res1)) {
20697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20698 }
20699 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20708 }
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20716 PyObject *resultobj = 0;
20717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20718 bool result;
20719 void *argp1 = 0 ;
20720 int res1 = 0 ;
20721 PyObject *swig_obj[1] ;
20722
20723 if (!args) SWIG_fail;
20724 swig_obj[0] = args;
20725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20726 if (!SWIG_IsOK(res1)) {
20727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20728 }
20729 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20746 PyObject *resultobj = 0;
20747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20748 bool result;
20749 void *argp1 = 0 ;
20750 int res1 = 0 ;
20751 PyObject *swig_obj[1] ;
20752
20753 if (!args) SWIG_fail;
20754 swig_obj[0] = args;
20755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20758 }
20759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 {
20767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20768 }
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20776 PyObject *resultobj = 0;
20777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20778 bool result;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 PyObject *swig_obj[1] ;
20782
20783 if (!args) SWIG_fail;
20784 swig_obj[0] = args;
20785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20786 if (!SWIG_IsOK(res1)) {
20787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20788 }
20789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20793 wxPyEndAllowThreads(__tstate);
20794 if (PyErr_Occurred()) SWIG_fail;
20795 }
20796 {
20797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20798 }
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20806 PyObject *resultobj = 0;
20807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20808 wxPoint result;
20809 void *argp1 = 0 ;
20810 int res1 = 0 ;
20811 PyObject *swig_obj[1] ;
20812
20813 if (!args) SWIG_fail;
20814 swig_obj[0] = args;
20815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20816 if (!SWIG_IsOK(res1)) {
20817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20818 }
20819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (arg1)->GetPosition();
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20827 return resultobj;
20828 fail:
20829 return NULL;
20830 }
20831
20832
20833 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20834 PyObject *resultobj = 0;
20835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20836 long *arg2 = (long *) 0 ;
20837 long *arg3 = (long *) 0 ;
20838 void *argp1 = 0 ;
20839 int res1 = 0 ;
20840 long temp2 ;
20841 int res2 = SWIG_TMPOBJ ;
20842 long temp3 ;
20843 int res3 = SWIG_TMPOBJ ;
20844 PyObject *swig_obj[1] ;
20845
20846 arg2 = &temp2;
20847 arg3 = &temp3;
20848 if (!args) SWIG_fail;
20849 swig_obj[0] = args;
20850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20851 if (!SWIG_IsOK(res1)) {
20852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20853 }
20854 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20855 {
20856 PyThreadState* __tstate = wxPyBeginAllowThreads();
20857 (arg1)->GetPosition(arg2,arg3);
20858 wxPyEndAllowThreads(__tstate);
20859 if (PyErr_Occurred()) SWIG_fail;
20860 }
20861 resultobj = SWIG_Py_Void();
20862 if (SWIG_IsTmpObj(res2)) {
20863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20864 } else {
20865 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20867 }
20868 if (SWIG_IsTmpObj(res3)) {
20869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20870 } else {
20871 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20873 }
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20881 PyObject *resultobj = 0;
20882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20883 wxDC *arg2 = 0 ;
20884 wxPoint result;
20885 void *argp1 = 0 ;
20886 int res1 = 0 ;
20887 void *argp2 = 0 ;
20888 int res2 = 0 ;
20889 PyObject * obj0 = 0 ;
20890 PyObject * obj1 = 0 ;
20891 char * kwnames[] = {
20892 (char *) "self",(char *) "dc", NULL
20893 };
20894
20895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20899 }
20900 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20901 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20902 if (!SWIG_IsOK(res2)) {
20903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20904 }
20905 if (!argp2) {
20906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20907 }
20908 arg2 = reinterpret_cast< wxDC * >(argp2);
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20923 PyObject *resultobj = 0;
20924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20925 int result;
20926 void *argp1 = 0 ;
20927 int res1 = 0 ;
20928 PyObject *swig_obj[1] ;
20929
20930 if (!args) SWIG_fail;
20931 swig_obj[0] = args;
20932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20933 if (!SWIG_IsOK(res1)) {
20934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20935 }
20936 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20937 {
20938 PyThreadState* __tstate = wxPyBeginAllowThreads();
20939 result = (int)((wxMouseEvent const *)arg1)->GetX();
20940 wxPyEndAllowThreads(__tstate);
20941 if (PyErr_Occurred()) SWIG_fail;
20942 }
20943 resultobj = SWIG_From_int(static_cast< int >(result));
20944 return resultobj;
20945 fail:
20946 return NULL;
20947 }
20948
20949
20950 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20951 PyObject *resultobj = 0;
20952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20953 int result;
20954 void *argp1 = 0 ;
20955 int res1 = 0 ;
20956 PyObject *swig_obj[1] ;
20957
20958 if (!args) SWIG_fail;
20959 swig_obj[0] = args;
20960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20961 if (!SWIG_IsOK(res1)) {
20962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20963 }
20964 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (int)((wxMouseEvent const *)arg1)->GetY();
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 resultobj = SWIG_From_int(static_cast< int >(result));
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20981 int result;
20982 void *argp1 = 0 ;
20983 int res1 = 0 ;
20984 PyObject *swig_obj[1] ;
20985
20986 if (!args) SWIG_fail;
20987 swig_obj[0] = args;
20988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20989 if (!SWIG_IsOK(res1)) {
20990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20991 }
20992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 resultobj = SWIG_From_int(static_cast< int >(result));
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21007 PyObject *resultobj = 0;
21008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21009 int result;
21010 void *argp1 = 0 ;
21011 int res1 = 0 ;
21012 PyObject *swig_obj[1] ;
21013
21014 if (!args) SWIG_fail;
21015 swig_obj[0] = args;
21016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21017 if (!SWIG_IsOK(res1)) {
21018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21019 }
21020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 resultobj = SWIG_From_int(static_cast< int >(result));
21028 return resultobj;
21029 fail:
21030 return NULL;
21031 }
21032
21033
21034 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21035 PyObject *resultobj = 0;
21036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21037 int result;
21038 void *argp1 = 0 ;
21039 int res1 = 0 ;
21040 PyObject *swig_obj[1] ;
21041
21042 if (!args) SWIG_fail;
21043 swig_obj[0] = args;
21044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21045 if (!SWIG_IsOK(res1)) {
21046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21047 }
21048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 resultobj = SWIG_From_int(static_cast< int >(result));
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21065 bool result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 PyObject *swig_obj[1] ;
21069
21070 if (!args) SWIG_fail;
21071 swig_obj[0] = args;
21072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21073 if (!SWIG_IsOK(res1)) {
21074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21075 }
21076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 {
21084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21085 }
21086 return resultobj;
21087 fail:
21088 return NULL;
21089 }
21090
21091
21092 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21093 PyObject *resultobj = 0;
21094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21095 int arg2 ;
21096 void *argp1 = 0 ;
21097 int res1 = 0 ;
21098 int val2 ;
21099 int ecode2 = 0 ;
21100 PyObject *swig_obj[2] ;
21101
21102 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21104 if (!SWIG_IsOK(res1)) {
21105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21106 }
21107 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21109 if (!SWIG_IsOK(ecode2)) {
21110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21111 }
21112 arg2 = static_cast< int >(val2);
21113 if (arg1) (arg1)->m_x = arg2;
21114
21115 resultobj = SWIG_Py_Void();
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21125 int result;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 PyObject *swig_obj[1] ;
21129
21130 if (!args) SWIG_fail;
21131 swig_obj[0] = args;
21132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21135 }
21136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21137 result = (int) ((arg1)->m_x);
21138 resultobj = SWIG_From_int(static_cast< int >(result));
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21148 int arg2 ;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 int val2 ;
21152 int ecode2 = 0 ;
21153 PyObject *swig_obj[2] ;
21154
21155 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21159 }
21160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21161 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21162 if (!SWIG_IsOK(ecode2)) {
21163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21164 }
21165 arg2 = static_cast< int >(val2);
21166 if (arg1) (arg1)->m_y = arg2;
21167
21168 resultobj = SWIG_Py_Void();
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21178 int result;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21188 }
21189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21190 result = (int) ((arg1)->m_y);
21191 resultobj = SWIG_From_int(static_cast< int >(result));
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21199 PyObject *resultobj = 0;
21200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21201 bool arg2 ;
21202 void *argp1 = 0 ;
21203 int res1 = 0 ;
21204 bool val2 ;
21205 int ecode2 = 0 ;
21206 PyObject *swig_obj[2] ;
21207
21208 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21210 if (!SWIG_IsOK(res1)) {
21211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21212 }
21213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21214 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21215 if (!SWIG_IsOK(ecode2)) {
21216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21217 }
21218 arg2 = static_cast< bool >(val2);
21219 if (arg1) (arg1)->m_leftDown = arg2;
21220
21221 resultobj = SWIG_Py_Void();
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21229 PyObject *resultobj = 0;
21230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21231 bool result;
21232 void *argp1 = 0 ;
21233 int res1 = 0 ;
21234 PyObject *swig_obj[1] ;
21235
21236 if (!args) SWIG_fail;
21237 swig_obj[0] = args;
21238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21239 if (!SWIG_IsOK(res1)) {
21240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21241 }
21242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21243 result = (bool) ((arg1)->m_leftDown);
21244 {
21245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21246 }
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21254 PyObject *resultobj = 0;
21255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21256 bool arg2 ;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 bool val2 ;
21260 int ecode2 = 0 ;
21261 PyObject *swig_obj[2] ;
21262
21263 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21265 if (!SWIG_IsOK(res1)) {
21266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21267 }
21268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21269 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21270 if (!SWIG_IsOK(ecode2)) {
21271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21272 }
21273 arg2 = static_cast< bool >(val2);
21274 if (arg1) (arg1)->m_middleDown = arg2;
21275
21276 resultobj = SWIG_Py_Void();
21277 return resultobj;
21278 fail:
21279 return NULL;
21280 }
21281
21282
21283 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21284 PyObject *resultobj = 0;
21285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21286 bool result;
21287 void *argp1 = 0 ;
21288 int res1 = 0 ;
21289 PyObject *swig_obj[1] ;
21290
21291 if (!args) SWIG_fail;
21292 swig_obj[0] = args;
21293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21294 if (!SWIG_IsOK(res1)) {
21295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21296 }
21297 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21298 result = (bool) ((arg1)->m_middleDown);
21299 {
21300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21301 }
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21309 PyObject *resultobj = 0;
21310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21311 bool arg2 ;
21312 void *argp1 = 0 ;
21313 int res1 = 0 ;
21314 bool val2 ;
21315 int ecode2 = 0 ;
21316 PyObject *swig_obj[2] ;
21317
21318 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21320 if (!SWIG_IsOK(res1)) {
21321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21322 }
21323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21324 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21325 if (!SWIG_IsOK(ecode2)) {
21326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21327 }
21328 arg2 = static_cast< bool >(val2);
21329 if (arg1) (arg1)->m_rightDown = arg2;
21330
21331 resultobj = SWIG_Py_Void();
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21339 PyObject *resultobj = 0;
21340 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21341 bool result;
21342 void *argp1 = 0 ;
21343 int res1 = 0 ;
21344 PyObject *swig_obj[1] ;
21345
21346 if (!args) SWIG_fail;
21347 swig_obj[0] = args;
21348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21349 if (!SWIG_IsOK(res1)) {
21350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21351 }
21352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21353 result = (bool) ((arg1)->m_rightDown);
21354 {
21355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21356 }
21357 return resultobj;
21358 fail:
21359 return NULL;
21360 }
21361
21362
21363 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21364 PyObject *resultobj = 0;
21365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21366 bool arg2 ;
21367 void *argp1 = 0 ;
21368 int res1 = 0 ;
21369 bool val2 ;
21370 int ecode2 = 0 ;
21371 PyObject *swig_obj[2] ;
21372
21373 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21375 if (!SWIG_IsOK(res1)) {
21376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21377 }
21378 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21379 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21380 if (!SWIG_IsOK(ecode2)) {
21381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21382 }
21383 arg2 = static_cast< bool >(val2);
21384 if (arg1) (arg1)->m_controlDown = arg2;
21385
21386 resultobj = SWIG_Py_Void();
21387 return resultobj;
21388 fail:
21389 return NULL;
21390 }
21391
21392
21393 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21394 PyObject *resultobj = 0;
21395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21396 bool result;
21397 void *argp1 = 0 ;
21398 int res1 = 0 ;
21399 PyObject *swig_obj[1] ;
21400
21401 if (!args) SWIG_fail;
21402 swig_obj[0] = args;
21403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21404 if (!SWIG_IsOK(res1)) {
21405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21406 }
21407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21408 result = (bool) ((arg1)->m_controlDown);
21409 {
21410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21411 }
21412 return resultobj;
21413 fail:
21414 return NULL;
21415 }
21416
21417
21418 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21419 PyObject *resultobj = 0;
21420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21421 bool arg2 ;
21422 void *argp1 = 0 ;
21423 int res1 = 0 ;
21424 bool val2 ;
21425 int ecode2 = 0 ;
21426 PyObject *swig_obj[2] ;
21427
21428 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21430 if (!SWIG_IsOK(res1)) {
21431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21432 }
21433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21434 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21435 if (!SWIG_IsOK(ecode2)) {
21436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21437 }
21438 arg2 = static_cast< bool >(val2);
21439 if (arg1) (arg1)->m_shiftDown = arg2;
21440
21441 resultobj = SWIG_Py_Void();
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21449 PyObject *resultobj = 0;
21450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21451 bool result;
21452 void *argp1 = 0 ;
21453 int res1 = 0 ;
21454 PyObject *swig_obj[1] ;
21455
21456 if (!args) SWIG_fail;
21457 swig_obj[0] = args;
21458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21459 if (!SWIG_IsOK(res1)) {
21460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21461 }
21462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21463 result = (bool) ((arg1)->m_shiftDown);
21464 {
21465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21466 }
21467 return resultobj;
21468 fail:
21469 return NULL;
21470 }
21471
21472
21473 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21474 PyObject *resultobj = 0;
21475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21476 bool arg2 ;
21477 void *argp1 = 0 ;
21478 int res1 = 0 ;
21479 bool val2 ;
21480 int ecode2 = 0 ;
21481 PyObject *swig_obj[2] ;
21482
21483 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21485 if (!SWIG_IsOK(res1)) {
21486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21487 }
21488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21489 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21490 if (!SWIG_IsOK(ecode2)) {
21491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21492 }
21493 arg2 = static_cast< bool >(val2);
21494 if (arg1) (arg1)->m_altDown = arg2;
21495
21496 resultobj = SWIG_Py_Void();
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21504 PyObject *resultobj = 0;
21505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21506 bool result;
21507 void *argp1 = 0 ;
21508 int res1 = 0 ;
21509 PyObject *swig_obj[1] ;
21510
21511 if (!args) SWIG_fail;
21512 swig_obj[0] = args;
21513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21514 if (!SWIG_IsOK(res1)) {
21515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21516 }
21517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21518 result = (bool) ((arg1)->m_altDown);
21519 {
21520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21521 }
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21529 PyObject *resultobj = 0;
21530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21531 bool arg2 ;
21532 void *argp1 = 0 ;
21533 int res1 = 0 ;
21534 bool val2 ;
21535 int ecode2 = 0 ;
21536 PyObject *swig_obj[2] ;
21537
21538 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21540 if (!SWIG_IsOK(res1)) {
21541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21542 }
21543 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21544 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21545 if (!SWIG_IsOK(ecode2)) {
21546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21547 }
21548 arg2 = static_cast< bool >(val2);
21549 if (arg1) (arg1)->m_metaDown = arg2;
21550
21551 resultobj = SWIG_Py_Void();
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 bool result;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 PyObject *swig_obj[1] ;
21565
21566 if (!args) SWIG_fail;
21567 swig_obj[0] = args;
21568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21571 }
21572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21573 result = (bool) ((arg1)->m_metaDown);
21574 {
21575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21576 }
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21584 PyObject *resultobj = 0;
21585 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21586 int arg2 ;
21587 void *argp1 = 0 ;
21588 int res1 = 0 ;
21589 int val2 ;
21590 int ecode2 = 0 ;
21591 PyObject *swig_obj[2] ;
21592
21593 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21595 if (!SWIG_IsOK(res1)) {
21596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21597 }
21598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21599 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21600 if (!SWIG_IsOK(ecode2)) {
21601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21602 }
21603 arg2 = static_cast< int >(val2);
21604 if (arg1) (arg1)->m_wheelRotation = arg2;
21605
21606 resultobj = SWIG_Py_Void();
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21614 PyObject *resultobj = 0;
21615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21616 int result;
21617 void *argp1 = 0 ;
21618 int res1 = 0 ;
21619 PyObject *swig_obj[1] ;
21620
21621 if (!args) SWIG_fail;
21622 swig_obj[0] = args;
21623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21624 if (!SWIG_IsOK(res1)) {
21625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21626 }
21627 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21628 result = (int) ((arg1)->m_wheelRotation);
21629 resultobj = SWIG_From_int(static_cast< int >(result));
21630 return resultobj;
21631 fail:
21632 return NULL;
21633 }
21634
21635
21636 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21637 PyObject *resultobj = 0;
21638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21639 int arg2 ;
21640 void *argp1 = 0 ;
21641 int res1 = 0 ;
21642 int val2 ;
21643 int ecode2 = 0 ;
21644 PyObject *swig_obj[2] ;
21645
21646 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21648 if (!SWIG_IsOK(res1)) {
21649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21650 }
21651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21652 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21653 if (!SWIG_IsOK(ecode2)) {
21654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21655 }
21656 arg2 = static_cast< int >(val2);
21657 if (arg1) (arg1)->m_wheelDelta = arg2;
21658
21659 resultobj = SWIG_Py_Void();
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *resultobj = 0;
21668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21669 int result;
21670 void *argp1 = 0 ;
21671 int res1 = 0 ;
21672 PyObject *swig_obj[1] ;
21673
21674 if (!args) SWIG_fail;
21675 swig_obj[0] = args;
21676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21679 }
21680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21681 result = (int) ((arg1)->m_wheelDelta);
21682 resultobj = SWIG_From_int(static_cast< int >(result));
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21692 int arg2 ;
21693 void *argp1 = 0 ;
21694 int res1 = 0 ;
21695 int val2 ;
21696 int ecode2 = 0 ;
21697 PyObject *swig_obj[2] ;
21698
21699 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21701 if (!SWIG_IsOK(res1)) {
21702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21703 }
21704 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21705 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21706 if (!SWIG_IsOK(ecode2)) {
21707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21708 }
21709 arg2 = static_cast< int >(val2);
21710 if (arg1) (arg1)->m_linesPerAction = arg2;
21711
21712 resultobj = SWIG_Py_Void();
21713 return resultobj;
21714 fail:
21715 return NULL;
21716 }
21717
21718
21719 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21720 PyObject *resultobj = 0;
21721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21722 int result;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 PyObject *swig_obj[1] ;
21726
21727 if (!args) SWIG_fail;
21728 swig_obj[0] = args;
21729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21730 if (!SWIG_IsOK(res1)) {
21731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21732 }
21733 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21734 result = (int) ((arg1)->m_linesPerAction);
21735 resultobj = SWIG_From_int(static_cast< int >(result));
21736 return resultobj;
21737 fail:
21738 return NULL;
21739 }
21740
21741
21742 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21743 PyObject *obj;
21744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21745 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21746 return SWIG_Py_Void();
21747 }
21748
21749 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21750 return SWIG_Python_InitShadowInstance(args);
21751 }
21752
21753 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21754 PyObject *resultobj = 0;
21755 int arg1 = (int) 0 ;
21756 int arg2 = (int) 0 ;
21757 wxSetCursorEvent *result = 0 ;
21758 int val1 ;
21759 int ecode1 = 0 ;
21760 int val2 ;
21761 int ecode2 = 0 ;
21762 PyObject * obj0 = 0 ;
21763 PyObject * obj1 = 0 ;
21764 char * kwnames[] = {
21765 (char *) "x",(char *) "y", NULL
21766 };
21767
21768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21769 if (obj0) {
21770 ecode1 = SWIG_AsVal_int(obj0, &val1);
21771 if (!SWIG_IsOK(ecode1)) {
21772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21773 }
21774 arg1 = static_cast< int >(val1);
21775 }
21776 if (obj1) {
21777 ecode2 = SWIG_AsVal_int(obj1, &val2);
21778 if (!SWIG_IsOK(ecode2)) {
21779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21780 }
21781 arg2 = static_cast< int >(val2);
21782 }
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *resultobj = 0;
21798 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21799 int result;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 PyObject *swig_obj[1] ;
21803
21804 if (!args) SWIG_fail;
21805 swig_obj[0] = args;
21806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21807 if (!SWIG_IsOK(res1)) {
21808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21809 }
21810 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 resultobj = SWIG_From_int(static_cast< int >(result));
21818 return resultobj;
21819 fail:
21820 return NULL;
21821 }
21822
21823
21824 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21825 PyObject *resultobj = 0;
21826 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21827 int result;
21828 void *argp1 = 0 ;
21829 int res1 = 0 ;
21830 PyObject *swig_obj[1] ;
21831
21832 if (!args) SWIG_fail;
21833 swig_obj[0] = args;
21834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21835 if (!SWIG_IsOK(res1)) {
21836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21837 }
21838 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21839 {
21840 PyThreadState* __tstate = wxPyBeginAllowThreads();
21841 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21842 wxPyEndAllowThreads(__tstate);
21843 if (PyErr_Occurred()) SWIG_fail;
21844 }
21845 resultobj = SWIG_From_int(static_cast< int >(result));
21846 return resultobj;
21847 fail:
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj = 0;
21854 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21855 wxCursor *arg2 = 0 ;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 void *argp2 = 0 ;
21859 int res2 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "self",(char *) "cursor", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21868 if (!SWIG_IsOK(res1)) {
21869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21870 }
21871 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21873 if (!SWIG_IsOK(res2)) {
21874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21875 }
21876 if (!argp2) {
21877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21878 }
21879 arg2 = reinterpret_cast< wxCursor * >(argp2);
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 (arg1)->SetCursor((wxCursor const &)*arg2);
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 resultobj = SWIG_Py_Void();
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21894 PyObject *resultobj = 0;
21895 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21896 wxCursor *result = 0 ;
21897 void *argp1 = 0 ;
21898 int res1 = 0 ;
21899 PyObject *swig_obj[1] ;
21900
21901 if (!args) SWIG_fail;
21902 swig_obj[0] = args;
21903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21904 if (!SWIG_IsOK(res1)) {
21905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21906 }
21907 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21908 {
21909 PyThreadState* __tstate = wxPyBeginAllowThreads();
21910 {
21911 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21912 result = (wxCursor *) &_result_ref;
21913 }
21914 wxPyEndAllowThreads(__tstate);
21915 if (PyErr_Occurred()) SWIG_fail;
21916 }
21917 {
21918 wxCursor* resultptr = new wxCursor(*result);
21919 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 PyObject *resultobj = 0;
21929 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21930 bool result;
21931 void *argp1 = 0 ;
21932 int res1 = 0 ;
21933 PyObject *swig_obj[1] ;
21934
21935 if (!args) SWIG_fail;
21936 swig_obj[0] = args;
21937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21938 if (!SWIG_IsOK(res1)) {
21939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21940 }
21941 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 {
21949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21950 }
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21958 PyObject *obj;
21959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21960 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21961 return SWIG_Py_Void();
21962 }
21963
21964 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21965 return SWIG_Python_InitShadowInstance(args);
21966 }
21967
21968 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21969 PyObject *resultobj = 0;
21970 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21971 wxKeyEvent *result = 0 ;
21972 int val1 ;
21973 int ecode1 = 0 ;
21974 PyObject * obj0 = 0 ;
21975 char * kwnames[] = {
21976 (char *) "eventType", NULL
21977 };
21978
21979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21980 if (obj0) {
21981 ecode1 = SWIG_AsVal_int(obj0, &val1);
21982 if (!SWIG_IsOK(ecode1)) {
21983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21984 }
21985 arg1 = static_cast< wxEventType >(val1);
21986 }
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22003 int result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 PyObject *swig_obj[1] ;
22007
22008 if (!args) SWIG_fail;
22009 swig_obj[0] = args;
22010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22011 if (!SWIG_IsOK(res1)) {
22012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22013 }
22014 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22018 wxPyEndAllowThreads(__tstate);
22019 if (PyErr_Occurred()) SWIG_fail;
22020 }
22021 resultobj = SWIG_From_int(static_cast< int >(result));
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22029 PyObject *resultobj = 0;
22030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22031 bool result;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 PyObject *swig_obj[1] ;
22035
22036 if (!args) SWIG_fail;
22037 swig_obj[0] = args;
22038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22039 if (!SWIG_IsOK(res1)) {
22040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22041 }
22042 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 {
22050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22051 }
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059 PyObject *resultobj = 0;
22060 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22061 bool result;
22062 void *argp1 = 0 ;
22063 int res1 = 0 ;
22064 PyObject *swig_obj[1] ;
22065
22066 if (!args) SWIG_fail;
22067 swig_obj[0] = args;
22068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22071 }
22072 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 {
22080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22081 }
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22089 PyObject *resultobj = 0;
22090 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22091 bool result;
22092 void *argp1 = 0 ;
22093 int res1 = 0 ;
22094 PyObject *swig_obj[1] ;
22095
22096 if (!args) SWIG_fail;
22097 swig_obj[0] = args;
22098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22099 if (!SWIG_IsOK(res1)) {
22100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22101 }
22102 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22103 {
22104 PyThreadState* __tstate = wxPyBeginAllowThreads();
22105 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 {
22110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22111 }
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22119 PyObject *resultobj = 0;
22120 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22121 bool result;
22122 void *argp1 = 0 ;
22123 int res1 = 0 ;
22124 PyObject *swig_obj[1] ;
22125
22126 if (!args) SWIG_fail;
22127 swig_obj[0] = args;
22128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22129 if (!SWIG_IsOK(res1)) {
22130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22131 }
22132 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22133 {
22134 PyThreadState* __tstate = wxPyBeginAllowThreads();
22135 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22136 wxPyEndAllowThreads(__tstate);
22137 if (PyErr_Occurred()) SWIG_fail;
22138 }
22139 {
22140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22141 }
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22149 PyObject *resultobj = 0;
22150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22151 bool result;
22152 void *argp1 = 0 ;
22153 int res1 = 0 ;
22154 PyObject *swig_obj[1] ;
22155
22156 if (!args) SWIG_fail;
22157 swig_obj[0] = args;
22158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22161 }
22162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22163 {
22164 PyThreadState* __tstate = wxPyBeginAllowThreads();
22165 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 {
22170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22171 }
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22179 PyObject *resultobj = 0;
22180 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22181 bool result;
22182 void *argp1 = 0 ;
22183 int res1 = 0 ;
22184 PyObject *swig_obj[1] ;
22185
22186 if (!args) SWIG_fail;
22187 swig_obj[0] = args;
22188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22191 }
22192 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22196 wxPyEndAllowThreads(__tstate);
22197 if (PyErr_Occurred()) SWIG_fail;
22198 }
22199 {
22200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22201 }
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *resultobj = 0;
22210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22211 int result;
22212 void *argp1 = 0 ;
22213 int res1 = 0 ;
22214 PyObject *swig_obj[1] ;
22215
22216 if (!args) SWIG_fail;
22217 swig_obj[0] = args;
22218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22221 }
22222 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_From_int(static_cast< int >(result));
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22239 int result;
22240 void *argp1 = 0 ;
22241 int res1 = 0 ;
22242 PyObject *swig_obj[1] ;
22243
22244 if (!args) SWIG_fail;
22245 swig_obj[0] = args;
22246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22247 if (!SWIG_IsOK(res1)) {
22248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22249 }
22250 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22251 {
22252 PyThreadState* __tstate = wxPyBeginAllowThreads();
22253 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22254 wxPyEndAllowThreads(__tstate);
22255 if (PyErr_Occurred()) SWIG_fail;
22256 }
22257 resultobj = SWIG_From_int(static_cast< int >(result));
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22265 PyObject *resultobj = 0;
22266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22267 int arg2 ;
22268 void *argp1 = 0 ;
22269 int res1 = 0 ;
22270 int val2 ;
22271 int ecode2 = 0 ;
22272 PyObject * obj0 = 0 ;
22273 PyObject * obj1 = 0 ;
22274 char * kwnames[] = {
22275 (char *) "self",(char *) "uniChar", NULL
22276 };
22277
22278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22280 if (!SWIG_IsOK(res1)) {
22281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22282 }
22283 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22284 ecode2 = SWIG_AsVal_int(obj1, &val2);
22285 if (!SWIG_IsOK(ecode2)) {
22286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22287 }
22288 arg2 = static_cast< int >(val2);
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 resultobj = SWIG_Py_Void();
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22303 PyObject *resultobj = 0;
22304 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22305 unsigned int result;
22306 void *argp1 = 0 ;
22307 int res1 = 0 ;
22308 PyObject *swig_obj[1] ;
22309
22310 if (!args) SWIG_fail;
22311 swig_obj[0] = args;
22312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22313 if (!SWIG_IsOK(res1)) {
22314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22315 }
22316 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22317 {
22318 PyThreadState* __tstate = wxPyBeginAllowThreads();
22319 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22324 return resultobj;
22325 fail:
22326 return NULL;
22327 }
22328
22329
22330 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22331 PyObject *resultobj = 0;
22332 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22333 unsigned int result;
22334 void *argp1 = 0 ;
22335 int res1 = 0 ;
22336 PyObject *swig_obj[1] ;
22337
22338 if (!args) SWIG_fail;
22339 swig_obj[0] = args;
22340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22341 if (!SWIG_IsOK(res1)) {
22342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22343 }
22344 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22345 {
22346 PyThreadState* __tstate = wxPyBeginAllowThreads();
22347 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22352 return resultobj;
22353 fail:
22354 return NULL;
22355 }
22356
22357
22358 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22359 PyObject *resultobj = 0;
22360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22361 wxPoint result;
22362 void *argp1 = 0 ;
22363 int res1 = 0 ;
22364 PyObject *swig_obj[1] ;
22365
22366 if (!args) SWIG_fail;
22367 swig_obj[0] = args;
22368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22369 if (!SWIG_IsOK(res1)) {
22370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22371 }
22372 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22373 {
22374 PyThreadState* __tstate = wxPyBeginAllowThreads();
22375 result = (arg1)->GetPosition();
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22380 return resultobj;
22381 fail:
22382 return NULL;
22383 }
22384
22385
22386 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22387 PyObject *resultobj = 0;
22388 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22389 long *arg2 = (long *) 0 ;
22390 long *arg3 = (long *) 0 ;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 long temp2 ;
22394 int res2 = SWIG_TMPOBJ ;
22395 long temp3 ;
22396 int res3 = SWIG_TMPOBJ ;
22397 PyObject *swig_obj[1] ;
22398
22399 arg2 = &temp2;
22400 arg3 = &temp3;
22401 if (!args) SWIG_fail;
22402 swig_obj[0] = args;
22403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22406 }
22407 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 (arg1)->GetPosition(arg2,arg3);
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 resultobj = SWIG_Py_Void();
22415 if (SWIG_IsTmpObj(res2)) {
22416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22417 } else {
22418 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22420 }
22421 if (SWIG_IsTmpObj(res3)) {
22422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22423 } else {
22424 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22426 }
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22436 int result;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 PyObject *swig_obj[1] ;
22440
22441 if (!args) SWIG_fail;
22442 swig_obj[0] = args;
22443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22444 if (!SWIG_IsOK(res1)) {
22445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22446 }
22447 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = (int)((wxKeyEvent const *)arg1)->GetX();
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_From_int(static_cast< int >(result));
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22462 PyObject *resultobj = 0;
22463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22464 int result;
22465 void *argp1 = 0 ;
22466 int res1 = 0 ;
22467 PyObject *swig_obj[1] ;
22468
22469 if (!args) SWIG_fail;
22470 swig_obj[0] = args;
22471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22472 if (!SWIG_IsOK(res1)) {
22473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22474 }
22475 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (int)((wxKeyEvent const *)arg1)->GetY();
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 resultobj = SWIG_From_int(static_cast< int >(result));
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22490 PyObject *resultobj = 0;
22491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22492 int arg2 ;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 int val2 ;
22496 int ecode2 = 0 ;
22497 PyObject *swig_obj[2] ;
22498
22499 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22501 if (!SWIG_IsOK(res1)) {
22502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22503 }
22504 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22505 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22506 if (!SWIG_IsOK(ecode2)) {
22507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22508 }
22509 arg2 = static_cast< int >(val2);
22510 if (arg1) (arg1)->m_x = arg2;
22511
22512 resultobj = SWIG_Py_Void();
22513 return resultobj;
22514 fail:
22515 return NULL;
22516 }
22517
22518
22519 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22520 PyObject *resultobj = 0;
22521 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22522 int result;
22523 void *argp1 = 0 ;
22524 int res1 = 0 ;
22525 PyObject *swig_obj[1] ;
22526
22527 if (!args) SWIG_fail;
22528 swig_obj[0] = args;
22529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22530 if (!SWIG_IsOK(res1)) {
22531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22532 }
22533 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22534 result = (int) ((arg1)->m_x);
22535 resultobj = SWIG_From_int(static_cast< int >(result));
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22543 PyObject *resultobj = 0;
22544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22545 int arg2 ;
22546 void *argp1 = 0 ;
22547 int res1 = 0 ;
22548 int val2 ;
22549 int ecode2 = 0 ;
22550 PyObject *swig_obj[2] ;
22551
22552 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22554 if (!SWIG_IsOK(res1)) {
22555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22556 }
22557 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22558 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22559 if (!SWIG_IsOK(ecode2)) {
22560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22561 }
22562 arg2 = static_cast< int >(val2);
22563 if (arg1) (arg1)->m_y = arg2;
22564
22565 resultobj = SWIG_Py_Void();
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22573 PyObject *resultobj = 0;
22574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22575 int result;
22576 void *argp1 = 0 ;
22577 int res1 = 0 ;
22578 PyObject *swig_obj[1] ;
22579
22580 if (!args) SWIG_fail;
22581 swig_obj[0] = args;
22582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22583 if (!SWIG_IsOK(res1)) {
22584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22585 }
22586 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22587 result = (int) ((arg1)->m_y);
22588 resultobj = SWIG_From_int(static_cast< int >(result));
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22596 PyObject *resultobj = 0;
22597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22598 long arg2 ;
22599 void *argp1 = 0 ;
22600 int res1 = 0 ;
22601 long val2 ;
22602 int ecode2 = 0 ;
22603 PyObject *swig_obj[2] ;
22604
22605 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22607 if (!SWIG_IsOK(res1)) {
22608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22609 }
22610 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22611 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22612 if (!SWIG_IsOK(ecode2)) {
22613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22614 }
22615 arg2 = static_cast< long >(val2);
22616 if (arg1) (arg1)->m_keyCode = arg2;
22617
22618 resultobj = SWIG_Py_Void();
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22626 PyObject *resultobj = 0;
22627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22628 long result;
22629 void *argp1 = 0 ;
22630 int res1 = 0 ;
22631 PyObject *swig_obj[1] ;
22632
22633 if (!args) SWIG_fail;
22634 swig_obj[0] = args;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 result = (long) ((arg1)->m_keyCode);
22641 resultobj = SWIG_From_long(static_cast< long >(result));
22642 return resultobj;
22643 fail:
22644 return NULL;
22645 }
22646
22647
22648 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22649 PyObject *resultobj = 0;
22650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22651 bool arg2 ;
22652 void *argp1 = 0 ;
22653 int res1 = 0 ;
22654 bool val2 ;
22655 int ecode2 = 0 ;
22656 PyObject *swig_obj[2] ;
22657
22658 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22660 if (!SWIG_IsOK(res1)) {
22661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22662 }
22663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22664 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22665 if (!SWIG_IsOK(ecode2)) {
22666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22667 }
22668 arg2 = static_cast< bool >(val2);
22669 if (arg1) (arg1)->m_controlDown = arg2;
22670
22671 resultobj = SWIG_Py_Void();
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22679 PyObject *resultobj = 0;
22680 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22681 bool result;
22682 void *argp1 = 0 ;
22683 int res1 = 0 ;
22684 PyObject *swig_obj[1] ;
22685
22686 if (!args) SWIG_fail;
22687 swig_obj[0] = args;
22688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22689 if (!SWIG_IsOK(res1)) {
22690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22691 }
22692 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22693 result = (bool) ((arg1)->m_controlDown);
22694 {
22695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22696 }
22697 return resultobj;
22698 fail:
22699 return NULL;
22700 }
22701
22702
22703 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22704 PyObject *resultobj = 0;
22705 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22706 bool arg2 ;
22707 void *argp1 = 0 ;
22708 int res1 = 0 ;
22709 bool val2 ;
22710 int ecode2 = 0 ;
22711 PyObject *swig_obj[2] ;
22712
22713 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22715 if (!SWIG_IsOK(res1)) {
22716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22717 }
22718 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22719 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22720 if (!SWIG_IsOK(ecode2)) {
22721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22722 }
22723 arg2 = static_cast< bool >(val2);
22724 if (arg1) (arg1)->m_shiftDown = arg2;
22725
22726 resultobj = SWIG_Py_Void();
22727 return resultobj;
22728 fail:
22729 return NULL;
22730 }
22731
22732
22733 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734 PyObject *resultobj = 0;
22735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22736 bool result;
22737 void *argp1 = 0 ;
22738 int res1 = 0 ;
22739 PyObject *swig_obj[1] ;
22740
22741 if (!args) SWIG_fail;
22742 swig_obj[0] = args;
22743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22744 if (!SWIG_IsOK(res1)) {
22745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22746 }
22747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22748 result = (bool) ((arg1)->m_shiftDown);
22749 {
22750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22751 }
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22759 PyObject *resultobj = 0;
22760 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22761 bool arg2 ;
22762 void *argp1 = 0 ;
22763 int res1 = 0 ;
22764 bool val2 ;
22765 int ecode2 = 0 ;
22766 PyObject *swig_obj[2] ;
22767
22768 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22770 if (!SWIG_IsOK(res1)) {
22771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22772 }
22773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22774 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22775 if (!SWIG_IsOK(ecode2)) {
22776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22777 }
22778 arg2 = static_cast< bool >(val2);
22779 if (arg1) (arg1)->m_altDown = arg2;
22780
22781 resultobj = SWIG_Py_Void();
22782 return resultobj;
22783 fail:
22784 return NULL;
22785 }
22786
22787
22788 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22789 PyObject *resultobj = 0;
22790 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22791 bool result;
22792 void *argp1 = 0 ;
22793 int res1 = 0 ;
22794 PyObject *swig_obj[1] ;
22795
22796 if (!args) SWIG_fail;
22797 swig_obj[0] = args;
22798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22801 }
22802 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22803 result = (bool) ((arg1)->m_altDown);
22804 {
22805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22806 }
22807 return resultobj;
22808 fail:
22809 return NULL;
22810 }
22811
22812
22813 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22814 PyObject *resultobj = 0;
22815 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22816 bool arg2 ;
22817 void *argp1 = 0 ;
22818 int res1 = 0 ;
22819 bool val2 ;
22820 int ecode2 = 0 ;
22821 PyObject *swig_obj[2] ;
22822
22823 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22825 if (!SWIG_IsOK(res1)) {
22826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22827 }
22828 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22829 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22830 if (!SWIG_IsOK(ecode2)) {
22831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22832 }
22833 arg2 = static_cast< bool >(val2);
22834 if (arg1) (arg1)->m_metaDown = arg2;
22835
22836 resultobj = SWIG_Py_Void();
22837 return resultobj;
22838 fail:
22839 return NULL;
22840 }
22841
22842
22843 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22844 PyObject *resultobj = 0;
22845 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22846 bool result;
22847 void *argp1 = 0 ;
22848 int res1 = 0 ;
22849 PyObject *swig_obj[1] ;
22850
22851 if (!args) SWIG_fail;
22852 swig_obj[0] = args;
22853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22856 }
22857 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22858 result = (bool) ((arg1)->m_metaDown);
22859 {
22860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22861 }
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22869 PyObject *resultobj = 0;
22870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22871 bool arg2 ;
22872 void *argp1 = 0 ;
22873 int res1 = 0 ;
22874 bool val2 ;
22875 int ecode2 = 0 ;
22876 PyObject *swig_obj[2] ;
22877
22878 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22880 if (!SWIG_IsOK(res1)) {
22881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22882 }
22883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22884 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22885 if (!SWIG_IsOK(ecode2)) {
22886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22887 }
22888 arg2 = static_cast< bool >(val2);
22889 if (arg1) (arg1)->m_scanCode = arg2;
22890
22891 resultobj = SWIG_Py_Void();
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22899 PyObject *resultobj = 0;
22900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22901 bool result;
22902 void *argp1 = 0 ;
22903 int res1 = 0 ;
22904 PyObject *swig_obj[1] ;
22905
22906 if (!args) SWIG_fail;
22907 swig_obj[0] = args;
22908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22911 }
22912 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22913 result = (bool) ((arg1)->m_scanCode);
22914 {
22915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22916 }
22917 return resultobj;
22918 fail:
22919 return NULL;
22920 }
22921
22922
22923 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22924 PyObject *resultobj = 0;
22925 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22926 unsigned int arg2 ;
22927 void *argp1 = 0 ;
22928 int res1 = 0 ;
22929 unsigned int val2 ;
22930 int ecode2 = 0 ;
22931 PyObject *swig_obj[2] ;
22932
22933 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22935 if (!SWIG_IsOK(res1)) {
22936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22937 }
22938 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22939 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22940 if (!SWIG_IsOK(ecode2)) {
22941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22942 }
22943 arg2 = static_cast< unsigned int >(val2);
22944 if (arg1) (arg1)->m_rawCode = arg2;
22945
22946 resultobj = SWIG_Py_Void();
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22954 PyObject *resultobj = 0;
22955 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22956 unsigned int result;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 PyObject *swig_obj[1] ;
22960
22961 if (!args) SWIG_fail;
22962 swig_obj[0] = args;
22963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22964 if (!SWIG_IsOK(res1)) {
22965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22966 }
22967 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22968 result = (unsigned int) ((arg1)->m_rawCode);
22969 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22970 return resultobj;
22971 fail:
22972 return NULL;
22973 }
22974
22975
22976 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22977 PyObject *resultobj = 0;
22978 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22979 unsigned int arg2 ;
22980 void *argp1 = 0 ;
22981 int res1 = 0 ;
22982 unsigned int val2 ;
22983 int ecode2 = 0 ;
22984 PyObject *swig_obj[2] ;
22985
22986 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22988 if (!SWIG_IsOK(res1)) {
22989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22990 }
22991 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22992 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22993 if (!SWIG_IsOK(ecode2)) {
22994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22995 }
22996 arg2 = static_cast< unsigned int >(val2);
22997 if (arg1) (arg1)->m_rawFlags = arg2;
22998
22999 resultobj = SWIG_Py_Void();
23000 return resultobj;
23001 fail:
23002 return NULL;
23003 }
23004
23005
23006 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23007 PyObject *resultobj = 0;
23008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23009 unsigned int result;
23010 void *argp1 = 0 ;
23011 int res1 = 0 ;
23012 PyObject *swig_obj[1] ;
23013
23014 if (!args) SWIG_fail;
23015 swig_obj[0] = args;
23016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23017 if (!SWIG_IsOK(res1)) {
23018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23019 }
23020 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23021 result = (unsigned int) ((arg1)->m_rawFlags);
23022 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23030 PyObject *obj;
23031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23032 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23033 return SWIG_Py_Void();
23034 }
23035
23036 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23037 return SWIG_Python_InitShadowInstance(args);
23038 }
23039
23040 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23041 PyObject *resultobj = 0;
23042 wxSize const &arg1_defvalue = wxDefaultSize ;
23043 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23044 int arg2 = (int) 0 ;
23045 wxSizeEvent *result = 0 ;
23046 wxSize temp1 ;
23047 int val2 ;
23048 int ecode2 = 0 ;
23049 PyObject * obj0 = 0 ;
23050 PyObject * obj1 = 0 ;
23051 char * kwnames[] = {
23052 (char *) "sz",(char *) "winid", NULL
23053 };
23054
23055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23056 if (obj0) {
23057 {
23058 arg1 = &temp1;
23059 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23060 }
23061 }
23062 if (obj1) {
23063 ecode2 = SWIG_AsVal_int(obj1, &val2);
23064 if (!SWIG_IsOK(ecode2)) {
23065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23066 }
23067 arg2 = static_cast< int >(val2);
23068 }
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23083 PyObject *resultobj = 0;
23084 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23085 wxSize result;
23086 void *argp1 = 0 ;
23087 int res1 = 0 ;
23088 PyObject *swig_obj[1] ;
23089
23090 if (!args) SWIG_fail;
23091 swig_obj[0] = args;
23092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23093 if (!SWIG_IsOK(res1)) {
23094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23095 }
23096 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23097 {
23098 PyThreadState* __tstate = wxPyBeginAllowThreads();
23099 result = ((wxSizeEvent const *)arg1)->GetSize();
23100 wxPyEndAllowThreads(__tstate);
23101 if (PyErr_Occurred()) SWIG_fail;
23102 }
23103 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23111 PyObject *resultobj = 0;
23112 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23113 wxRect result;
23114 void *argp1 = 0 ;
23115 int res1 = 0 ;
23116 PyObject *swig_obj[1] ;
23117
23118 if (!args) SWIG_fail;
23119 swig_obj[0] = args;
23120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23121 if (!SWIG_IsOK(res1)) {
23122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23123 }
23124 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 result = ((wxSizeEvent const *)arg1)->GetRect();
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj = 0;
23140 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23141 wxRect arg2 ;
23142 void *argp1 = 0 ;
23143 int res1 = 0 ;
23144 void *argp2 ;
23145 int res2 = 0 ;
23146 PyObject * obj0 = 0 ;
23147 PyObject * obj1 = 0 ;
23148 char * kwnames[] = {
23149 (char *) "self",(char *) "rect", NULL
23150 };
23151
23152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23154 if (!SWIG_IsOK(res1)) {
23155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23156 }
23157 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23158 {
23159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23160 if (!SWIG_IsOK(res2)) {
23161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23162 }
23163 if (!argp2) {
23164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23165 } else {
23166 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23167 arg2 = *temp;
23168 if (SWIG_IsNewObj(res2)) delete temp;
23169 }
23170 }
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 (arg1)->SetRect(arg2);
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 resultobj = SWIG_Py_Void();
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23185 PyObject *resultobj = 0;
23186 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23187 wxSize arg2 ;
23188 void *argp1 = 0 ;
23189 int res1 = 0 ;
23190 void *argp2 ;
23191 int res2 = 0 ;
23192 PyObject * obj0 = 0 ;
23193 PyObject * obj1 = 0 ;
23194 char * kwnames[] = {
23195 (char *) "self",(char *) "size", NULL
23196 };
23197
23198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23200 if (!SWIG_IsOK(res1)) {
23201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23202 }
23203 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23204 {
23205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23206 if (!SWIG_IsOK(res2)) {
23207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23208 }
23209 if (!argp2) {
23210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23211 } else {
23212 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23213 arg2 = *temp;
23214 if (SWIG_IsNewObj(res2)) delete temp;
23215 }
23216 }
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 wxSizeEvent_SetSize(arg1,arg2);
23220 wxPyEndAllowThreads(__tstate);
23221 if (PyErr_Occurred()) SWIG_fail;
23222 }
23223 resultobj = SWIG_Py_Void();
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23231 PyObject *resultobj = 0;
23232 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23233 wxSize *arg2 = (wxSize *) 0 ;
23234 void *argp1 = 0 ;
23235 int res1 = 0 ;
23236 void *argp2 = 0 ;
23237 int res2 = 0 ;
23238 PyObject *swig_obj[2] ;
23239
23240 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23244 }
23245 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23246 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23247 if (!SWIG_IsOK(res2)) {
23248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23249 }
23250 arg2 = reinterpret_cast< wxSize * >(argp2);
23251 if (arg1) (arg1)->m_size = *arg2;
23252
23253 resultobj = SWIG_Py_Void();
23254 return resultobj;
23255 fail:
23256 return NULL;
23257 }
23258
23259
23260 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23261 PyObject *resultobj = 0;
23262 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23263 wxSize *result = 0 ;
23264 void *argp1 = 0 ;
23265 int res1 = 0 ;
23266 PyObject *swig_obj[1] ;
23267
23268 if (!args) SWIG_fail;
23269 swig_obj[0] = args;
23270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23271 if (!SWIG_IsOK(res1)) {
23272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23273 }
23274 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23275 result = (wxSize *)& ((arg1)->m_size);
23276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23284 PyObject *resultobj = 0;
23285 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23286 wxRect *arg2 = (wxRect *) 0 ;
23287 void *argp1 = 0 ;
23288 int res1 = 0 ;
23289 void *argp2 = 0 ;
23290 int res2 = 0 ;
23291 PyObject *swig_obj[2] ;
23292
23293 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23295 if (!SWIG_IsOK(res1)) {
23296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23297 }
23298 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23299 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23300 if (!SWIG_IsOK(res2)) {
23301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23302 }
23303 arg2 = reinterpret_cast< wxRect * >(argp2);
23304 if (arg1) (arg1)->m_rect = *arg2;
23305
23306 resultobj = SWIG_Py_Void();
23307 return resultobj;
23308 fail:
23309 return NULL;
23310 }
23311
23312
23313 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23314 PyObject *resultobj = 0;
23315 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23316 wxRect *result = 0 ;
23317 void *argp1 = 0 ;
23318 int res1 = 0 ;
23319 PyObject *swig_obj[1] ;
23320
23321 if (!args) SWIG_fail;
23322 swig_obj[0] = args;
23323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23324 if (!SWIG_IsOK(res1)) {
23325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23326 }
23327 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23328 result = (wxRect *)& ((arg1)->m_rect);
23329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23337 PyObject *obj;
23338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23339 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23340 return SWIG_Py_Void();
23341 }
23342
23343 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23344 return SWIG_Python_InitShadowInstance(args);
23345 }
23346
23347 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23348 PyObject *resultobj = 0;
23349 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23350 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23351 int arg2 = (int) 0 ;
23352 wxMoveEvent *result = 0 ;
23353 wxPoint temp1 ;
23354 int val2 ;
23355 int ecode2 = 0 ;
23356 PyObject * obj0 = 0 ;
23357 PyObject * obj1 = 0 ;
23358 char * kwnames[] = {
23359 (char *) "pos",(char *) "winid", NULL
23360 };
23361
23362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23363 if (obj0) {
23364 {
23365 arg1 = &temp1;
23366 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23367 }
23368 }
23369 if (obj1) {
23370 ecode2 = SWIG_AsVal_int(obj1, &val2);
23371 if (!SWIG_IsOK(ecode2)) {
23372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23373 }
23374 arg2 = static_cast< int >(val2);
23375 }
23376 {
23377 PyThreadState* __tstate = wxPyBeginAllowThreads();
23378 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23390 PyObject *resultobj = 0;
23391 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23392 wxPoint result;
23393 void *argp1 = 0 ;
23394 int res1 = 0 ;
23395 PyObject *swig_obj[1] ;
23396
23397 if (!args) SWIG_fail;
23398 swig_obj[0] = args;
23399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23400 if (!SWIG_IsOK(res1)) {
23401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23402 }
23403 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23404 {
23405 PyThreadState* __tstate = wxPyBeginAllowThreads();
23406 result = ((wxMoveEvent const *)arg1)->GetPosition();
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23418 PyObject *resultobj = 0;
23419 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23420 wxRect result;
23421 void *argp1 = 0 ;
23422 int res1 = 0 ;
23423 PyObject *swig_obj[1] ;
23424
23425 if (!args) SWIG_fail;
23426 swig_obj[0] = args;
23427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23428 if (!SWIG_IsOK(res1)) {
23429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23430 }
23431 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23432 {
23433 PyThreadState* __tstate = wxPyBeginAllowThreads();
23434 result = ((wxMoveEvent const *)arg1)->GetRect();
23435 wxPyEndAllowThreads(__tstate);
23436 if (PyErr_Occurred()) SWIG_fail;
23437 }
23438 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj = 0;
23447 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23448 wxRect *arg2 = 0 ;
23449 void *argp1 = 0 ;
23450 int res1 = 0 ;
23451 wxRect temp2 ;
23452 PyObject * obj0 = 0 ;
23453 PyObject * obj1 = 0 ;
23454 char * kwnames[] = {
23455 (char *) "self",(char *) "rect", NULL
23456 };
23457
23458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23460 if (!SWIG_IsOK(res1)) {
23461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23462 }
23463 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23464 {
23465 arg2 = &temp2;
23466 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23467 }
23468 {
23469 PyThreadState* __tstate = wxPyBeginAllowThreads();
23470 (arg1)->SetRect((wxRect const &)*arg2);
23471 wxPyEndAllowThreads(__tstate);
23472 if (PyErr_Occurred()) SWIG_fail;
23473 }
23474 resultobj = SWIG_Py_Void();
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23482 PyObject *resultobj = 0;
23483 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23484 wxPoint *arg2 = 0 ;
23485 void *argp1 = 0 ;
23486 int res1 = 0 ;
23487 wxPoint temp2 ;
23488 PyObject * obj0 = 0 ;
23489 PyObject * obj1 = 0 ;
23490 char * kwnames[] = {
23491 (char *) "self",(char *) "pos", NULL
23492 };
23493
23494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23496 if (!SWIG_IsOK(res1)) {
23497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23498 }
23499 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23500 {
23501 arg2 = &temp2;
23502 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23503 }
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 (arg1)->SetPosition((wxPoint const &)*arg2);
23507 wxPyEndAllowThreads(__tstate);
23508 if (PyErr_Occurred()) SWIG_fail;
23509 }
23510 resultobj = SWIG_Py_Void();
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23518 PyObject *obj;
23519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23520 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23521 return SWIG_Py_Void();
23522 }
23523
23524 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23525 return SWIG_Python_InitShadowInstance(args);
23526 }
23527
23528 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23529 PyObject *resultobj = 0;
23530 int arg1 = (int) 0 ;
23531 wxPaintEvent *result = 0 ;
23532 int val1 ;
23533 int ecode1 = 0 ;
23534 PyObject * obj0 = 0 ;
23535 char * kwnames[] = {
23536 (char *) "Id", NULL
23537 };
23538
23539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23540 if (obj0) {
23541 ecode1 = SWIG_AsVal_int(obj0, &val1);
23542 if (!SWIG_IsOK(ecode1)) {
23543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23544 }
23545 arg1 = static_cast< int >(val1);
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23561 PyObject *obj;
23562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23563 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23564 return SWIG_Py_Void();
23565 }
23566
23567 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23568 return SWIG_Python_InitShadowInstance(args);
23569 }
23570
23571 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23572 PyObject *resultobj = 0;
23573 int arg1 = (int) 0 ;
23574 wxNcPaintEvent *result = 0 ;
23575 int val1 ;
23576 int ecode1 = 0 ;
23577 PyObject * obj0 = 0 ;
23578 char * kwnames[] = {
23579 (char *) "winid", NULL
23580 };
23581
23582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23583 if (obj0) {
23584 ecode1 = SWIG_AsVal_int(obj0, &val1);
23585 if (!SWIG_IsOK(ecode1)) {
23586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23587 }
23588 arg1 = static_cast< int >(val1);
23589 }
23590 {
23591 PyThreadState* __tstate = wxPyBeginAllowThreads();
23592 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23604 PyObject *obj;
23605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23606 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23607 return SWIG_Py_Void();
23608 }
23609
23610 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23611 return SWIG_Python_InitShadowInstance(args);
23612 }
23613
23614 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23615 PyObject *resultobj = 0;
23616 int arg1 = (int) 0 ;
23617 wxDC *arg2 = (wxDC *) NULL ;
23618 wxEraseEvent *result = 0 ;
23619 int val1 ;
23620 int ecode1 = 0 ;
23621 void *argp2 = 0 ;
23622 int res2 = 0 ;
23623 PyObject * obj0 = 0 ;
23624 PyObject * obj1 = 0 ;
23625 char * kwnames[] = {
23626 (char *) "Id",(char *) "dc", NULL
23627 };
23628
23629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23630 if (obj0) {
23631 ecode1 = SWIG_AsVal_int(obj0, &val1);
23632 if (!SWIG_IsOK(ecode1)) {
23633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23634 }
23635 arg1 = static_cast< int >(val1);
23636 }
23637 if (obj1) {
23638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23639 if (!SWIG_IsOK(res2)) {
23640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23641 }
23642 arg2 = reinterpret_cast< wxDC * >(argp2);
23643 }
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23647 wxPyEndAllowThreads(__tstate);
23648 if (PyErr_Occurred()) SWIG_fail;
23649 }
23650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23651 return resultobj;
23652 fail:
23653 return NULL;
23654 }
23655
23656
23657 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23658 PyObject *resultobj = 0;
23659 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23660 wxDC *result = 0 ;
23661 void *argp1 = 0 ;
23662 int res1 = 0 ;
23663 PyObject *swig_obj[1] ;
23664
23665 if (!args) SWIG_fail;
23666 swig_obj[0] = args;
23667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23668 if (!SWIG_IsOK(res1)) {
23669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23670 }
23671 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 {
23679 resultobj = wxPyMake_wxObject(result, (bool)0);
23680 }
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23688 PyObject *obj;
23689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23690 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23691 return SWIG_Py_Void();
23692 }
23693
23694 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23695 return SWIG_Python_InitShadowInstance(args);
23696 }
23697
23698 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23699 PyObject *resultobj = 0;
23700 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23701 int arg2 = (int) 0 ;
23702 wxFocusEvent *result = 0 ;
23703 int val1 ;
23704 int ecode1 = 0 ;
23705 int val2 ;
23706 int ecode2 = 0 ;
23707 PyObject * obj0 = 0 ;
23708 PyObject * obj1 = 0 ;
23709 char * kwnames[] = {
23710 (char *) "type",(char *) "winid", NULL
23711 };
23712
23713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23714 if (obj0) {
23715 ecode1 = SWIG_AsVal_int(obj0, &val1);
23716 if (!SWIG_IsOK(ecode1)) {
23717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23718 }
23719 arg1 = static_cast< wxEventType >(val1);
23720 }
23721 if (obj1) {
23722 ecode2 = SWIG_AsVal_int(obj1, &val2);
23723 if (!SWIG_IsOK(ecode2)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23725 }
23726 arg2 = static_cast< int >(val2);
23727 }
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 PyObject *resultobj = 0;
23743 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23744 wxWindow *result = 0 ;
23745 void *argp1 = 0 ;
23746 int res1 = 0 ;
23747 PyObject *swig_obj[1] ;
23748
23749 if (!args) SWIG_fail;
23750 swig_obj[0] = args;
23751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23752 if (!SWIG_IsOK(res1)) {
23753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23754 }
23755 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23756 {
23757 PyThreadState* __tstate = wxPyBeginAllowThreads();
23758 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23759 wxPyEndAllowThreads(__tstate);
23760 if (PyErr_Occurred()) SWIG_fail;
23761 }
23762 {
23763 resultobj = wxPyMake_wxObject(result, (bool)0);
23764 }
23765 return resultobj;
23766 fail:
23767 return NULL;
23768 }
23769
23770
23771 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23772 PyObject *resultobj = 0;
23773 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23774 wxWindow *arg2 = (wxWindow *) 0 ;
23775 void *argp1 = 0 ;
23776 int res1 = 0 ;
23777 void *argp2 = 0 ;
23778 int res2 = 0 ;
23779 PyObject * obj0 = 0 ;
23780 PyObject * obj1 = 0 ;
23781 char * kwnames[] = {
23782 (char *) "self",(char *) "win", NULL
23783 };
23784
23785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23787 if (!SWIG_IsOK(res1)) {
23788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23789 }
23790 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23792 if (!SWIG_IsOK(res2)) {
23793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23794 }
23795 arg2 = reinterpret_cast< wxWindow * >(argp2);
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 (arg1)->SetWindow(arg2);
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 resultobj = SWIG_Py_Void();
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *obj;
23811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23812 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23813 return SWIG_Py_Void();
23814 }
23815
23816 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23817 return SWIG_Python_InitShadowInstance(args);
23818 }
23819
23820 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23821 PyObject *resultobj = 0;
23822 wxWindow *arg1 = (wxWindow *) NULL ;
23823 wxChildFocusEvent *result = 0 ;
23824 void *argp1 = 0 ;
23825 int res1 = 0 ;
23826 PyObject * obj0 = 0 ;
23827 char * kwnames[] = {
23828 (char *) "win", NULL
23829 };
23830
23831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23832 if (obj0) {
23833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23834 if (!SWIG_IsOK(res1)) {
23835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23836 }
23837 arg1 = reinterpret_cast< wxWindow * >(argp1);
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23855 wxWindow *result = 0 ;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 PyObject *swig_obj[1] ;
23859
23860 if (!args) SWIG_fail;
23861 swig_obj[0] = args;
23862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 {
23874 resultobj = wxPyMake_wxObject(result, (bool)0);
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *obj;
23884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23885 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23886 return SWIG_Py_Void();
23887 }
23888
23889 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23890 return SWIG_Python_InitShadowInstance(args);
23891 }
23892
23893 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj = 0;
23895 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23896 bool arg2 = (bool) true ;
23897 int arg3 = (int) 0 ;
23898 wxActivateEvent *result = 0 ;
23899 int val1 ;
23900 int ecode1 = 0 ;
23901 bool val2 ;
23902 int ecode2 = 0 ;
23903 int val3 ;
23904 int ecode3 = 0 ;
23905 PyObject * obj0 = 0 ;
23906 PyObject * obj1 = 0 ;
23907 PyObject * obj2 = 0 ;
23908 char * kwnames[] = {
23909 (char *) "type",(char *) "active",(char *) "Id", NULL
23910 };
23911
23912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23913 if (obj0) {
23914 ecode1 = SWIG_AsVal_int(obj0, &val1);
23915 if (!SWIG_IsOK(ecode1)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23917 }
23918 arg1 = static_cast< wxEventType >(val1);
23919 }
23920 if (obj1) {
23921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23922 if (!SWIG_IsOK(ecode2)) {
23923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23924 }
23925 arg2 = static_cast< bool >(val2);
23926 }
23927 if (obj2) {
23928 ecode3 = SWIG_AsVal_int(obj2, &val3);
23929 if (!SWIG_IsOK(ecode3)) {
23930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23931 }
23932 arg3 = static_cast< int >(val3);
23933 }
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 PyObject *resultobj = 0;
23949 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23950 bool result;
23951 void *argp1 = 0 ;
23952 int res1 = 0 ;
23953 PyObject *swig_obj[1] ;
23954
23955 if (!args) SWIG_fail;
23956 swig_obj[0] = args;
23957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23958 if (!SWIG_IsOK(res1)) {
23959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23960 }
23961 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23978 PyObject *obj;
23979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23980 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23981 return SWIG_Py_Void();
23982 }
23983
23984 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23985 return SWIG_Python_InitShadowInstance(args);
23986 }
23987
23988 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj = 0;
23990 int arg1 = (int) 0 ;
23991 wxInitDialogEvent *result = 0 ;
23992 int val1 ;
23993 int ecode1 = 0 ;
23994 PyObject * obj0 = 0 ;
23995 char * kwnames[] = {
23996 (char *) "Id", NULL
23997 };
23998
23999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24000 if (obj0) {
24001 ecode1 = SWIG_AsVal_int(obj0, &val1);
24002 if (!SWIG_IsOK(ecode1)) {
24003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24004 }
24005 arg1 = static_cast< int >(val1);
24006 }
24007 {
24008 PyThreadState* __tstate = wxPyBeginAllowThreads();
24009 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24021 PyObject *obj;
24022 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24023 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24024 return SWIG_Py_Void();
24025 }
24026
24027 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24028 return SWIG_Python_InitShadowInstance(args);
24029 }
24030
24031 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24032 PyObject *resultobj = 0;
24033 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24034 int arg2 = (int) 0 ;
24035 wxMenu *arg3 = (wxMenu *) NULL ;
24036 wxMenuEvent *result = 0 ;
24037 int val1 ;
24038 int ecode1 = 0 ;
24039 int val2 ;
24040 int ecode2 = 0 ;
24041 void *argp3 = 0 ;
24042 int res3 = 0 ;
24043 PyObject * obj0 = 0 ;
24044 PyObject * obj1 = 0 ;
24045 PyObject * obj2 = 0 ;
24046 char * kwnames[] = {
24047 (char *) "type",(char *) "winid",(char *) "menu", NULL
24048 };
24049
24050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24051 if (obj0) {
24052 ecode1 = SWIG_AsVal_int(obj0, &val1);
24053 if (!SWIG_IsOK(ecode1)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24055 }
24056 arg1 = static_cast< wxEventType >(val1);
24057 }
24058 if (obj1) {
24059 ecode2 = SWIG_AsVal_int(obj1, &val2);
24060 if (!SWIG_IsOK(ecode2)) {
24061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24062 }
24063 arg2 = static_cast< int >(val2);
24064 }
24065 if (obj2) {
24066 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24067 if (!SWIG_IsOK(res3)) {
24068 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24069 }
24070 arg3 = reinterpret_cast< wxMenu * >(argp3);
24071 }
24072 {
24073 PyThreadState* __tstate = wxPyBeginAllowThreads();
24074 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 PyObject *resultobj = 0;
24087 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24088 int result;
24089 void *argp1 = 0 ;
24090 int res1 = 0 ;
24091 PyObject *swig_obj[1] ;
24092
24093 if (!args) SWIG_fail;
24094 swig_obj[0] = args;
24095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24096 if (!SWIG_IsOK(res1)) {
24097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24098 }
24099 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 resultobj = SWIG_From_int(static_cast< int >(result));
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24114 PyObject *resultobj = 0;
24115 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24116 bool result;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 PyObject *swig_obj[1] ;
24120
24121 if (!args) SWIG_fail;
24122 swig_obj[0] = args;
24123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24126 }
24127 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 {
24135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24146 wxMenu *result = 0 ;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 PyObject *swig_obj[1] ;
24150
24151 if (!args) SWIG_fail;
24152 swig_obj[0] = args;
24153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24154 if (!SWIG_IsOK(res1)) {
24155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24156 }
24157 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 {
24165 resultobj = wxPyMake_wxObject(result, (bool)0);
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24174 PyObject *obj;
24175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24176 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24177 return SWIG_Py_Void();
24178 }
24179
24180 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24181 return SWIG_Python_InitShadowInstance(args);
24182 }
24183
24184 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj = 0;
24186 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24187 int arg2 = (int) 0 ;
24188 wxCloseEvent *result = 0 ;
24189 int val1 ;
24190 int ecode1 = 0 ;
24191 int val2 ;
24192 int ecode2 = 0 ;
24193 PyObject * obj0 = 0 ;
24194 PyObject * obj1 = 0 ;
24195 char * kwnames[] = {
24196 (char *) "type",(char *) "winid", NULL
24197 };
24198
24199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24200 if (obj0) {
24201 ecode1 = SWIG_AsVal_int(obj0, &val1);
24202 if (!SWIG_IsOK(ecode1)) {
24203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24204 }
24205 arg1 = static_cast< wxEventType >(val1);
24206 }
24207 if (obj1) {
24208 ecode2 = SWIG_AsVal_int(obj1, &val2);
24209 if (!SWIG_IsOK(ecode2)) {
24210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24211 }
24212 arg2 = static_cast< int >(val2);
24213 }
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24230 bool arg2 ;
24231 void *argp1 = 0 ;
24232 int res1 = 0 ;
24233 bool val2 ;
24234 int ecode2 = 0 ;
24235 PyObject * obj0 = 0 ;
24236 PyObject * obj1 = 0 ;
24237 char * kwnames[] = {
24238 (char *) "self",(char *) "logOff", NULL
24239 };
24240
24241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24243 if (!SWIG_IsOK(res1)) {
24244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24245 }
24246 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24248 if (!SWIG_IsOK(ecode2)) {
24249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24250 }
24251 arg2 = static_cast< bool >(val2);
24252 {
24253 PyThreadState* __tstate = wxPyBeginAllowThreads();
24254 (arg1)->SetLoggingOff(arg2);
24255 wxPyEndAllowThreads(__tstate);
24256 if (PyErr_Occurred()) SWIG_fail;
24257 }
24258 resultobj = SWIG_Py_Void();
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24266 PyObject *resultobj = 0;
24267 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24268 bool result;
24269 void *argp1 = 0 ;
24270 int res1 = 0 ;
24271 PyObject *swig_obj[1] ;
24272
24273 if (!args) SWIG_fail;
24274 swig_obj[0] = args;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24278 }
24279 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 {
24287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24288 }
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj = 0;
24297 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24298 bool arg2 = (bool) true ;
24299 void *argp1 = 0 ;
24300 int res1 = 0 ;
24301 bool val2 ;
24302 int ecode2 = 0 ;
24303 PyObject * obj0 = 0 ;
24304 PyObject * obj1 = 0 ;
24305 char * kwnames[] = {
24306 (char *) "self",(char *) "veto", NULL
24307 };
24308
24309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24311 if (!SWIG_IsOK(res1)) {
24312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24313 }
24314 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24315 if (obj1) {
24316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24317 if (!SWIG_IsOK(ecode2)) {
24318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24319 }
24320 arg2 = static_cast< bool >(val2);
24321 }
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 (arg1)->Veto(arg2);
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_Py_Void();
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *resultobj = 0;
24337 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24338 bool result;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 PyObject *swig_obj[1] ;
24342
24343 if (!args) SWIG_fail;
24344 swig_obj[0] = args;
24345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24346 if (!SWIG_IsOK(res1)) {
24347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24348 }
24349 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24350 {
24351 PyThreadState* __tstate = wxPyBeginAllowThreads();
24352 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 {
24357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24358 }
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24366 PyObject *resultobj = 0;
24367 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24368 bool arg2 ;
24369 void *argp1 = 0 ;
24370 int res1 = 0 ;
24371 bool val2 ;
24372 int ecode2 = 0 ;
24373 PyObject * obj0 = 0 ;
24374 PyObject * obj1 = 0 ;
24375 char * kwnames[] = {
24376 (char *) "self",(char *) "canVeto", NULL
24377 };
24378
24379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24381 if (!SWIG_IsOK(res1)) {
24382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24383 }
24384 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24385 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24386 if (!SWIG_IsOK(ecode2)) {
24387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24388 }
24389 arg2 = static_cast< bool >(val2);
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 (arg1)->SetCanVeto(arg2);
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 resultobj = SWIG_Py_Void();
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404 PyObject *resultobj = 0;
24405 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24406 bool result;
24407 void *argp1 = 0 ;
24408 int res1 = 0 ;
24409 PyObject *swig_obj[1] ;
24410
24411 if (!args) SWIG_fail;
24412 swig_obj[0] = args;
24413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24414 if (!SWIG_IsOK(res1)) {
24415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24416 }
24417 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24421 wxPyEndAllowThreads(__tstate);
24422 if (PyErr_Occurred()) SWIG_fail;
24423 }
24424 {
24425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24426 }
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24434 PyObject *obj;
24435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24436 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24437 return SWIG_Py_Void();
24438 }
24439
24440 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 return SWIG_Python_InitShadowInstance(args);
24442 }
24443
24444 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24445 PyObject *resultobj = 0;
24446 int arg1 = (int) 0 ;
24447 bool arg2 = (bool) false ;
24448 wxShowEvent *result = 0 ;
24449 int val1 ;
24450 int ecode1 = 0 ;
24451 bool val2 ;
24452 int ecode2 = 0 ;
24453 PyObject * obj0 = 0 ;
24454 PyObject * obj1 = 0 ;
24455 char * kwnames[] = {
24456 (char *) "winid",(char *) "show", NULL
24457 };
24458
24459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24460 if (obj0) {
24461 ecode1 = SWIG_AsVal_int(obj0, &val1);
24462 if (!SWIG_IsOK(ecode1)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24464 }
24465 arg1 = static_cast< int >(val1);
24466 }
24467 if (obj1) {
24468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24469 if (!SWIG_IsOK(ecode2)) {
24470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24471 }
24472 arg2 = static_cast< bool >(val2);
24473 }
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24488 PyObject *resultobj = 0;
24489 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24490 bool arg2 ;
24491 void *argp1 = 0 ;
24492 int res1 = 0 ;
24493 bool val2 ;
24494 int ecode2 = 0 ;
24495 PyObject * obj0 = 0 ;
24496 PyObject * obj1 = 0 ;
24497 char * kwnames[] = {
24498 (char *) "self",(char *) "show", NULL
24499 };
24500
24501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24503 if (!SWIG_IsOK(res1)) {
24504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24505 }
24506 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24507 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24508 if (!SWIG_IsOK(ecode2)) {
24509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24510 }
24511 arg2 = static_cast< bool >(val2);
24512 {
24513 PyThreadState* __tstate = wxPyBeginAllowThreads();
24514 (arg1)->SetShow(arg2);
24515 wxPyEndAllowThreads(__tstate);
24516 if (PyErr_Occurred()) SWIG_fail;
24517 }
24518 resultobj = SWIG_Py_Void();
24519 return resultobj;
24520 fail:
24521 return NULL;
24522 }
24523
24524
24525 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24526 PyObject *resultobj = 0;
24527 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24528 bool result;
24529 void *argp1 = 0 ;
24530 int res1 = 0 ;
24531 PyObject *swig_obj[1] ;
24532
24533 if (!args) SWIG_fail;
24534 swig_obj[0] = args;
24535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24536 if (!SWIG_IsOK(res1)) {
24537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24538 }
24539 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24540 {
24541 PyThreadState* __tstate = wxPyBeginAllowThreads();
24542 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24543 wxPyEndAllowThreads(__tstate);
24544 if (PyErr_Occurred()) SWIG_fail;
24545 }
24546 {
24547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24548 }
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24556 PyObject *obj;
24557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24558 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24559 return SWIG_Py_Void();
24560 }
24561
24562 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24563 return SWIG_Python_InitShadowInstance(args);
24564 }
24565
24566 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj = 0;
24568 int arg1 = (int) 0 ;
24569 bool arg2 = (bool) true ;
24570 wxIconizeEvent *result = 0 ;
24571 int val1 ;
24572 int ecode1 = 0 ;
24573 bool val2 ;
24574 int ecode2 = 0 ;
24575 PyObject * obj0 = 0 ;
24576 PyObject * obj1 = 0 ;
24577 char * kwnames[] = {
24578 (char *) "id",(char *) "iconized", NULL
24579 };
24580
24581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24582 if (obj0) {
24583 ecode1 = SWIG_AsVal_int(obj0, &val1);
24584 if (!SWIG_IsOK(ecode1)) {
24585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24586 }
24587 arg1 = static_cast< int >(val1);
24588 }
24589 if (obj1) {
24590 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24591 if (!SWIG_IsOK(ecode2)) {
24592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24593 }
24594 arg2 = static_cast< bool >(val2);
24595 }
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24599 wxPyEndAllowThreads(__tstate);
24600 if (PyErr_Occurred()) SWIG_fail;
24601 }
24602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24603 return resultobj;
24604 fail:
24605 return NULL;
24606 }
24607
24608
24609 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24610 PyObject *resultobj = 0;
24611 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24612 bool result;
24613 void *argp1 = 0 ;
24614 int res1 = 0 ;
24615 PyObject *swig_obj[1] ;
24616
24617 if (!args) SWIG_fail;
24618 swig_obj[0] = args;
24619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24620 if (!SWIG_IsOK(res1)) {
24621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24622 }
24623 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24624 {
24625 PyThreadState* __tstate = wxPyBeginAllowThreads();
24626 result = (bool)(arg1)->Iconized();
24627 wxPyEndAllowThreads(__tstate);
24628 if (PyErr_Occurred()) SWIG_fail;
24629 }
24630 {
24631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24632 }
24633 return resultobj;
24634 fail:
24635 return NULL;
24636 }
24637
24638
24639 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24640 PyObject *obj;
24641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24642 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24643 return SWIG_Py_Void();
24644 }
24645
24646 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24647 return SWIG_Python_InitShadowInstance(args);
24648 }
24649
24650 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24651 PyObject *resultobj = 0;
24652 int arg1 = (int) 0 ;
24653 wxMaximizeEvent *result = 0 ;
24654 int val1 ;
24655 int ecode1 = 0 ;
24656 PyObject * obj0 = 0 ;
24657 char * kwnames[] = {
24658 (char *) "id", NULL
24659 };
24660
24661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24662 if (obj0) {
24663 ecode1 = SWIG_AsVal_int(obj0, &val1);
24664 if (!SWIG_IsOK(ecode1)) {
24665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24666 }
24667 arg1 = static_cast< int >(val1);
24668 }
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24672 wxPyEndAllowThreads(__tstate);
24673 if (PyErr_Occurred()) SWIG_fail;
24674 }
24675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24676 return resultobj;
24677 fail:
24678 return NULL;
24679 }
24680
24681
24682 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24683 PyObject *obj;
24684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24685 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24686 return SWIG_Py_Void();
24687 }
24688
24689 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24690 return SWIG_Python_InitShadowInstance(args);
24691 }
24692
24693 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24694 PyObject *resultobj = 0;
24695 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24696 wxPoint result;
24697 void *argp1 = 0 ;
24698 int res1 = 0 ;
24699 PyObject *swig_obj[1] ;
24700
24701 if (!args) SWIG_fail;
24702 swig_obj[0] = args;
24703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24704 if (!SWIG_IsOK(res1)) {
24705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24706 }
24707 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 result = (arg1)->GetPosition();
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24722 PyObject *resultobj = 0;
24723 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24724 int result;
24725 void *argp1 = 0 ;
24726 int res1 = 0 ;
24727 PyObject *swig_obj[1] ;
24728
24729 if (!args) SWIG_fail;
24730 swig_obj[0] = args;
24731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24732 if (!SWIG_IsOK(res1)) {
24733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24734 }
24735 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (int)(arg1)->GetNumberOfFiles();
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 resultobj = SWIG_From_int(static_cast< int >(result));
24743 return resultobj;
24744 fail:
24745 return NULL;
24746 }
24747
24748
24749 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24750 PyObject *resultobj = 0;
24751 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24752 PyObject *result = 0 ;
24753 void *argp1 = 0 ;
24754 int res1 = 0 ;
24755 PyObject *swig_obj[1] ;
24756
24757 if (!args) SWIG_fail;
24758 swig_obj[0] = args;
24759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24760 if (!SWIG_IsOK(res1)) {
24761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24762 }
24763 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24764 {
24765 PyThreadState* __tstate = wxPyBeginAllowThreads();
24766 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 resultobj = result;
24771 return resultobj;
24772 fail:
24773 return NULL;
24774 }
24775
24776
24777 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24778 PyObject *obj;
24779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24780 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24781 return SWIG_Py_Void();
24782 }
24783
24784 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24785 PyObject *resultobj = 0;
24786 int arg1 = (int) 0 ;
24787 wxUpdateUIEvent *result = 0 ;
24788 int val1 ;
24789 int ecode1 = 0 ;
24790 PyObject * obj0 = 0 ;
24791 char * kwnames[] = {
24792 (char *) "commandId", NULL
24793 };
24794
24795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24796 if (obj0) {
24797 ecode1 = SWIG_AsVal_int(obj0, &val1);
24798 if (!SWIG_IsOK(ecode1)) {
24799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24800 }
24801 arg1 = static_cast< int >(val1);
24802 }
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24817 PyObject *resultobj = 0;
24818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24819 bool result;
24820 void *argp1 = 0 ;
24821 int res1 = 0 ;
24822 PyObject *swig_obj[1] ;
24823
24824 if (!args) SWIG_fail;
24825 swig_obj[0] = args;
24826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24829 }
24830 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24834 wxPyEndAllowThreads(__tstate);
24835 if (PyErr_Occurred()) SWIG_fail;
24836 }
24837 {
24838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24839 }
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847 PyObject *resultobj = 0;
24848 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24849 bool result;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 PyObject *swig_obj[1] ;
24853
24854 if (!args) SWIG_fail;
24855 swig_obj[0] = args;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24859 }
24860 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 {
24868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24869 }
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24877 PyObject *resultobj = 0;
24878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24879 bool result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 PyObject *swig_obj[1] ;
24883
24884 if (!args) SWIG_fail;
24885 swig_obj[0] = args;
24886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24889 }
24890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24907 PyObject *resultobj = 0;
24908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24909 wxString result;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 PyObject *swig_obj[1] ;
24913
24914 if (!args) SWIG_fail;
24915 swig_obj[0] = args;
24916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24917 if (!SWIG_IsOK(res1)) {
24918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24919 }
24920 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24924 wxPyEndAllowThreads(__tstate);
24925 if (PyErr_Occurred()) SWIG_fail;
24926 }
24927 {
24928 #if wxUSE_UNICODE
24929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24930 #else
24931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24932 #endif
24933 }
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24941 PyObject *resultobj = 0;
24942 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24943 bool result;
24944 void *argp1 = 0 ;
24945 int res1 = 0 ;
24946 PyObject *swig_obj[1] ;
24947
24948 if (!args) SWIG_fail;
24949 swig_obj[0] = args;
24950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24951 if (!SWIG_IsOK(res1)) {
24952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24953 }
24954 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24955 {
24956 PyThreadState* __tstate = wxPyBeginAllowThreads();
24957 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24958 wxPyEndAllowThreads(__tstate);
24959 if (PyErr_Occurred()) SWIG_fail;
24960 }
24961 {
24962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24963 }
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24971 PyObject *resultobj = 0;
24972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24973 bool result;
24974 void *argp1 = 0 ;
24975 int res1 = 0 ;
24976 PyObject *swig_obj[1] ;
24977
24978 if (!args) SWIG_fail;
24979 swig_obj[0] = args;
24980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24981 if (!SWIG_IsOK(res1)) {
24982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24983 }
24984 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24988 wxPyEndAllowThreads(__tstate);
24989 if (PyErr_Occurred()) SWIG_fail;
24990 }
24991 {
24992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24993 }
24994 return resultobj;
24995 fail:
24996 return NULL;
24997 }
24998
24999
25000 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25001 PyObject *resultobj = 0;
25002 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25003 bool result;
25004 void *argp1 = 0 ;
25005 int res1 = 0 ;
25006 PyObject *swig_obj[1] ;
25007
25008 if (!args) SWIG_fail;
25009 swig_obj[0] = args;
25010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25011 if (!SWIG_IsOK(res1)) {
25012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25013 }
25014 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 {
25022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25023 }
25024 return resultobj;
25025 fail:
25026 return NULL;
25027 }
25028
25029
25030 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25031 PyObject *resultobj = 0;
25032 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25033 bool result;
25034 void *argp1 = 0 ;
25035 int res1 = 0 ;
25036 PyObject *swig_obj[1] ;
25037
25038 if (!args) SWIG_fail;
25039 swig_obj[0] = args;
25040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25041 if (!SWIG_IsOK(res1)) {
25042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25043 }
25044 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25045 {
25046 PyThreadState* __tstate = wxPyBeginAllowThreads();
25047 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25048 wxPyEndAllowThreads(__tstate);
25049 if (PyErr_Occurred()) SWIG_fail;
25050 }
25051 {
25052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25053 }
25054 return resultobj;
25055 fail:
25056 return NULL;
25057 }
25058
25059
25060 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25061 PyObject *resultobj = 0;
25062 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25063 bool arg2 ;
25064 void *argp1 = 0 ;
25065 int res1 = 0 ;
25066 bool val2 ;
25067 int ecode2 = 0 ;
25068 PyObject * obj0 = 0 ;
25069 PyObject * obj1 = 0 ;
25070 char * kwnames[] = {
25071 (char *) "self",(char *) "check", NULL
25072 };
25073
25074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25076 if (!SWIG_IsOK(res1)) {
25077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25078 }
25079 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25081 if (!SWIG_IsOK(ecode2)) {
25082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25083 }
25084 arg2 = static_cast< bool >(val2);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 (arg1)->Check(arg2);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_Py_Void();
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25099 PyObject *resultobj = 0;
25100 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25101 bool arg2 ;
25102 void *argp1 = 0 ;
25103 int res1 = 0 ;
25104 bool val2 ;
25105 int ecode2 = 0 ;
25106 PyObject * obj0 = 0 ;
25107 PyObject * obj1 = 0 ;
25108 char * kwnames[] = {
25109 (char *) "self",(char *) "enable", NULL
25110 };
25111
25112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25114 if (!SWIG_IsOK(res1)) {
25115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25116 }
25117 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25118 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25119 if (!SWIG_IsOK(ecode2)) {
25120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25121 }
25122 arg2 = static_cast< bool >(val2);
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 (arg1)->Enable(arg2);
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 resultobj = SWIG_Py_Void();
25130 return resultobj;
25131 fail:
25132 return NULL;
25133 }
25134
25135
25136 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25137 PyObject *resultobj = 0;
25138 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25139 bool arg2 ;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 bool val2 ;
25143 int ecode2 = 0 ;
25144 PyObject * obj0 = 0 ;
25145 PyObject * obj1 = 0 ;
25146 char * kwnames[] = {
25147 (char *) "self",(char *) "show", NULL
25148 };
25149
25150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25152 if (!SWIG_IsOK(res1)) {
25153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25154 }
25155 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25157 if (!SWIG_IsOK(ecode2)) {
25158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25159 }
25160 arg2 = static_cast< bool >(val2);
25161 {
25162 PyThreadState* __tstate = wxPyBeginAllowThreads();
25163 (arg1)->Show(arg2);
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 resultobj = SWIG_Py_Void();
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj = 0;
25176 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25177 wxString *arg2 = 0 ;
25178 void *argp1 = 0 ;
25179 int res1 = 0 ;
25180 bool temp2 = false ;
25181 PyObject * obj0 = 0 ;
25182 PyObject * obj1 = 0 ;
25183 char * kwnames[] = {
25184 (char *) "self",(char *) "text", NULL
25185 };
25186
25187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25189 if (!SWIG_IsOK(res1)) {
25190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25191 }
25192 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25193 {
25194 arg2 = wxString_in_helper(obj1);
25195 if (arg2 == NULL) SWIG_fail;
25196 temp2 = true;
25197 }
25198 {
25199 PyThreadState* __tstate = wxPyBeginAllowThreads();
25200 (arg1)->SetText((wxString const &)*arg2);
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 resultobj = SWIG_Py_Void();
25205 {
25206 if (temp2)
25207 delete arg2;
25208 }
25209 return resultobj;
25210 fail:
25211 {
25212 if (temp2)
25213 delete arg2;
25214 }
25215 return NULL;
25216 }
25217
25218
25219 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25220 PyObject *resultobj = 0;
25221 long arg1 ;
25222 long val1 ;
25223 int ecode1 = 0 ;
25224 PyObject * obj0 = 0 ;
25225 char * kwnames[] = {
25226 (char *) "updateInterval", NULL
25227 };
25228
25229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25230 ecode1 = SWIG_AsVal_long(obj0, &val1);
25231 if (!SWIG_IsOK(ecode1)) {
25232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25233 }
25234 arg1 = static_cast< long >(val1);
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 wxUpdateUIEvent::SetUpdateInterval(arg1);
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 resultobj = SWIG_Py_Void();
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 PyObject *resultobj = 0;
25250 long result;
25251
25252 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 resultobj = SWIG_From_long(static_cast< long >(result));
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj = 0;
25268 wxWindow *arg1 = (wxWindow *) 0 ;
25269 bool result;
25270 void *argp1 = 0 ;
25271 int res1 = 0 ;
25272 PyObject * obj0 = 0 ;
25273 char * kwnames[] = {
25274 (char *) "win", NULL
25275 };
25276
25277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25279 if (!SWIG_IsOK(res1)) {
25280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25281 }
25282 arg1 = reinterpret_cast< wxWindow * >(argp1);
25283 {
25284 PyThreadState* __tstate = wxPyBeginAllowThreads();
25285 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25286 wxPyEndAllowThreads(__tstate);
25287 if (PyErr_Occurred()) SWIG_fail;
25288 }
25289 {
25290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25291 }
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25299 PyObject *resultobj = 0;
25300
25301 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 wxUpdateUIEvent::ResetUpdateTime();
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 resultobj = SWIG_Py_Void();
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj = 0;
25317 wxUpdateUIMode arg1 ;
25318 int val1 ;
25319 int ecode1 = 0 ;
25320 PyObject * obj0 = 0 ;
25321 char * kwnames[] = {
25322 (char *) "mode", NULL
25323 };
25324
25325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25326 ecode1 = SWIG_AsVal_int(obj0, &val1);
25327 if (!SWIG_IsOK(ecode1)) {
25328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25329 }
25330 arg1 = static_cast< wxUpdateUIMode >(val1);
25331 {
25332 PyThreadState* __tstate = wxPyBeginAllowThreads();
25333 wxUpdateUIEvent::SetMode(arg1);
25334 wxPyEndAllowThreads(__tstate);
25335 if (PyErr_Occurred()) SWIG_fail;
25336 }
25337 resultobj = SWIG_Py_Void();
25338 return resultobj;
25339 fail:
25340 return NULL;
25341 }
25342
25343
25344 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25345 PyObject *resultobj = 0;
25346 wxUpdateUIMode result;
25347
25348 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25352 wxPyEndAllowThreads(__tstate);
25353 if (PyErr_Occurred()) SWIG_fail;
25354 }
25355 resultobj = SWIG_From_int(static_cast< int >(result));
25356 return resultobj;
25357 fail:
25358 return NULL;
25359 }
25360
25361
25362 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25363 PyObject *obj;
25364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25365 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25366 return SWIG_Py_Void();
25367 }
25368
25369 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25370 return SWIG_Python_InitShadowInstance(args);
25371 }
25372
25373 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25374 PyObject *resultobj = 0;
25375 wxSysColourChangedEvent *result = 0 ;
25376
25377 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25385 return resultobj;
25386 fail:
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25392 PyObject *obj;
25393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25394 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25395 return SWIG_Py_Void();
25396 }
25397
25398 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25399 return SWIG_Python_InitShadowInstance(args);
25400 }
25401
25402 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25403 PyObject *resultobj = 0;
25404 int arg1 = (int) 0 ;
25405 wxWindow *arg2 = (wxWindow *) NULL ;
25406 wxMouseCaptureChangedEvent *result = 0 ;
25407 int val1 ;
25408 int ecode1 = 0 ;
25409 void *argp2 = 0 ;
25410 int res2 = 0 ;
25411 PyObject * obj0 = 0 ;
25412 PyObject * obj1 = 0 ;
25413 char * kwnames[] = {
25414 (char *) "winid",(char *) "gainedCapture", NULL
25415 };
25416
25417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25418 if (obj0) {
25419 ecode1 = SWIG_AsVal_int(obj0, &val1);
25420 if (!SWIG_IsOK(ecode1)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25422 }
25423 arg1 = static_cast< int >(val1);
25424 }
25425 if (obj1) {
25426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25427 if (!SWIG_IsOK(res2)) {
25428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25429 }
25430 arg2 = reinterpret_cast< wxWindow * >(argp2);
25431 }
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25439 return resultobj;
25440 fail:
25441 return NULL;
25442 }
25443
25444
25445 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25446 PyObject *resultobj = 0;
25447 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25448 wxWindow *result = 0 ;
25449 void *argp1 = 0 ;
25450 int res1 = 0 ;
25451 PyObject *swig_obj[1] ;
25452
25453 if (!args) SWIG_fail;
25454 swig_obj[0] = args;
25455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25456 if (!SWIG_IsOK(res1)) {
25457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25458 }
25459 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25463 wxPyEndAllowThreads(__tstate);
25464 if (PyErr_Occurred()) SWIG_fail;
25465 }
25466 {
25467 resultobj = wxPyMake_wxObject(result, (bool)0);
25468 }
25469 return resultobj;
25470 fail:
25471 return NULL;
25472 }
25473
25474
25475 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25476 PyObject *obj;
25477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25478 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25479 return SWIG_Py_Void();
25480 }
25481
25482 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 return SWIG_Python_InitShadowInstance(args);
25484 }
25485
25486 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25487 PyObject *resultobj = 0;
25488 int arg1 = (int) 0 ;
25489 wxMouseCaptureLostEvent *result = 0 ;
25490 int val1 ;
25491 int ecode1 = 0 ;
25492 PyObject * obj0 = 0 ;
25493 char * kwnames[] = {
25494 (char *) "winid", NULL
25495 };
25496
25497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25498 if (obj0) {
25499 ecode1 = SWIG_AsVal_int(obj0, &val1);
25500 if (!SWIG_IsOK(ecode1)) {
25501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25502 }
25503 arg1 = static_cast< int >(val1);
25504 }
25505 {
25506 PyThreadState* __tstate = wxPyBeginAllowThreads();
25507 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25512 return resultobj;
25513 fail:
25514 return NULL;
25515 }
25516
25517
25518 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519 PyObject *obj;
25520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25521 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25522 return SWIG_Py_Void();
25523 }
25524
25525 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 return SWIG_Python_InitShadowInstance(args);
25527 }
25528
25529 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25530 PyObject *resultobj = 0;
25531 wxDisplayChangedEvent *result = 0 ;
25532
25533 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25534 {
25535 PyThreadState* __tstate = wxPyBeginAllowThreads();
25536 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25537 wxPyEndAllowThreads(__tstate);
25538 if (PyErr_Occurred()) SWIG_fail;
25539 }
25540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25548 PyObject *obj;
25549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25550 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25551 return SWIG_Py_Void();
25552 }
25553
25554 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 return SWIG_Python_InitShadowInstance(args);
25556 }
25557
25558 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj = 0;
25560 int arg1 = (int) 0 ;
25561 wxPaletteChangedEvent *result = 0 ;
25562 int val1 ;
25563 int ecode1 = 0 ;
25564 PyObject * obj0 = 0 ;
25565 char * kwnames[] = {
25566 (char *) "id", NULL
25567 };
25568
25569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25570 if (obj0) {
25571 ecode1 = SWIG_AsVal_int(obj0, &val1);
25572 if (!SWIG_IsOK(ecode1)) {
25573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25574 }
25575 arg1 = static_cast< int >(val1);
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj = 0;
25592 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25593 wxWindow *arg2 = (wxWindow *) 0 ;
25594 void *argp1 = 0 ;
25595 int res1 = 0 ;
25596 void *argp2 = 0 ;
25597 int res2 = 0 ;
25598 PyObject * obj0 = 0 ;
25599 PyObject * obj1 = 0 ;
25600 char * kwnames[] = {
25601 (char *) "self",(char *) "win", NULL
25602 };
25603
25604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25608 }
25609 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25611 if (!SWIG_IsOK(res2)) {
25612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25613 }
25614 arg2 = reinterpret_cast< wxWindow * >(argp2);
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 (arg1)->SetChangedWindow(arg2);
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 resultobj = SWIG_Py_Void();
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 PyObject *resultobj = 0;
25630 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25631 wxWindow *result = 0 ;
25632 void *argp1 = 0 ;
25633 int res1 = 0 ;
25634 PyObject *swig_obj[1] ;
25635
25636 if (!args) SWIG_fail;
25637 swig_obj[0] = args;
25638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25639 if (!SWIG_IsOK(res1)) {
25640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25641 }
25642 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (wxWindow *)(arg1)->GetChangedWindow();
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 {
25650 resultobj = wxPyMake_wxObject(result, (bool)0);
25651 }
25652 return resultobj;
25653 fail:
25654 return NULL;
25655 }
25656
25657
25658 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25659 PyObject *obj;
25660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25661 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25662 return SWIG_Py_Void();
25663 }
25664
25665 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666 return SWIG_Python_InitShadowInstance(args);
25667 }
25668
25669 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj = 0;
25671 int arg1 = (int) 0 ;
25672 wxQueryNewPaletteEvent *result = 0 ;
25673 int val1 ;
25674 int ecode1 = 0 ;
25675 PyObject * obj0 = 0 ;
25676 char * kwnames[] = {
25677 (char *) "winid", NULL
25678 };
25679
25680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25681 if (obj0) {
25682 ecode1 = SWIG_AsVal_int(obj0, &val1);
25683 if (!SWIG_IsOK(ecode1)) {
25684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25685 }
25686 arg1 = static_cast< int >(val1);
25687 }
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25704 bool arg2 ;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 bool val2 ;
25708 int ecode2 = 0 ;
25709 PyObject * obj0 = 0 ;
25710 PyObject * obj1 = 0 ;
25711 char * kwnames[] = {
25712 (char *) "self",(char *) "realized", NULL
25713 };
25714
25715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25719 }
25720 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25722 if (!SWIG_IsOK(ecode2)) {
25723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25724 }
25725 arg2 = static_cast< bool >(val2);
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 (arg1)->SetPaletteRealized(arg2);
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 resultobj = SWIG_Py_Void();
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25740 PyObject *resultobj = 0;
25741 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25742 bool result;
25743 void *argp1 = 0 ;
25744 int res1 = 0 ;
25745 PyObject *swig_obj[1] ;
25746
25747 if (!args) SWIG_fail;
25748 swig_obj[0] = args;
25749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25750 if (!SWIG_IsOK(res1)) {
25751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25752 }
25753 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25757 wxPyEndAllowThreads(__tstate);
25758 if (PyErr_Occurred()) SWIG_fail;
25759 }
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25770 PyObject *obj;
25771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25772 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25773 return SWIG_Py_Void();
25774 }
25775
25776 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25777 return SWIG_Python_InitShadowInstance(args);
25778 }
25779
25780 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25781 PyObject *resultobj = 0;
25782 wxNavigationKeyEvent *result = 0 ;
25783
25784 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25788 wxPyEndAllowThreads(__tstate);
25789 if (PyErr_Occurred()) SWIG_fail;
25790 }
25791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25792 return resultobj;
25793 fail:
25794 return NULL;
25795 }
25796
25797
25798 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25799 PyObject *resultobj = 0;
25800 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25801 bool result;
25802 void *argp1 = 0 ;
25803 int res1 = 0 ;
25804 PyObject *swig_obj[1] ;
25805
25806 if (!args) SWIG_fail;
25807 swig_obj[0] = args;
25808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25809 if (!SWIG_IsOK(res1)) {
25810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25811 }
25812 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 {
25820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25821 }
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj = 0;
25830 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25831 bool arg2 ;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 bool val2 ;
25835 int ecode2 = 0 ;
25836 PyObject * obj0 = 0 ;
25837 PyObject * obj1 = 0 ;
25838 char * kwnames[] = {
25839 (char *) "self",(char *) "forward", NULL
25840 };
25841
25842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25846 }
25847 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25849 if (!SWIG_IsOK(ecode2)) {
25850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25851 }
25852 arg2 = static_cast< bool >(val2);
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 (arg1)->SetDirection(arg2);
25856 wxPyEndAllowThreads(__tstate);
25857 if (PyErr_Occurred()) SWIG_fail;
25858 }
25859 resultobj = SWIG_Py_Void();
25860 return resultobj;
25861 fail:
25862 return NULL;
25863 }
25864
25865
25866 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25867 PyObject *resultobj = 0;
25868 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25869 bool result;
25870 void *argp1 = 0 ;
25871 int res1 = 0 ;
25872 PyObject *swig_obj[1] ;
25873
25874 if (!args) SWIG_fail;
25875 swig_obj[0] = args;
25876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25877 if (!SWIG_IsOK(res1)) {
25878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25879 }
25880 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25884 wxPyEndAllowThreads(__tstate);
25885 if (PyErr_Occurred()) SWIG_fail;
25886 }
25887 {
25888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25889 }
25890 return resultobj;
25891 fail:
25892 return NULL;
25893 }
25894
25895
25896 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25897 PyObject *resultobj = 0;
25898 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25899 bool arg2 ;
25900 void *argp1 = 0 ;
25901 int res1 = 0 ;
25902 bool val2 ;
25903 int ecode2 = 0 ;
25904 PyObject * obj0 = 0 ;
25905 PyObject * obj1 = 0 ;
25906 char * kwnames[] = {
25907 (char *) "self",(char *) "ischange", NULL
25908 };
25909
25910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25912 if (!SWIG_IsOK(res1)) {
25913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25914 }
25915 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25917 if (!SWIG_IsOK(ecode2)) {
25918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25919 }
25920 arg2 = static_cast< bool >(val2);
25921 {
25922 PyThreadState* __tstate = wxPyBeginAllowThreads();
25923 (arg1)->SetWindowChange(arg2);
25924 wxPyEndAllowThreads(__tstate);
25925 if (PyErr_Occurred()) SWIG_fail;
25926 }
25927 resultobj = SWIG_Py_Void();
25928 return resultobj;
25929 fail:
25930 return NULL;
25931 }
25932
25933
25934 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25935 PyObject *resultobj = 0;
25936 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25937 bool result;
25938 void *argp1 = 0 ;
25939 int res1 = 0 ;
25940 PyObject *swig_obj[1] ;
25941
25942 if (!args) SWIG_fail;
25943 swig_obj[0] = args;
25944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25945 if (!SWIG_IsOK(res1)) {
25946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25947 }
25948 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25949 {
25950 PyThreadState* __tstate = wxPyBeginAllowThreads();
25951 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25952 wxPyEndAllowThreads(__tstate);
25953 if (PyErr_Occurred()) SWIG_fail;
25954 }
25955 {
25956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25957 }
25958 return resultobj;
25959 fail:
25960 return NULL;
25961 }
25962
25963
25964 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25965 PyObject *resultobj = 0;
25966 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25967 bool arg2 ;
25968 void *argp1 = 0 ;
25969 int res1 = 0 ;
25970 bool val2 ;
25971 int ecode2 = 0 ;
25972 PyObject * obj0 = 0 ;
25973 PyObject * obj1 = 0 ;
25974 char * kwnames[] = {
25975 (char *) "self",(char *) "bIs", NULL
25976 };
25977
25978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25980 if (!SWIG_IsOK(res1)) {
25981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25982 }
25983 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25985 if (!SWIG_IsOK(ecode2)) {
25986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25987 }
25988 arg2 = static_cast< bool >(val2);
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 (arg1)->SetFromTab(arg2);
25992 wxPyEndAllowThreads(__tstate);
25993 if (PyErr_Occurred()) SWIG_fail;
25994 }
25995 resultobj = SWIG_Py_Void();
25996 return resultobj;
25997 fail:
25998 return NULL;
25999 }
26000
26001
26002 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26005 long arg2 ;
26006 void *argp1 = 0 ;
26007 int res1 = 0 ;
26008 long val2 ;
26009 int ecode2 = 0 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 char * kwnames[] = {
26013 (char *) "self",(char *) "flags", NULL
26014 };
26015
26016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26018 if (!SWIG_IsOK(res1)) {
26019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26020 }
26021 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26022 ecode2 = SWIG_AsVal_long(obj1, &val2);
26023 if (!SWIG_IsOK(ecode2)) {
26024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26025 }
26026 arg2 = static_cast< long >(val2);
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 (arg1)->SetFlags(arg2);
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 resultobj = SWIG_Py_Void();
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26041 PyObject *resultobj = 0;
26042 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26043 wxWindow *result = 0 ;
26044 void *argp1 = 0 ;
26045 int res1 = 0 ;
26046 PyObject *swig_obj[1] ;
26047
26048 if (!args) SWIG_fail;
26049 swig_obj[0] = args;
26050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26051 if (!SWIG_IsOK(res1)) {
26052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26053 }
26054 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26055 {
26056 PyThreadState* __tstate = wxPyBeginAllowThreads();
26057 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26058 wxPyEndAllowThreads(__tstate);
26059 if (PyErr_Occurred()) SWIG_fail;
26060 }
26061 {
26062 resultobj = wxPyMake_wxObject(result, (bool)0);
26063 }
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26071 PyObject *resultobj = 0;
26072 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26073 wxWindow *arg2 = (wxWindow *) 0 ;
26074 void *argp1 = 0 ;
26075 int res1 = 0 ;
26076 void *argp2 = 0 ;
26077 int res2 = 0 ;
26078 PyObject * obj0 = 0 ;
26079 PyObject * obj1 = 0 ;
26080 char * kwnames[] = {
26081 (char *) "self",(char *) "win", NULL
26082 };
26083
26084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26086 if (!SWIG_IsOK(res1)) {
26087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26088 }
26089 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26091 if (!SWIG_IsOK(res2)) {
26092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26093 }
26094 arg2 = reinterpret_cast< wxWindow * >(argp2);
26095 {
26096 PyThreadState* __tstate = wxPyBeginAllowThreads();
26097 (arg1)->SetCurrentFocus(arg2);
26098 wxPyEndAllowThreads(__tstate);
26099 if (PyErr_Occurred()) SWIG_fail;
26100 }
26101 resultobj = SWIG_Py_Void();
26102 return resultobj;
26103 fail:
26104 return NULL;
26105 }
26106
26107
26108 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26109 PyObject *obj;
26110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26111 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26112 return SWIG_Py_Void();
26113 }
26114
26115 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26116 return SWIG_Python_InitShadowInstance(args);
26117 }
26118
26119 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26120 PyObject *resultobj = 0;
26121 wxWindow *arg1 = (wxWindow *) NULL ;
26122 wxWindowCreateEvent *result = 0 ;
26123 void *argp1 = 0 ;
26124 int res1 = 0 ;
26125 PyObject * obj0 = 0 ;
26126 char * kwnames[] = {
26127 (char *) "win", NULL
26128 };
26129
26130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26131 if (obj0) {
26132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26135 }
26136 arg1 = reinterpret_cast< wxWindow * >(argp1);
26137 }
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26145 return resultobj;
26146 fail:
26147 return NULL;
26148 }
26149
26150
26151 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26152 PyObject *resultobj = 0;
26153 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26154 wxWindow *result = 0 ;
26155 void *argp1 = 0 ;
26156 int res1 = 0 ;
26157 PyObject *swig_obj[1] ;
26158
26159 if (!args) SWIG_fail;
26160 swig_obj[0] = args;
26161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26162 if (!SWIG_IsOK(res1)) {
26163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26164 }
26165 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26169 wxPyEndAllowThreads(__tstate);
26170 if (PyErr_Occurred()) SWIG_fail;
26171 }
26172 {
26173 resultobj = wxPyMake_wxObject(result, (bool)0);
26174 }
26175 return resultobj;
26176 fail:
26177 return NULL;
26178 }
26179
26180
26181 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26182 PyObject *obj;
26183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26184 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26185 return SWIG_Py_Void();
26186 }
26187
26188 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26189 return SWIG_Python_InitShadowInstance(args);
26190 }
26191
26192 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26193 PyObject *resultobj = 0;
26194 wxWindow *arg1 = (wxWindow *) NULL ;
26195 wxWindowDestroyEvent *result = 0 ;
26196 void *argp1 = 0 ;
26197 int res1 = 0 ;
26198 PyObject * obj0 = 0 ;
26199 char * kwnames[] = {
26200 (char *) "win", NULL
26201 };
26202
26203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26204 if (obj0) {
26205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26206 if (!SWIG_IsOK(res1)) {
26207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26208 }
26209 arg1 = reinterpret_cast< wxWindow * >(argp1);
26210 }
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26214 wxPyEndAllowThreads(__tstate);
26215 if (PyErr_Occurred()) SWIG_fail;
26216 }
26217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26225 PyObject *resultobj = 0;
26226 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26227 wxWindow *result = 0 ;
26228 void *argp1 = 0 ;
26229 int res1 = 0 ;
26230 PyObject *swig_obj[1] ;
26231
26232 if (!args) SWIG_fail;
26233 swig_obj[0] = args;
26234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26237 }
26238 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 {
26246 resultobj = wxPyMake_wxObject(result, (bool)0);
26247 }
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26255 PyObject *obj;
26256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26257 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26258 return SWIG_Py_Void();
26259 }
26260
26261 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26262 return SWIG_Python_InitShadowInstance(args);
26263 }
26264
26265 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26266 PyObject *resultobj = 0;
26267 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26268 int arg2 = (int) 0 ;
26269 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26270 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26271 wxContextMenuEvent *result = 0 ;
26272 int val1 ;
26273 int ecode1 = 0 ;
26274 int val2 ;
26275 int ecode2 = 0 ;
26276 wxPoint temp3 ;
26277 PyObject * obj0 = 0 ;
26278 PyObject * obj1 = 0 ;
26279 PyObject * obj2 = 0 ;
26280 char * kwnames[] = {
26281 (char *) "type",(char *) "winid",(char *) "pt", NULL
26282 };
26283
26284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26285 if (obj0) {
26286 ecode1 = SWIG_AsVal_int(obj0, &val1);
26287 if (!SWIG_IsOK(ecode1)) {
26288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26289 }
26290 arg1 = static_cast< wxEventType >(val1);
26291 }
26292 if (obj1) {
26293 ecode2 = SWIG_AsVal_int(obj1, &val2);
26294 if (!SWIG_IsOK(ecode2)) {
26295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26296 }
26297 arg2 = static_cast< int >(val2);
26298 }
26299 if (obj2) {
26300 {
26301 arg3 = &temp3;
26302 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26303 }
26304 }
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26319 PyObject *resultobj = 0;
26320 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26321 wxPoint *result = 0 ;
26322 void *argp1 = 0 ;
26323 int res1 = 0 ;
26324 PyObject *swig_obj[1] ;
26325
26326 if (!args) SWIG_fail;
26327 swig_obj[0] = args;
26328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26331 }
26332 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26333 {
26334 PyThreadState* __tstate = wxPyBeginAllowThreads();
26335 {
26336 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26337 result = (wxPoint *) &_result_ref;
26338 }
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26350 PyObject *resultobj = 0;
26351 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26352 wxPoint *arg2 = 0 ;
26353 void *argp1 = 0 ;
26354 int res1 = 0 ;
26355 wxPoint temp2 ;
26356 PyObject * obj0 = 0 ;
26357 PyObject * obj1 = 0 ;
26358 char * kwnames[] = {
26359 (char *) "self",(char *) "pos", NULL
26360 };
26361
26362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26364 if (!SWIG_IsOK(res1)) {
26365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26366 }
26367 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26368 {
26369 arg2 = &temp2;
26370 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26371 }
26372 {
26373 PyThreadState* __tstate = wxPyBeginAllowThreads();
26374 (arg1)->SetPosition((wxPoint const &)*arg2);
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 resultobj = SWIG_Py_Void();
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26386 PyObject *obj;
26387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26388 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26389 return SWIG_Py_Void();
26390 }
26391
26392 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26393 return SWIG_Python_InitShadowInstance(args);
26394 }
26395
26396 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26397 PyObject *resultobj = 0;
26398 wxIdleEvent *result = 0 ;
26399
26400 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 result = (wxIdleEvent *)new wxIdleEvent();
26404 wxPyEndAllowThreads(__tstate);
26405 if (PyErr_Occurred()) SWIG_fail;
26406 }
26407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26408 return resultobj;
26409 fail:
26410 return NULL;
26411 }
26412
26413
26414 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26415 PyObject *resultobj = 0;
26416 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26417 bool arg2 = (bool) true ;
26418 void *argp1 = 0 ;
26419 int res1 = 0 ;
26420 bool val2 ;
26421 int ecode2 = 0 ;
26422 PyObject * obj0 = 0 ;
26423 PyObject * obj1 = 0 ;
26424 char * kwnames[] = {
26425 (char *) "self",(char *) "needMore", NULL
26426 };
26427
26428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26430 if (!SWIG_IsOK(res1)) {
26431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26432 }
26433 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26434 if (obj1) {
26435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26436 if (!SWIG_IsOK(ecode2)) {
26437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26438 }
26439 arg2 = static_cast< bool >(val2);
26440 }
26441 {
26442 PyThreadState* __tstate = wxPyBeginAllowThreads();
26443 (arg1)->RequestMore(arg2);
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 resultobj = SWIG_Py_Void();
26448 return resultobj;
26449 fail:
26450 return NULL;
26451 }
26452
26453
26454 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26455 PyObject *resultobj = 0;
26456 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26457 bool result;
26458 void *argp1 = 0 ;
26459 int res1 = 0 ;
26460 PyObject *swig_obj[1] ;
26461
26462 if (!args) SWIG_fail;
26463 swig_obj[0] = args;
26464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26465 if (!SWIG_IsOK(res1)) {
26466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26467 }
26468 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 {
26476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26477 }
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj = 0;
26486 wxIdleMode arg1 ;
26487 int val1 ;
26488 int ecode1 = 0 ;
26489 PyObject * obj0 = 0 ;
26490 char * kwnames[] = {
26491 (char *) "mode", NULL
26492 };
26493
26494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26495 ecode1 = SWIG_AsVal_int(obj0, &val1);
26496 if (!SWIG_IsOK(ecode1)) {
26497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26498 }
26499 arg1 = static_cast< wxIdleMode >(val1);
26500 {
26501 PyThreadState* __tstate = wxPyBeginAllowThreads();
26502 wxIdleEvent::SetMode(arg1);
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 resultobj = SWIG_Py_Void();
26507 return resultobj;
26508 fail:
26509 return NULL;
26510 }
26511
26512
26513 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26514 PyObject *resultobj = 0;
26515 wxIdleMode result;
26516
26517 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (wxIdleMode)wxIdleEvent::GetMode();
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 resultobj = SWIG_From_int(static_cast< int >(result));
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj = 0;
26533 wxWindow *arg1 = (wxWindow *) 0 ;
26534 bool result;
26535 void *argp1 = 0 ;
26536 int res1 = 0 ;
26537 PyObject * obj0 = 0 ;
26538 char * kwnames[] = {
26539 (char *) "win", NULL
26540 };
26541
26542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26544 if (!SWIG_IsOK(res1)) {
26545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26546 }
26547 arg1 = reinterpret_cast< wxWindow * >(argp1);
26548 {
26549 PyThreadState* __tstate = wxPyBeginAllowThreads();
26550 result = (bool)wxIdleEvent::CanSend(arg1);
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 {
26555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26556 }
26557 return resultobj;
26558 fail:
26559 return NULL;
26560 }
26561
26562
26563 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26564 PyObject *obj;
26565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26566 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26567 return SWIG_Py_Void();
26568 }
26569
26570 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26571 return SWIG_Python_InitShadowInstance(args);
26572 }
26573
26574 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26575 PyObject *resultobj = 0;
26576 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26577 int arg2 = (int) 0 ;
26578 wxClipboardTextEvent *result = 0 ;
26579 int val1 ;
26580 int ecode1 = 0 ;
26581 int val2 ;
26582 int ecode2 = 0 ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 char * kwnames[] = {
26586 (char *) "type",(char *) "winid", NULL
26587 };
26588
26589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26590 if (obj0) {
26591 ecode1 = SWIG_AsVal_int(obj0, &val1);
26592 if (!SWIG_IsOK(ecode1)) {
26593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26594 }
26595 arg1 = static_cast< wxEventType >(val1);
26596 }
26597 if (obj1) {
26598 ecode2 = SWIG_AsVal_int(obj1, &val2);
26599 if (!SWIG_IsOK(ecode2)) {
26600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26601 }
26602 arg2 = static_cast< int >(val2);
26603 }
26604 {
26605 PyThreadState* __tstate = wxPyBeginAllowThreads();
26606 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26607 wxPyEndAllowThreads(__tstate);
26608 if (PyErr_Occurred()) SWIG_fail;
26609 }
26610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26618 PyObject *obj;
26619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26620 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26621 return SWIG_Py_Void();
26622 }
26623
26624 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26625 return SWIG_Python_InitShadowInstance(args);
26626 }
26627
26628 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26629 PyObject *resultobj = 0;
26630 int arg1 = (int) 0 ;
26631 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26632 wxPyEvent *result = 0 ;
26633 int val1 ;
26634 int ecode1 = 0 ;
26635 int val2 ;
26636 int ecode2 = 0 ;
26637 PyObject * obj0 = 0 ;
26638 PyObject * obj1 = 0 ;
26639 char * kwnames[] = {
26640 (char *) "winid",(char *) "eventType", NULL
26641 };
26642
26643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26644 if (obj0) {
26645 ecode1 = SWIG_AsVal_int(obj0, &val1);
26646 if (!SWIG_IsOK(ecode1)) {
26647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26648 }
26649 arg1 = static_cast< int >(val1);
26650 }
26651 if (obj1) {
26652 ecode2 = SWIG_AsVal_int(obj1, &val2);
26653 if (!SWIG_IsOK(ecode2)) {
26654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26655 }
26656 arg2 = static_cast< wxEventType >(val2);
26657 }
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 PyObject *resultobj = 0;
26673 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26674 void *argp1 = 0 ;
26675 int res1 = 0 ;
26676 PyObject *swig_obj[1] ;
26677
26678 if (!args) SWIG_fail;
26679 swig_obj[0] = args;
26680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26681 if (!SWIG_IsOK(res1)) {
26682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26683 }
26684 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 delete arg1;
26688
26689 wxPyEndAllowThreads(__tstate);
26690 if (PyErr_Occurred()) SWIG_fail;
26691 }
26692 resultobj = SWIG_Py_Void();
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26700 PyObject *resultobj = 0;
26701 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26702 PyObject *arg2 = (PyObject *) 0 ;
26703 void *argp1 = 0 ;
26704 int res1 = 0 ;
26705 PyObject * obj0 = 0 ;
26706 PyObject * obj1 = 0 ;
26707 char * kwnames[] = {
26708 (char *) "self",(char *) "self", NULL
26709 };
26710
26711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26715 }
26716 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26717 arg2 = obj1;
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 (arg1)->SetSelf(arg2);
26721 wxPyEndAllowThreads(__tstate);
26722 if (PyErr_Occurred()) SWIG_fail;
26723 }
26724 resultobj = SWIG_Py_Void();
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26732 PyObject *resultobj = 0;
26733 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26734 PyObject *result = 0 ;
26735 void *argp1 = 0 ;
26736 int res1 = 0 ;
26737 PyObject *swig_obj[1] ;
26738
26739 if (!args) SWIG_fail;
26740 swig_obj[0] = args;
26741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26742 if (!SWIG_IsOK(res1)) {
26743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26744 }
26745 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26746 {
26747 PyThreadState* __tstate = wxPyBeginAllowThreads();
26748 result = (PyObject *)(arg1)->GetSelf();
26749 wxPyEndAllowThreads(__tstate);
26750 if (PyErr_Occurred()) SWIG_fail;
26751 }
26752 resultobj = result;
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26760 PyObject *obj;
26761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26762 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26763 return SWIG_Py_Void();
26764 }
26765
26766 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26767 return SWIG_Python_InitShadowInstance(args);
26768 }
26769
26770 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26773 int arg2 = (int) 0 ;
26774 wxPyCommandEvent *result = 0 ;
26775 int val1 ;
26776 int ecode1 = 0 ;
26777 int val2 ;
26778 int ecode2 = 0 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char * kwnames[] = {
26782 (char *) "eventType",(char *) "id", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26786 if (obj0) {
26787 ecode1 = SWIG_AsVal_int(obj0, &val1);
26788 if (!SWIG_IsOK(ecode1)) {
26789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26790 }
26791 arg1 = static_cast< wxEventType >(val1);
26792 }
26793 if (obj1) {
26794 ecode2 = SWIG_AsVal_int(obj1, &val2);
26795 if (!SWIG_IsOK(ecode2)) {
26796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26797 }
26798 arg2 = static_cast< int >(val2);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 PyObject *swig_obj[1] ;
26819
26820 if (!args) SWIG_fail;
26821 swig_obj[0] = args;
26822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26825 }
26826 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 delete arg1;
26830
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 resultobj = SWIG_Py_Void();
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj = 0;
26843 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26844 PyObject *arg2 = (PyObject *) 0 ;
26845 void *argp1 = 0 ;
26846 int res1 = 0 ;
26847 PyObject * obj0 = 0 ;
26848 PyObject * obj1 = 0 ;
26849 char * kwnames[] = {
26850 (char *) "self",(char *) "self", NULL
26851 };
26852
26853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26855 if (!SWIG_IsOK(res1)) {
26856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26857 }
26858 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26859 arg2 = obj1;
26860 {
26861 PyThreadState* __tstate = wxPyBeginAllowThreads();
26862 (arg1)->SetSelf(arg2);
26863 wxPyEndAllowThreads(__tstate);
26864 if (PyErr_Occurred()) SWIG_fail;
26865 }
26866 resultobj = SWIG_Py_Void();
26867 return resultobj;
26868 fail:
26869 return NULL;
26870 }
26871
26872
26873 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26874 PyObject *resultobj = 0;
26875 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26876 PyObject *result = 0 ;
26877 void *argp1 = 0 ;
26878 int res1 = 0 ;
26879 PyObject *swig_obj[1] ;
26880
26881 if (!args) SWIG_fail;
26882 swig_obj[0] = args;
26883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26884 if (!SWIG_IsOK(res1)) {
26885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26886 }
26887 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 result = (PyObject *)(arg1)->GetSelf();
26891 wxPyEndAllowThreads(__tstate);
26892 if (PyErr_Occurred()) SWIG_fail;
26893 }
26894 resultobj = result;
26895 return resultobj;
26896 fail:
26897 return NULL;
26898 }
26899
26900
26901 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26902 PyObject *obj;
26903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26904 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26905 return SWIG_Py_Void();
26906 }
26907
26908 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26909 return SWIG_Python_InitShadowInstance(args);
26910 }
26911
26912 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26913 PyObject *resultobj = 0;
26914 wxWindow *arg1 = (wxWindow *) 0 ;
26915 wxDateTime *arg2 = 0 ;
26916 wxEventType arg3 ;
26917 wxDateEvent *result = 0 ;
26918 void *argp1 = 0 ;
26919 int res1 = 0 ;
26920 void *argp2 = 0 ;
26921 int res2 = 0 ;
26922 int val3 ;
26923 int ecode3 = 0 ;
26924 PyObject * obj0 = 0 ;
26925 PyObject * obj1 = 0 ;
26926 PyObject * obj2 = 0 ;
26927 char * kwnames[] = {
26928 (char *) "win",(char *) "dt",(char *) "type", NULL
26929 };
26930
26931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26933 if (!SWIG_IsOK(res1)) {
26934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26935 }
26936 arg1 = reinterpret_cast< wxWindow * >(argp1);
26937 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26938 if (!SWIG_IsOK(res2)) {
26939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26940 }
26941 if (!argp2) {
26942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26943 }
26944 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26945 ecode3 = SWIG_AsVal_int(obj2, &val3);
26946 if (!SWIG_IsOK(ecode3)) {
26947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26948 }
26949 arg3 = static_cast< wxEventType >(val3);
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26957 return resultobj;
26958 fail:
26959 return NULL;
26960 }
26961
26962
26963 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26964 PyObject *resultobj = 0;
26965 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26966 wxDateTime *result = 0 ;
26967 void *argp1 = 0 ;
26968 int res1 = 0 ;
26969 PyObject *swig_obj[1] ;
26970
26971 if (!args) SWIG_fail;
26972 swig_obj[0] = args;
26973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26974 if (!SWIG_IsOK(res1)) {
26975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26976 }
26977 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 {
26981 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26982 result = (wxDateTime *) &_result_ref;
26983 }
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26988 return resultobj;
26989 fail:
26990 return NULL;
26991 }
26992
26993
26994 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26995 PyObject *resultobj = 0;
26996 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26997 wxDateTime *arg2 = 0 ;
26998 void *argp1 = 0 ;
26999 int res1 = 0 ;
27000 void *argp2 = 0 ;
27001 int res2 = 0 ;
27002 PyObject * obj0 = 0 ;
27003 PyObject * obj1 = 0 ;
27004 char * kwnames[] = {
27005 (char *) "self",(char *) "date", NULL
27006 };
27007
27008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27010 if (!SWIG_IsOK(res1)) {
27011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27012 }
27013 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27014 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27015 if (!SWIG_IsOK(res2)) {
27016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27017 }
27018 if (!argp2) {
27019 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27020 }
27021 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 (arg1)->SetDate((wxDateTime const &)*arg2);
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 resultobj = SWIG_Py_Void();
27029 return resultobj;
27030 fail:
27031 return NULL;
27032 }
27033
27034
27035 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27036 PyObject *obj;
27037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27038 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27039 return SWIG_Py_Void();
27040 }
27041
27042 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 return SWIG_Python_InitShadowInstance(args);
27044 }
27045
27046 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxPyApp *result = 0 ;
27049
27050 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27051 {
27052 PyThreadState* __tstate = wxPyBeginAllowThreads();
27053 result = (wxPyApp *)new_wxPyApp();
27054 wxPyEndAllowThreads(__tstate);
27055 if (PyErr_Occurred()) SWIG_fail;
27056 }
27057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27065 PyObject *resultobj = 0;
27066 wxPyApp *arg1 = (wxPyApp *) 0 ;
27067 void *argp1 = 0 ;
27068 int res1 = 0 ;
27069 PyObject *swig_obj[1] ;
27070
27071 if (!args) SWIG_fail;
27072 swig_obj[0] = args;
27073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27074 if (!SWIG_IsOK(res1)) {
27075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27076 }
27077 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 delete arg1;
27081
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 resultobj = SWIG_Py_Void();
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj = 0;
27094 wxPyApp *arg1 = (wxPyApp *) 0 ;
27095 PyObject *arg2 = (PyObject *) 0 ;
27096 PyObject *arg3 = (PyObject *) 0 ;
27097 bool arg4 ;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 bool val4 ;
27101 int ecode4 = 0 ;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 PyObject * obj2 = 0 ;
27105 PyObject * obj3 = 0 ;
27106 char * kwnames[] = {
27107 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27108 };
27109
27110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27114 }
27115 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27116 arg2 = obj1;
27117 arg3 = obj2;
27118 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27119 if (!SWIG_IsOK(ecode4)) {
27120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27121 }
27122 arg4 = static_cast< bool >(val4);
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 resultobj = SWIG_Py_Void();
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27137 PyObject *resultobj = 0;
27138 wxPyApp *arg1 = (wxPyApp *) 0 ;
27139 wxString result;
27140 void *argp1 = 0 ;
27141 int res1 = 0 ;
27142 PyObject *swig_obj[1] ;
27143
27144 if (!args) SWIG_fail;
27145 swig_obj[0] = args;
27146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27149 }
27150 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27151 {
27152 PyThreadState* __tstate = wxPyBeginAllowThreads();
27153 result = ((wxPyApp const *)arg1)->GetAppName();
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 {
27158 #if wxUSE_UNICODE
27159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27160 #else
27161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27162 #endif
27163 }
27164 return resultobj;
27165 fail:
27166 return NULL;
27167 }
27168
27169
27170 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27171 PyObject *resultobj = 0;
27172 wxPyApp *arg1 = (wxPyApp *) 0 ;
27173 wxString *arg2 = 0 ;
27174 void *argp1 = 0 ;
27175 int res1 = 0 ;
27176 bool temp2 = false ;
27177 PyObject * obj0 = 0 ;
27178 PyObject * obj1 = 0 ;
27179 char * kwnames[] = {
27180 (char *) "self",(char *) "name", NULL
27181 };
27182
27183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27185 if (!SWIG_IsOK(res1)) {
27186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27187 }
27188 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27189 {
27190 arg2 = wxString_in_helper(obj1);
27191 if (arg2 == NULL) SWIG_fail;
27192 temp2 = true;
27193 }
27194 {
27195 PyThreadState* __tstate = wxPyBeginAllowThreads();
27196 (arg1)->SetAppName((wxString const &)*arg2);
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 resultobj = SWIG_Py_Void();
27201 {
27202 if (temp2)
27203 delete arg2;
27204 }
27205 return resultobj;
27206 fail:
27207 {
27208 if (temp2)
27209 delete arg2;
27210 }
27211 return NULL;
27212 }
27213
27214
27215 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27216 PyObject *resultobj = 0;
27217 wxPyApp *arg1 = (wxPyApp *) 0 ;
27218 wxString result;
27219 void *argp1 = 0 ;
27220 int res1 = 0 ;
27221 PyObject *swig_obj[1] ;
27222
27223 if (!args) SWIG_fail;
27224 swig_obj[0] = args;
27225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27226 if (!SWIG_IsOK(res1)) {
27227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27228 }
27229 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27230 {
27231 PyThreadState* __tstate = wxPyBeginAllowThreads();
27232 result = ((wxPyApp const *)arg1)->GetClassName();
27233 wxPyEndAllowThreads(__tstate);
27234 if (PyErr_Occurred()) SWIG_fail;
27235 }
27236 {
27237 #if wxUSE_UNICODE
27238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27239 #else
27240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27241 #endif
27242 }
27243 return resultobj;
27244 fail:
27245 return NULL;
27246 }
27247
27248
27249 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27250 PyObject *resultobj = 0;
27251 wxPyApp *arg1 = (wxPyApp *) 0 ;
27252 wxString *arg2 = 0 ;
27253 void *argp1 = 0 ;
27254 int res1 = 0 ;
27255 bool temp2 = false ;
27256 PyObject * obj0 = 0 ;
27257 PyObject * obj1 = 0 ;
27258 char * kwnames[] = {
27259 (char *) "self",(char *) "name", NULL
27260 };
27261
27262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27264 if (!SWIG_IsOK(res1)) {
27265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27266 }
27267 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27268 {
27269 arg2 = wxString_in_helper(obj1);
27270 if (arg2 == NULL) SWIG_fail;
27271 temp2 = true;
27272 }
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 (arg1)->SetClassName((wxString const &)*arg2);
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 resultobj = SWIG_Py_Void();
27280 {
27281 if (temp2)
27282 delete arg2;
27283 }
27284 return resultobj;
27285 fail:
27286 {
27287 if (temp2)
27288 delete arg2;
27289 }
27290 return NULL;
27291 }
27292
27293
27294 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27295 PyObject *resultobj = 0;
27296 wxPyApp *arg1 = (wxPyApp *) 0 ;
27297 wxString *result = 0 ;
27298 void *argp1 = 0 ;
27299 int res1 = 0 ;
27300 PyObject *swig_obj[1] ;
27301
27302 if (!args) SWIG_fail;
27303 swig_obj[0] = args;
27304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27305 if (!SWIG_IsOK(res1)) {
27306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27307 }
27308 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 {
27312 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27313 result = (wxString *) &_result_ref;
27314 }
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 {
27319 #if wxUSE_UNICODE
27320 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27321 #else
27322 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27323 #endif
27324 }
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27332 PyObject *resultobj = 0;
27333 wxPyApp *arg1 = (wxPyApp *) 0 ;
27334 wxString *arg2 = 0 ;
27335 void *argp1 = 0 ;
27336 int res1 = 0 ;
27337 bool temp2 = false ;
27338 PyObject * obj0 = 0 ;
27339 PyObject * obj1 = 0 ;
27340 char * kwnames[] = {
27341 (char *) "self",(char *) "name", NULL
27342 };
27343
27344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27346 if (!SWIG_IsOK(res1)) {
27347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27348 }
27349 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27350 {
27351 arg2 = wxString_in_helper(obj1);
27352 if (arg2 == NULL) SWIG_fail;
27353 temp2 = true;
27354 }
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 (arg1)->SetVendorName((wxString const &)*arg2);
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 resultobj = SWIG_Py_Void();
27362 {
27363 if (temp2)
27364 delete arg2;
27365 }
27366 return resultobj;
27367 fail:
27368 {
27369 if (temp2)
27370 delete arg2;
27371 }
27372 return NULL;
27373 }
27374
27375
27376 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27377 PyObject *resultobj = 0;
27378 wxPyApp *arg1 = (wxPyApp *) 0 ;
27379 wxAppTraits *result = 0 ;
27380 void *argp1 = 0 ;
27381 int res1 = 0 ;
27382 PyObject *swig_obj[1] ;
27383
27384 if (!args) SWIG_fail;
27385 swig_obj[0] = args;
27386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27387 if (!SWIG_IsOK(res1)) {
27388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27389 }
27390 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 result = (wxAppTraits *)(arg1)->GetTraits();
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27398 return resultobj;
27399 fail:
27400 return NULL;
27401 }
27402
27403
27404 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27405 PyObject *resultobj = 0;
27406 wxPyApp *arg1 = (wxPyApp *) 0 ;
27407 void *argp1 = 0 ;
27408 int res1 = 0 ;
27409 PyObject *swig_obj[1] ;
27410
27411 if (!args) SWIG_fail;
27412 swig_obj[0] = args;
27413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27414 if (!SWIG_IsOK(res1)) {
27415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27416 }
27417 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 (arg1)->ProcessPendingEvents();
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 resultobj = SWIG_Py_Void();
27425 return resultobj;
27426 fail:
27427 return NULL;
27428 }
27429
27430
27431 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27432 PyObject *resultobj = 0;
27433 wxPyApp *arg1 = (wxPyApp *) 0 ;
27434 bool arg2 = (bool) false ;
27435 bool result;
27436 void *argp1 = 0 ;
27437 int res1 = 0 ;
27438 bool val2 ;
27439 int ecode2 = 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char * kwnames[] = {
27443 (char *) "self",(char *) "onlyIfNeeded", NULL
27444 };
27445
27446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27450 }
27451 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27452 if (obj1) {
27453 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27454 if (!SWIG_IsOK(ecode2)) {
27455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27456 }
27457 arg2 = static_cast< bool >(val2);
27458 }
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 result = (bool)(arg1)->Yield(arg2);
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27467 }
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27475 PyObject *resultobj = 0;
27476 wxPyApp *arg1 = (wxPyApp *) 0 ;
27477 void *argp1 = 0 ;
27478 int res1 = 0 ;
27479 PyObject *swig_obj[1] ;
27480
27481 if (!args) SWIG_fail;
27482 swig_obj[0] = args;
27483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27484 if (!SWIG_IsOK(res1)) {
27485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27486 }
27487 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27488 {
27489 PyThreadState* __tstate = wxPyBeginAllowThreads();
27490 (arg1)->WakeUpIdle();
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 resultobj = SWIG_Py_Void();
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 PyObject *resultobj = 0;
27503 bool result;
27504
27505 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (bool)wxPyApp::IsMainLoopRunning();
27509 wxPyEndAllowThreads(__tstate);
27510 if (PyErr_Occurred()) SWIG_fail;
27511 }
27512 {
27513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27514 }
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27522 PyObject *resultobj = 0;
27523 wxPyApp *arg1 = (wxPyApp *) 0 ;
27524 int result;
27525 void *argp1 = 0 ;
27526 int res1 = 0 ;
27527 PyObject *swig_obj[1] ;
27528
27529 if (!args) SWIG_fail;
27530 swig_obj[0] = args;
27531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27532 if (!SWIG_IsOK(res1)) {
27533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27534 }
27535 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 result = (int)(arg1)->MainLoop();
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_From_int(static_cast< int >(result));
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27550 PyObject *resultobj = 0;
27551 wxPyApp *arg1 = (wxPyApp *) 0 ;
27552 void *argp1 = 0 ;
27553 int res1 = 0 ;
27554 PyObject *swig_obj[1] ;
27555
27556 if (!args) SWIG_fail;
27557 swig_obj[0] = args;
27558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27559 if (!SWIG_IsOK(res1)) {
27560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27561 }
27562 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 (arg1)->Exit();
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 resultobj = SWIG_Py_Void();
27570 return resultobj;
27571 fail:
27572 return NULL;
27573 }
27574
27575
27576 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27577 PyObject *resultobj = 0;
27578 wxPyApp *arg1 = (wxPyApp *) 0 ;
27579 void *argp1 = 0 ;
27580 int res1 = 0 ;
27581 PyObject *swig_obj[1] ;
27582
27583 if (!args) SWIG_fail;
27584 swig_obj[0] = args;
27585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27586 if (!SWIG_IsOK(res1)) {
27587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27588 }
27589 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 (arg1)->ExitMainLoop();
27593 wxPyEndAllowThreads(__tstate);
27594 if (PyErr_Occurred()) SWIG_fail;
27595 }
27596 resultobj = SWIG_Py_Void();
27597 return resultobj;
27598 fail:
27599 return NULL;
27600 }
27601
27602
27603 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27604 PyObject *resultobj = 0;
27605 wxPyApp *arg1 = (wxPyApp *) 0 ;
27606 bool result;
27607 void *argp1 = 0 ;
27608 int res1 = 0 ;
27609 PyObject *swig_obj[1] ;
27610
27611 if (!args) SWIG_fail;
27612 swig_obj[0] = args;
27613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27614 if (!SWIG_IsOK(res1)) {
27615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27616 }
27617 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 result = (bool)(arg1)->Pending();
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 {
27625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27626 }
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27634 PyObject *resultobj = 0;
27635 wxPyApp *arg1 = (wxPyApp *) 0 ;
27636 bool result;
27637 void *argp1 = 0 ;
27638 int res1 = 0 ;
27639 PyObject *swig_obj[1] ;
27640
27641 if (!args) SWIG_fail;
27642 swig_obj[0] = args;
27643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 result = (bool)(arg1)->Dispatch();
27651 wxPyEndAllowThreads(__tstate);
27652 if (PyErr_Occurred()) SWIG_fail;
27653 }
27654 {
27655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27656 }
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27664 PyObject *resultobj = 0;
27665 wxPyApp *arg1 = (wxPyApp *) 0 ;
27666 bool result;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 PyObject *swig_obj[1] ;
27670
27671 if (!args) SWIG_fail;
27672 swig_obj[0] = args;
27673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27674 if (!SWIG_IsOK(res1)) {
27675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27676 }
27677 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 result = (bool)(arg1)->ProcessIdle();
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 {
27685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27686 }
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27694 PyObject *resultobj = 0;
27695 wxPyApp *arg1 = (wxPyApp *) 0 ;
27696 wxWindow *arg2 = (wxWindow *) 0 ;
27697 wxIdleEvent *arg3 = 0 ;
27698 bool result;
27699 void *argp1 = 0 ;
27700 int res1 = 0 ;
27701 void *argp2 = 0 ;
27702 int res2 = 0 ;
27703 void *argp3 = 0 ;
27704 int res3 = 0 ;
27705 PyObject * obj0 = 0 ;
27706 PyObject * obj1 = 0 ;
27707 PyObject * obj2 = 0 ;
27708 char * kwnames[] = {
27709 (char *) "self",(char *) "win",(char *) "event", NULL
27710 };
27711
27712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27716 }
27717 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27719 if (!SWIG_IsOK(res2)) {
27720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27721 }
27722 arg2 = reinterpret_cast< wxWindow * >(argp2);
27723 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27724 if (!SWIG_IsOK(res3)) {
27725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27726 }
27727 if (!argp3) {
27728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27729 }
27730 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27731 {
27732 PyThreadState* __tstate = wxPyBeginAllowThreads();
27733 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27734 wxPyEndAllowThreads(__tstate);
27735 if (PyErr_Occurred()) SWIG_fail;
27736 }
27737 {
27738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27739 }
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27747 PyObject *resultobj = 0;
27748 wxPyApp *arg1 = (wxPyApp *) 0 ;
27749 bool result;
27750 void *argp1 = 0 ;
27751 int res1 = 0 ;
27752 PyObject *swig_obj[1] ;
27753
27754 if (!args) SWIG_fail;
27755 swig_obj[0] = args;
27756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27757 if (!SWIG_IsOK(res1)) {
27758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27759 }
27760 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 result = (bool)((wxPyApp const *)arg1)->IsActive();
27764 wxPyEndAllowThreads(__tstate);
27765 if (PyErr_Occurred()) SWIG_fail;
27766 }
27767 {
27768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27769 }
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27777 PyObject *resultobj = 0;
27778 wxPyApp *arg1 = (wxPyApp *) 0 ;
27779 wxWindow *arg2 = (wxWindow *) 0 ;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 void *argp2 = 0 ;
27783 int res2 = 0 ;
27784 PyObject * obj0 = 0 ;
27785 PyObject * obj1 = 0 ;
27786 char * kwnames[] = {
27787 (char *) "self",(char *) "win", NULL
27788 };
27789
27790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27792 if (!SWIG_IsOK(res1)) {
27793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27794 }
27795 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27797 if (!SWIG_IsOK(res2)) {
27798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27799 }
27800 arg2 = reinterpret_cast< wxWindow * >(argp2);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 (arg1)->SetTopWindow(arg2);
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 resultobj = SWIG_Py_Void();
27808 return resultobj;
27809 fail:
27810 return NULL;
27811 }
27812
27813
27814 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27815 PyObject *resultobj = 0;
27816 wxPyApp *arg1 = (wxPyApp *) 0 ;
27817 wxWindow *result = 0 ;
27818 void *argp1 = 0 ;
27819 int res1 = 0 ;
27820 PyObject *swig_obj[1] ;
27821
27822 if (!args) SWIG_fail;
27823 swig_obj[0] = args;
27824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27825 if (!SWIG_IsOK(res1)) {
27826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27827 }
27828 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 {
27836 resultobj = wxPyMake_wxObject(result, (bool)0);
27837 }
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27845 PyObject *resultobj = 0;
27846 wxPyApp *arg1 = (wxPyApp *) 0 ;
27847 bool arg2 ;
27848 void *argp1 = 0 ;
27849 int res1 = 0 ;
27850 bool val2 ;
27851 int ecode2 = 0 ;
27852 PyObject * obj0 = 0 ;
27853 PyObject * obj1 = 0 ;
27854 char * kwnames[] = {
27855 (char *) "self",(char *) "flag", NULL
27856 };
27857
27858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27860 if (!SWIG_IsOK(res1)) {
27861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27862 }
27863 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27864 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27865 if (!SWIG_IsOK(ecode2)) {
27866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27867 }
27868 arg2 = static_cast< bool >(val2);
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 (arg1)->SetExitOnFrameDelete(arg2);
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 resultobj = SWIG_Py_Void();
27876 return resultobj;
27877 fail:
27878 return NULL;
27879 }
27880
27881
27882 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27883 PyObject *resultobj = 0;
27884 wxPyApp *arg1 = (wxPyApp *) 0 ;
27885 bool result;
27886 void *argp1 = 0 ;
27887 int res1 = 0 ;
27888 PyObject *swig_obj[1] ;
27889
27890 if (!args) SWIG_fail;
27891 swig_obj[0] = args;
27892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27893 if (!SWIG_IsOK(res1)) {
27894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27895 }
27896 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27897 {
27898 PyThreadState* __tstate = wxPyBeginAllowThreads();
27899 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27905 }
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj = 0;
27914 wxPyApp *arg1 = (wxPyApp *) 0 ;
27915 bool arg2 ;
27916 void *argp1 = 0 ;
27917 int res1 = 0 ;
27918 bool val2 ;
27919 int ecode2 = 0 ;
27920 PyObject * obj0 = 0 ;
27921 PyObject * obj1 = 0 ;
27922 char * kwnames[] = {
27923 (char *) "self",(char *) "flag", NULL
27924 };
27925
27926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27928 if (!SWIG_IsOK(res1)) {
27929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27930 }
27931 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27933 if (!SWIG_IsOK(ecode2)) {
27934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27935 }
27936 arg2 = static_cast< bool >(val2);
27937 {
27938 PyThreadState* __tstate = wxPyBeginAllowThreads();
27939 (arg1)->SetUseBestVisual(arg2);
27940 wxPyEndAllowThreads(__tstate);
27941 if (PyErr_Occurred()) SWIG_fail;
27942 }
27943 resultobj = SWIG_Py_Void();
27944 return resultobj;
27945 fail:
27946 return NULL;
27947 }
27948
27949
27950 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27951 PyObject *resultobj = 0;
27952 wxPyApp *arg1 = (wxPyApp *) 0 ;
27953 bool result;
27954 void *argp1 = 0 ;
27955 int res1 = 0 ;
27956 PyObject *swig_obj[1] ;
27957
27958 if (!args) SWIG_fail;
27959 swig_obj[0] = args;
27960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27961 if (!SWIG_IsOK(res1)) {
27962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27963 }
27964 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 {
27972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27973 }
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj = 0;
27982 wxPyApp *arg1 = (wxPyApp *) 0 ;
27983 int arg2 ;
27984 void *argp1 = 0 ;
27985 int res1 = 0 ;
27986 int val2 ;
27987 int ecode2 = 0 ;
27988 PyObject * obj0 = 0 ;
27989 PyObject * obj1 = 0 ;
27990 char * kwnames[] = {
27991 (char *) "self",(char *) "mode", NULL
27992 };
27993
27994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27996 if (!SWIG_IsOK(res1)) {
27997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27998 }
27999 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28000 ecode2 = SWIG_AsVal_int(obj1, &val2);
28001 if (!SWIG_IsOK(ecode2)) {
28002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28003 }
28004 arg2 = static_cast< int >(val2);
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 (arg1)->SetPrintMode(arg2);
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 resultobj = SWIG_Py_Void();
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28019 PyObject *resultobj = 0;
28020 wxPyApp *arg1 = (wxPyApp *) 0 ;
28021 int result;
28022 void *argp1 = 0 ;
28023 int res1 = 0 ;
28024 PyObject *swig_obj[1] ;
28025
28026 if (!args) SWIG_fail;
28027 swig_obj[0] = args;
28028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28029 if (!SWIG_IsOK(res1)) {
28030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28031 }
28032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_From_int(static_cast< int >(result));
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 wxPyApp *arg1 = (wxPyApp *) 0 ;
28049 int arg2 ;
28050 void *argp1 = 0 ;
28051 int res1 = 0 ;
28052 int val2 ;
28053 int ecode2 = 0 ;
28054 PyObject * obj0 = 0 ;
28055 PyObject * obj1 = 0 ;
28056 char * kwnames[] = {
28057 (char *) "self",(char *) "mode", NULL
28058 };
28059
28060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28062 if (!SWIG_IsOK(res1)) {
28063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28064 }
28065 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28066 ecode2 = SWIG_AsVal_int(obj1, &val2);
28067 if (!SWIG_IsOK(ecode2)) {
28068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28069 }
28070 arg2 = static_cast< int >(val2);
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 (arg1)->SetAssertMode(arg2);
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 resultobj = SWIG_Py_Void();
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28085 PyObject *resultobj = 0;
28086 wxPyApp *arg1 = (wxPyApp *) 0 ;
28087 int result;
28088 void *argp1 = 0 ;
28089 int res1 = 0 ;
28090 PyObject *swig_obj[1] ;
28091
28092 if (!args) SWIG_fail;
28093 swig_obj[0] = args;
28094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28095 if (!SWIG_IsOK(res1)) {
28096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28097 }
28098 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (int)(arg1)->GetAssertMode();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 resultobj = SWIG_From_int(static_cast< int >(result));
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28113 PyObject *resultobj = 0;
28114 bool result;
28115
28116 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 {
28124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28125 }
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28133 PyObject *resultobj = 0;
28134 long result;
28135
28136 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 result = (long)wxPyApp::GetMacAboutMenuItemId();
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_From_long(static_cast< long >(result));
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28151 PyObject *resultobj = 0;
28152 long result;
28153
28154 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28155 {
28156 PyThreadState* __tstate = wxPyBeginAllowThreads();
28157 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 resultobj = SWIG_From_long(static_cast< long >(result));
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28169 PyObject *resultobj = 0;
28170 long result;
28171
28172 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (long)wxPyApp::GetMacExitMenuItemId();
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_From_long(static_cast< long >(result));
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 PyObject *resultobj = 0;
28188 wxString result;
28189
28190 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28191 {
28192 PyThreadState* __tstate = wxPyBeginAllowThreads();
28193 result = wxPyApp::GetMacHelpMenuTitleName();
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 {
28198 #if wxUSE_UNICODE
28199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28200 #else
28201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28202 #endif
28203 }
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj = 0;
28212 bool arg1 ;
28213 bool val1 ;
28214 int ecode1 = 0 ;
28215 PyObject * obj0 = 0 ;
28216 char * kwnames[] = {
28217 (char *) "val", NULL
28218 };
28219
28220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28221 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28222 if (!SWIG_IsOK(ecode1)) {
28223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28224 }
28225 arg1 = static_cast< bool >(val1);
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 resultobj = SWIG_Py_Void();
28233 return resultobj;
28234 fail:
28235 return NULL;
28236 }
28237
28238
28239 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28240 PyObject *resultobj = 0;
28241 long arg1 ;
28242 long val1 ;
28243 int ecode1 = 0 ;
28244 PyObject * obj0 = 0 ;
28245 char * kwnames[] = {
28246 (char *) "val", NULL
28247 };
28248
28249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28250 ecode1 = SWIG_AsVal_long(obj0, &val1);
28251 if (!SWIG_IsOK(ecode1)) {
28252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28253 }
28254 arg1 = static_cast< long >(val1);
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 wxPyApp::SetMacAboutMenuItemId(arg1);
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = SWIG_Py_Void();
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28269 PyObject *resultobj = 0;
28270 long arg1 ;
28271 long val1 ;
28272 int ecode1 = 0 ;
28273 PyObject * obj0 = 0 ;
28274 char * kwnames[] = {
28275 (char *) "val", NULL
28276 };
28277
28278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28279 ecode1 = SWIG_AsVal_long(obj0, &val1);
28280 if (!SWIG_IsOK(ecode1)) {
28281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28282 }
28283 arg1 = static_cast< long >(val1);
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 resultobj = SWIG_Py_Void();
28291 return resultobj;
28292 fail:
28293 return NULL;
28294 }
28295
28296
28297 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28298 PyObject *resultobj = 0;
28299 long arg1 ;
28300 long val1 ;
28301 int ecode1 = 0 ;
28302 PyObject * obj0 = 0 ;
28303 char * kwnames[] = {
28304 (char *) "val", NULL
28305 };
28306
28307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28308 ecode1 = SWIG_AsVal_long(obj0, &val1);
28309 if (!SWIG_IsOK(ecode1)) {
28310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28311 }
28312 arg1 = static_cast< long >(val1);
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 wxPyApp::SetMacExitMenuItemId(arg1);
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 resultobj = SWIG_Py_Void();
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj = 0;
28328 wxString *arg1 = 0 ;
28329 bool temp1 = false ;
28330 PyObject * obj0 = 0 ;
28331 char * kwnames[] = {
28332 (char *) "val", NULL
28333 };
28334
28335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28336 {
28337 arg1 = wxString_in_helper(obj0);
28338 if (arg1 == NULL) SWIG_fail;
28339 temp1 = true;
28340 }
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 resultobj = SWIG_Py_Void();
28348 {
28349 if (temp1)
28350 delete arg1;
28351 }
28352 return resultobj;
28353 fail:
28354 {
28355 if (temp1)
28356 delete arg1;
28357 }
28358 return NULL;
28359 }
28360
28361
28362 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28363 PyObject *resultobj = 0;
28364 wxPyApp *arg1 = (wxPyApp *) 0 ;
28365 void *argp1 = 0 ;
28366 int res1 = 0 ;
28367 PyObject *swig_obj[1] ;
28368
28369 if (!args) SWIG_fail;
28370 swig_obj[0] = args;
28371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28372 if (!SWIG_IsOK(res1)) {
28373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28374 }
28375 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 (arg1)->_BootstrapApp();
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 resultobj = SWIG_Py_Void();
28383 return resultobj;
28384 fail:
28385 return NULL;
28386 }
28387
28388
28389 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28390 PyObject *resultobj = 0;
28391 int result;
28392
28393 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (int)wxPyApp_GetComCtl32Version();
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 resultobj = SWIG_From_int(static_cast< int >(result));
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28408 PyObject *obj;
28409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28410 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28411 return SWIG_Py_Void();
28412 }
28413
28414 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 return SWIG_Python_InitShadowInstance(args);
28416 }
28417
28418 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28419 PyObject *resultobj = 0;
28420
28421 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 wxExit();
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_Py_Void();
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 PyObject *resultobj = 0;
28437 bool result;
28438
28439 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28440 {
28441 PyThreadState* __tstate = wxPyBeginAllowThreads();
28442 result = (bool)wxYield();
28443 wxPyEndAllowThreads(__tstate);
28444 if (PyErr_Occurred()) SWIG_fail;
28445 }
28446 {
28447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28448 }
28449 return resultobj;
28450 fail:
28451 return NULL;
28452 }
28453
28454
28455 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28456 PyObject *resultobj = 0;
28457 bool result;
28458
28459 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (bool)wxYieldIfNeeded();
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 {
28467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28468 }
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28476 PyObject *resultobj = 0;
28477 wxWindow *arg1 = (wxWindow *) NULL ;
28478 bool arg2 = (bool) false ;
28479 bool result;
28480 void *argp1 = 0 ;
28481 int res1 = 0 ;
28482 bool val2 ;
28483 int ecode2 = 0 ;
28484 PyObject * obj0 = 0 ;
28485 PyObject * obj1 = 0 ;
28486 char * kwnames[] = {
28487 (char *) "win",(char *) "onlyIfNeeded", NULL
28488 };
28489
28490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28491 if (obj0) {
28492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28495 }
28496 arg1 = reinterpret_cast< wxWindow * >(argp1);
28497 }
28498 if (obj1) {
28499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28500 if (!SWIG_IsOK(ecode2)) {
28501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28502 }
28503 arg2 = static_cast< bool >(val2);
28504 }
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (bool)wxSafeYield(arg1,arg2);
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28521 PyObject *resultobj = 0;
28522
28523 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 wxWakeUpIdle();
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 resultobj = SWIG_Py_Void();
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28538 PyObject *resultobj = 0;
28539 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28540 wxEvent *arg2 = 0 ;
28541 void *argp1 = 0 ;
28542 int res1 = 0 ;
28543 void *argp2 = 0 ;
28544 int res2 = 0 ;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char * kwnames[] = {
28548 (char *) "dest",(char *) "event", NULL
28549 };
28550
28551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28553 if (!SWIG_IsOK(res1)) {
28554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28555 }
28556 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28557 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28558 if (!SWIG_IsOK(res2)) {
28559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28560 }
28561 if (!argp2) {
28562 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28563 }
28564 arg2 = reinterpret_cast< wxEvent * >(argp2);
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 wxPostEvent(arg1,*arg2);
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 resultobj = SWIG_Py_Void();
28572 return resultobj;
28573 fail:
28574 return NULL;
28575 }
28576
28577
28578 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28579 PyObject *resultobj = 0;
28580
28581 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28582 {
28583 PyThreadState* __tstate = wxPyBeginAllowThreads();
28584 wxApp_CleanUp();
28585 wxPyEndAllowThreads(__tstate);
28586 if (PyErr_Occurred()) SWIG_fail;
28587 }
28588 resultobj = SWIG_Py_Void();
28589 return resultobj;
28590 fail:
28591 return NULL;
28592 }
28593
28594
28595 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28596 PyObject *resultobj = 0;
28597 wxPyApp *result = 0 ;
28598
28599 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (wxPyApp *)wxPyGetApp();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = wxPyMake_wxObject(result, 0);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj = 0;
28617 char *arg1 = (char *) 0 ;
28618 int res1 ;
28619 char *buf1 = 0 ;
28620 int alloc1 = 0 ;
28621 PyObject * obj0 = 0 ;
28622 char * kwnames[] = {
28623 (char *) "encoding", NULL
28624 };
28625
28626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28627 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28628 if (!SWIG_IsOK(res1)) {
28629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28630 }
28631 arg1 = buf1;
28632 {
28633 PyThreadState* __tstate = wxPyBeginAllowThreads();
28634 wxSetDefaultPyEncoding((char const *)arg1);
28635 wxPyEndAllowThreads(__tstate);
28636 if (PyErr_Occurred()) SWIG_fail;
28637 }
28638 resultobj = SWIG_Py_Void();
28639 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28640 return resultobj;
28641 fail:
28642 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *resultobj = 0;
28649 char *result = 0 ;
28650
28651 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 result = (char *)wxGetDefaultPyEncoding();
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 resultobj = SWIG_FromCharPtr(result);
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28666 PyObject *resultobj = 0;
28667 wxEventLoop *result = 0 ;
28668
28669 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 result = (wxEventLoop *)new wxEventLoop();
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 PyObject *resultobj = 0;
28685 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28686 void *argp1 = 0 ;
28687 int res1 = 0 ;
28688 PyObject *swig_obj[1] ;
28689
28690 if (!args) SWIG_fail;
28691 swig_obj[0] = args;
28692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28693 if (!SWIG_IsOK(res1)) {
28694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28695 }
28696 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28697 {
28698 PyThreadState* __tstate = wxPyBeginAllowThreads();
28699 delete arg1;
28700
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 resultobj = SWIG_Py_Void();
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28712 PyObject *resultobj = 0;
28713 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28714 int result;
28715 void *argp1 = 0 ;
28716 int res1 = 0 ;
28717 PyObject *swig_obj[1] ;
28718
28719 if (!args) SWIG_fail;
28720 swig_obj[0] = args;
28721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28722 if (!SWIG_IsOK(res1)) {
28723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28724 }
28725 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = (int)(arg1)->Run();
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 resultobj = SWIG_From_int(static_cast< int >(result));
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28740 PyObject *resultobj = 0;
28741 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28742 int arg2 = (int) 0 ;
28743 void *argp1 = 0 ;
28744 int res1 = 0 ;
28745 int val2 ;
28746 int ecode2 = 0 ;
28747 PyObject * obj0 = 0 ;
28748 PyObject * obj1 = 0 ;
28749 char * kwnames[] = {
28750 (char *) "self",(char *) "rc", NULL
28751 };
28752
28753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28755 if (!SWIG_IsOK(res1)) {
28756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28757 }
28758 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28759 if (obj1) {
28760 ecode2 = SWIG_AsVal_int(obj1, &val2);
28761 if (!SWIG_IsOK(ecode2)) {
28762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28763 }
28764 arg2 = static_cast< int >(val2);
28765 }
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 (arg1)->Exit(arg2);
28769 wxPyEndAllowThreads(__tstate);
28770 if (PyErr_Occurred()) SWIG_fail;
28771 }
28772 resultobj = SWIG_Py_Void();
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28780 PyObject *resultobj = 0;
28781 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28782 bool result;
28783 void *argp1 = 0 ;
28784 int res1 = 0 ;
28785 PyObject *swig_obj[1] ;
28786
28787 if (!args) SWIG_fail;
28788 swig_obj[0] = args;
28789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28790 if (!SWIG_IsOK(res1)) {
28791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28792 }
28793 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 result = (bool)((wxEventLoop const *)arg1)->Pending();
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 {
28801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28802 }
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28810 PyObject *resultobj = 0;
28811 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28812 bool result;
28813 void *argp1 = 0 ;
28814 int res1 = 0 ;
28815 PyObject *swig_obj[1] ;
28816
28817 if (!args) SWIG_fail;
28818 swig_obj[0] = args;
28819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28820 if (!SWIG_IsOK(res1)) {
28821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28822 }
28823 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28824 {
28825 PyThreadState* __tstate = wxPyBeginAllowThreads();
28826 result = (bool)(arg1)->Dispatch();
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 {
28831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28832 }
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28840 PyObject *resultobj = 0;
28841 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28842 bool result;
28843 void *argp1 = 0 ;
28844 int res1 = 0 ;
28845 PyObject *swig_obj[1] ;
28846
28847 if (!args) SWIG_fail;
28848 swig_obj[0] = args;
28849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28850 if (!SWIG_IsOK(res1)) {
28851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28852 }
28853 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28857 wxPyEndAllowThreads(__tstate);
28858 if (PyErr_Occurred()) SWIG_fail;
28859 }
28860 {
28861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28862 }
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28870 PyObject *resultobj = 0;
28871 wxEventLoop *result = 0 ;
28872
28873 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28874 {
28875 PyThreadState* __tstate = wxPyBeginAllowThreads();
28876 result = (wxEventLoop *)wxEventLoop::GetActive();
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj = 0;
28889 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28890 void *argp1 = 0 ;
28891 int res1 = 0 ;
28892 PyObject * obj0 = 0 ;
28893 char * kwnames[] = {
28894 (char *) "loop", NULL
28895 };
28896
28897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28899 if (!SWIG_IsOK(res1)) {
28900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28901 }
28902 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28903 {
28904 PyThreadState* __tstate = wxPyBeginAllowThreads();
28905 wxEventLoop::SetActive(arg1);
28906 wxPyEndAllowThreads(__tstate);
28907 if (PyErr_Occurred()) SWIG_fail;
28908 }
28909 resultobj = SWIG_Py_Void();
28910 return resultobj;
28911 fail:
28912 return NULL;
28913 }
28914
28915
28916 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28917 PyObject *obj;
28918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28919 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28920 return SWIG_Py_Void();
28921 }
28922
28923 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28924 return SWIG_Python_InitShadowInstance(args);
28925 }
28926
28927 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28928 PyObject *resultobj = 0;
28929 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28930 wxEventLoopActivator *result = 0 ;
28931 void *argp1 = 0 ;
28932 int res1 = 0 ;
28933 PyObject * obj0 = 0 ;
28934 char * kwnames[] = {
28935 (char *) "evtLoop", NULL
28936 };
28937
28938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28940 if (!SWIG_IsOK(res1)) {
28941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28942 }
28943 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28944 {
28945 PyThreadState* __tstate = wxPyBeginAllowThreads();
28946 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28958 PyObject *resultobj = 0;
28959 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28960 void *argp1 = 0 ;
28961 int res1 = 0 ;
28962 PyObject *swig_obj[1] ;
28963
28964 if (!args) SWIG_fail;
28965 swig_obj[0] = args;
28966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28967 if (!SWIG_IsOK(res1)) {
28968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28969 }
28970 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28971 {
28972 PyThreadState* __tstate = wxPyBeginAllowThreads();
28973 delete arg1;
28974
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 resultobj = SWIG_Py_Void();
28979 return resultobj;
28980 fail:
28981 return NULL;
28982 }
28983
28984
28985 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28986 PyObject *obj;
28987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28988 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28989 return SWIG_Py_Void();
28990 }
28991
28992 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28993 return SWIG_Python_InitShadowInstance(args);
28994 }
28995
28996 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28997 PyObject *resultobj = 0;
28998 int arg1 = (int) 0 ;
28999 int arg2 = (int) 0 ;
29000 int arg3 = (int) 0 ;
29001 wxAcceleratorEntry *result = 0 ;
29002 int val1 ;
29003 int ecode1 = 0 ;
29004 int val2 ;
29005 int ecode2 = 0 ;
29006 int val3 ;
29007 int ecode3 = 0 ;
29008 PyObject * obj0 = 0 ;
29009 PyObject * obj1 = 0 ;
29010 PyObject * obj2 = 0 ;
29011 char * kwnames[] = {
29012 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29013 };
29014
29015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29016 if (obj0) {
29017 ecode1 = SWIG_AsVal_int(obj0, &val1);
29018 if (!SWIG_IsOK(ecode1)) {
29019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29020 }
29021 arg1 = static_cast< int >(val1);
29022 }
29023 if (obj1) {
29024 ecode2 = SWIG_AsVal_int(obj1, &val2);
29025 if (!SWIG_IsOK(ecode2)) {
29026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29027 }
29028 arg2 = static_cast< int >(val2);
29029 }
29030 if (obj2) {
29031 ecode3 = SWIG_AsVal_int(obj2, &val3);
29032 if (!SWIG_IsOK(ecode3)) {
29033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29034 }
29035 arg3 = static_cast< int >(val3);
29036 }
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 PyObject *resultobj = 0;
29052 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29053 void *argp1 = 0 ;
29054 int res1 = 0 ;
29055 PyObject *swig_obj[1] ;
29056
29057 if (!args) SWIG_fail;
29058 swig_obj[0] = args;
29059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29060 if (!SWIG_IsOK(res1)) {
29061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29062 }
29063 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29064 {
29065 PyThreadState* __tstate = wxPyBeginAllowThreads();
29066 delete arg1;
29067
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_Py_Void();
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj = 0;
29080 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29081 int arg2 ;
29082 int arg3 ;
29083 int arg4 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 int val2 ;
29087 int ecode2 = 0 ;
29088 int val3 ;
29089 int ecode3 = 0 ;
29090 int val4 ;
29091 int ecode4 = 0 ;
29092 PyObject * obj0 = 0 ;
29093 PyObject * obj1 = 0 ;
29094 PyObject * obj2 = 0 ;
29095 PyObject * obj3 = 0 ;
29096 char * kwnames[] = {
29097 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29098 };
29099
29100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29102 if (!SWIG_IsOK(res1)) {
29103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29104 }
29105 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29106 ecode2 = SWIG_AsVal_int(obj1, &val2);
29107 if (!SWIG_IsOK(ecode2)) {
29108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29109 }
29110 arg2 = static_cast< int >(val2);
29111 ecode3 = SWIG_AsVal_int(obj2, &val3);
29112 if (!SWIG_IsOK(ecode3)) {
29113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29114 }
29115 arg3 = static_cast< int >(val3);
29116 ecode4 = SWIG_AsVal_int(obj3, &val4);
29117 if (!SWIG_IsOK(ecode4)) {
29118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29119 }
29120 arg4 = static_cast< int >(val4);
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 (arg1)->Set(arg2,arg3,arg4);
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 resultobj = SWIG_Py_Void();
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29135 PyObject *resultobj = 0;
29136 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29137 int result;
29138 void *argp1 = 0 ;
29139 int res1 = 0 ;
29140 PyObject *swig_obj[1] ;
29141
29142 if (!args) SWIG_fail;
29143 swig_obj[0] = args;
29144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29145 if (!SWIG_IsOK(res1)) {
29146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29147 }
29148 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 result = (int)(arg1)->GetFlags();
29152 wxPyEndAllowThreads(__tstate);
29153 if (PyErr_Occurred()) SWIG_fail;
29154 }
29155 resultobj = SWIG_From_int(static_cast< int >(result));
29156 return resultobj;
29157 fail:
29158 return NULL;
29159 }
29160
29161
29162 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29163 PyObject *resultobj = 0;
29164 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29165 int result;
29166 void *argp1 = 0 ;
29167 int res1 = 0 ;
29168 PyObject *swig_obj[1] ;
29169
29170 if (!args) SWIG_fail;
29171 swig_obj[0] = args;
29172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29173 if (!SWIG_IsOK(res1)) {
29174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29175 }
29176 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (int)(arg1)->GetKeyCode();
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 resultobj = SWIG_From_int(static_cast< int >(result));
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191 PyObject *resultobj = 0;
29192 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29193 int result;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 PyObject *swig_obj[1] ;
29197
29198 if (!args) SWIG_fail;
29199 swig_obj[0] = args;
29200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29201 if (!SWIG_IsOK(res1)) {
29202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29203 }
29204 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = (int)(arg1)->GetCommand();
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_From_int(static_cast< int >(result));
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29219 PyObject *obj;
29220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29221 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29222 return SWIG_Py_Void();
29223 }
29224
29225 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29226 return SWIG_Python_InitShadowInstance(args);
29227 }
29228
29229 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29230 PyObject *resultobj = 0;
29231 int arg1 ;
29232 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29233 wxAcceleratorTable *result = 0 ;
29234 PyObject * obj0 = 0 ;
29235 char * kwnames[] = {
29236 (char *) "n", NULL
29237 };
29238
29239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29240 {
29241 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29242 if (arg2) arg1 = PyList_Size(obj0);
29243 else arg1 = 0;
29244 }
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 PyObject *resultobj = 0;
29260 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29261 void *argp1 = 0 ;
29262 int res1 = 0 ;
29263 PyObject *swig_obj[1] ;
29264
29265 if (!args) SWIG_fail;
29266 swig_obj[0] = args;
29267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29268 if (!SWIG_IsOK(res1)) {
29269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29270 }
29271 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29272 {
29273 PyThreadState* __tstate = wxPyBeginAllowThreads();
29274 delete arg1;
29275
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_Py_Void();
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29287 PyObject *resultobj = 0;
29288 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29289 bool result;
29290 void *argp1 = 0 ;
29291 int res1 = 0 ;
29292 PyObject *swig_obj[1] ;
29293
29294 if (!args) SWIG_fail;
29295 swig_obj[0] = args;
29296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29297 if (!SWIG_IsOK(res1)) {
29298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29299 }
29300 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 {
29308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29309 }
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29317 PyObject *obj;
29318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29319 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29320 return SWIG_Py_Void();
29321 }
29322
29323 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29324 return SWIG_Python_InitShadowInstance(args);
29325 }
29326
29327 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29328 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29329 return 1;
29330 }
29331
29332
29333 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29334 PyObject *pyobj = 0;
29335
29336 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29337 return pyobj;
29338 }
29339
29340
29341 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29342 PyObject *resultobj = 0;
29343 wxString *arg1 = 0 ;
29344 wxAcceleratorEntry *result = 0 ;
29345 bool temp1 = false ;
29346 PyObject * obj0 = 0 ;
29347 char * kwnames[] = {
29348 (char *) "label", NULL
29349 };
29350
29351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29352 {
29353 arg1 = wxString_in_helper(obj0);
29354 if (arg1 == NULL) SWIG_fail;
29355 temp1 = true;
29356 }
29357 {
29358 PyThreadState* __tstate = wxPyBeginAllowThreads();
29359 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29360 wxPyEndAllowThreads(__tstate);
29361 if (PyErr_Occurred()) SWIG_fail;
29362 }
29363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29364 {
29365 if (temp1)
29366 delete arg1;
29367 }
29368 return resultobj;
29369 fail:
29370 {
29371 if (temp1)
29372 delete arg1;
29373 }
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN int PanelNameStr_set(PyObject *) {
29379 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29380 return 1;
29381 }
29382
29383
29384 SWIGINTERN PyObject *PanelNameStr_get(void) {
29385 PyObject *pyobj = 0;
29386
29387 {
29388 #if wxUSE_UNICODE
29389 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29390 #else
29391 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29392 #endif
29393 }
29394 return pyobj;
29395 }
29396
29397
29398 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29399 PyObject *resultobj = 0;
29400 wxVisualAttributes *result = 0 ;
29401
29402 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 result = (wxVisualAttributes *)new_wxVisualAttributes();
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29428 }
29429 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 delete_wxVisualAttributes(arg1);
29433
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 resultobj = SWIG_Py_Void();
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29445 PyObject *resultobj = 0;
29446 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29447 wxFont *arg2 = (wxFont *) 0 ;
29448 void *argp1 = 0 ;
29449 int res1 = 0 ;
29450 void *argp2 = 0 ;
29451 int res2 = 0 ;
29452 PyObject *swig_obj[2] ;
29453
29454 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29456 if (!SWIG_IsOK(res1)) {
29457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29458 }
29459 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29460 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29461 if (!SWIG_IsOK(res2)) {
29462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29463 }
29464 arg2 = reinterpret_cast< wxFont * >(argp2);
29465 if (arg1) (arg1)->font = *arg2;
29466
29467 resultobj = SWIG_Py_Void();
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 PyObject *resultobj = 0;
29476 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29477 wxFont *result = 0 ;
29478 void *argp1 = 0 ;
29479 int res1 = 0 ;
29480 PyObject *swig_obj[1] ;
29481
29482 if (!args) SWIG_fail;
29483 swig_obj[0] = args;
29484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29485 if (!SWIG_IsOK(res1)) {
29486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29487 }
29488 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29489 result = (wxFont *)& ((arg1)->font);
29490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29491 return resultobj;
29492 fail:
29493 return NULL;
29494 }
29495
29496
29497 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29498 PyObject *resultobj = 0;
29499 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29500 wxColour *arg2 = (wxColour *) 0 ;
29501 void *argp1 = 0 ;
29502 int res1 = 0 ;
29503 void *argp2 = 0 ;
29504 int res2 = 0 ;
29505 PyObject *swig_obj[2] ;
29506
29507 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29509 if (!SWIG_IsOK(res1)) {
29510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29511 }
29512 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29513 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29514 if (!SWIG_IsOK(res2)) {
29515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29516 }
29517 arg2 = reinterpret_cast< wxColour * >(argp2);
29518 if (arg1) (arg1)->colFg = *arg2;
29519
29520 resultobj = SWIG_Py_Void();
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29528 PyObject *resultobj = 0;
29529 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29530 wxColour *result = 0 ;
29531 void *argp1 = 0 ;
29532 int res1 = 0 ;
29533 PyObject *swig_obj[1] ;
29534
29535 if (!args) SWIG_fail;
29536 swig_obj[0] = args;
29537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29538 if (!SWIG_IsOK(res1)) {
29539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29540 }
29541 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29542 result = (wxColour *)& ((arg1)->colFg);
29543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29544 return resultobj;
29545 fail:
29546 return NULL;
29547 }
29548
29549
29550 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29551 PyObject *resultobj = 0;
29552 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29553 wxColour *arg2 = (wxColour *) 0 ;
29554 void *argp1 = 0 ;
29555 int res1 = 0 ;
29556 void *argp2 = 0 ;
29557 int res2 = 0 ;
29558 PyObject *swig_obj[2] ;
29559
29560 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29562 if (!SWIG_IsOK(res1)) {
29563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29564 }
29565 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29566 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29567 if (!SWIG_IsOK(res2)) {
29568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29569 }
29570 arg2 = reinterpret_cast< wxColour * >(argp2);
29571 if (arg1) (arg1)->colBg = *arg2;
29572
29573 resultobj = SWIG_Py_Void();
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29581 PyObject *resultobj = 0;
29582 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29583 wxColour *result = 0 ;
29584 void *argp1 = 0 ;
29585 int res1 = 0 ;
29586 PyObject *swig_obj[1] ;
29587
29588 if (!args) SWIG_fail;
29589 swig_obj[0] = args;
29590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29591 if (!SWIG_IsOK(res1)) {
29592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29593 }
29594 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29595 result = (wxColour *)& ((arg1)->colBg);
29596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29597 return resultobj;
29598 fail:
29599 return NULL;
29600 }
29601
29602
29603 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29604 PyObject *obj;
29605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29606 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29607 return SWIG_Py_Void();
29608 }
29609
29610 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29611 return SWIG_Python_InitShadowInstance(args);
29612 }
29613
29614 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj = 0;
29616 wxWindow *arg1 = (wxWindow *) 0 ;
29617 int arg2 = (int) (int)-1 ;
29618 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29619 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29620 wxSize const &arg4_defvalue = wxDefaultSize ;
29621 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29622 long arg5 = (long) 0 ;
29623 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29624 wxString *arg6 = (wxString *) &arg6_defvalue ;
29625 wxWindow *result = 0 ;
29626 void *argp1 = 0 ;
29627 int res1 = 0 ;
29628 int val2 ;
29629 int ecode2 = 0 ;
29630 wxPoint temp3 ;
29631 wxSize temp4 ;
29632 long val5 ;
29633 int ecode5 = 0 ;
29634 bool temp6 = false ;
29635 PyObject * obj0 = 0 ;
29636 PyObject * obj1 = 0 ;
29637 PyObject * obj2 = 0 ;
29638 PyObject * obj3 = 0 ;
29639 PyObject * obj4 = 0 ;
29640 PyObject * obj5 = 0 ;
29641 char * kwnames[] = {
29642 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29643 };
29644
29645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29647 if (!SWIG_IsOK(res1)) {
29648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29649 }
29650 arg1 = reinterpret_cast< wxWindow * >(argp1);
29651 if (obj1) {
29652 ecode2 = SWIG_AsVal_int(obj1, &val2);
29653 if (!SWIG_IsOK(ecode2)) {
29654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29655 }
29656 arg2 = static_cast< int >(val2);
29657 }
29658 if (obj2) {
29659 {
29660 arg3 = &temp3;
29661 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29662 }
29663 }
29664 if (obj3) {
29665 {
29666 arg4 = &temp4;
29667 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29668 }
29669 }
29670 if (obj4) {
29671 ecode5 = SWIG_AsVal_long(obj4, &val5);
29672 if (!SWIG_IsOK(ecode5)) {
29673 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29674 }
29675 arg5 = static_cast< long >(val5);
29676 }
29677 if (obj5) {
29678 {
29679 arg6 = wxString_in_helper(obj5);
29680 if (arg6 == NULL) SWIG_fail;
29681 temp6 = true;
29682 }
29683 }
29684 {
29685 if (!wxPyCheckForApp()) SWIG_fail;
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29692 {
29693 if (temp6)
29694 delete arg6;
29695 }
29696 return resultobj;
29697 fail:
29698 {
29699 if (temp6)
29700 delete arg6;
29701 }
29702 return NULL;
29703 }
29704
29705
29706 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29707 PyObject *resultobj = 0;
29708 wxWindow *result = 0 ;
29709
29710 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29711 {
29712 if (!wxPyCheckForApp()) SWIG_fail;
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (wxWindow *)new wxWindow();
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29719 return resultobj;
29720 fail:
29721 return NULL;
29722 }
29723
29724
29725 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj = 0;
29727 wxWindow *arg1 = (wxWindow *) 0 ;
29728 wxWindow *arg2 = (wxWindow *) 0 ;
29729 int arg3 = (int) (int)-1 ;
29730 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29731 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29732 wxSize const &arg5_defvalue = wxDefaultSize ;
29733 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29734 long arg6 = (long) 0 ;
29735 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29736 wxString *arg7 = (wxString *) &arg7_defvalue ;
29737 bool result;
29738 void *argp1 = 0 ;
29739 int res1 = 0 ;
29740 void *argp2 = 0 ;
29741 int res2 = 0 ;
29742 int val3 ;
29743 int ecode3 = 0 ;
29744 wxPoint temp4 ;
29745 wxSize temp5 ;
29746 long val6 ;
29747 int ecode6 = 0 ;
29748 bool temp7 = false ;
29749 PyObject * obj0 = 0 ;
29750 PyObject * obj1 = 0 ;
29751 PyObject * obj2 = 0 ;
29752 PyObject * obj3 = 0 ;
29753 PyObject * obj4 = 0 ;
29754 PyObject * obj5 = 0 ;
29755 PyObject * obj6 = 0 ;
29756 char * kwnames[] = {
29757 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29758 };
29759
29760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29762 if (!SWIG_IsOK(res1)) {
29763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29764 }
29765 arg1 = reinterpret_cast< wxWindow * >(argp1);
29766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29767 if (!SWIG_IsOK(res2)) {
29768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29769 }
29770 arg2 = reinterpret_cast< wxWindow * >(argp2);
29771 if (obj2) {
29772 ecode3 = SWIG_AsVal_int(obj2, &val3);
29773 if (!SWIG_IsOK(ecode3)) {
29774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29775 }
29776 arg3 = static_cast< int >(val3);
29777 }
29778 if (obj3) {
29779 {
29780 arg4 = &temp4;
29781 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29782 }
29783 }
29784 if (obj4) {
29785 {
29786 arg5 = &temp5;
29787 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29788 }
29789 }
29790 if (obj5) {
29791 ecode6 = SWIG_AsVal_long(obj5, &val6);
29792 if (!SWIG_IsOK(ecode6)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29794 }
29795 arg6 = static_cast< long >(val6);
29796 }
29797 if (obj6) {
29798 {
29799 arg7 = wxString_in_helper(obj6);
29800 if (arg7 == NULL) SWIG_fail;
29801 temp7 = true;
29802 }
29803 }
29804 {
29805 PyThreadState* __tstate = wxPyBeginAllowThreads();
29806 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 {
29811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29812 }
29813 {
29814 if (temp7)
29815 delete arg7;
29816 }
29817 return resultobj;
29818 fail:
29819 {
29820 if (temp7)
29821 delete arg7;
29822 }
29823 return NULL;
29824 }
29825
29826
29827 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29828 PyObject *resultobj = 0;
29829 wxWindow *arg1 = (wxWindow *) 0 ;
29830 bool arg2 = (bool) false ;
29831 bool result;
29832 void *argp1 = 0 ;
29833 int res1 = 0 ;
29834 bool val2 ;
29835 int ecode2 = 0 ;
29836 PyObject * obj0 = 0 ;
29837 PyObject * obj1 = 0 ;
29838 char * kwnames[] = {
29839 (char *) "self",(char *) "force", NULL
29840 };
29841
29842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29846 }
29847 arg1 = reinterpret_cast< wxWindow * >(argp1);
29848 if (obj1) {
29849 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29850 if (!SWIG_IsOK(ecode2)) {
29851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29852 }
29853 arg2 = static_cast< bool >(val2);
29854 }
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 result = (bool)(arg1)->Close(arg2);
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 {
29862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29863 }
29864 return resultobj;
29865 fail:
29866 return NULL;
29867 }
29868
29869
29870 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29871 PyObject *resultobj = 0;
29872 wxWindow *arg1 = (wxWindow *) 0 ;
29873 bool result;
29874 void *argp1 = 0 ;
29875 int res1 = 0 ;
29876 PyObject *swig_obj[1] ;
29877
29878 if (!args) SWIG_fail;
29879 swig_obj[0] = args;
29880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29881 if (!SWIG_IsOK(res1)) {
29882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29883 }
29884 arg1 = reinterpret_cast< wxWindow * >(argp1);
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 result = (bool)(arg1)->Destroy();
29888 wxPyEndAllowThreads(__tstate);
29889 if (PyErr_Occurred()) SWIG_fail;
29890 }
29891 {
29892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29893 }
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29901 PyObject *resultobj = 0;
29902 wxWindow *arg1 = (wxWindow *) 0 ;
29903 bool result;
29904 void *argp1 = 0 ;
29905 int res1 = 0 ;
29906 PyObject *swig_obj[1] ;
29907
29908 if (!args) SWIG_fail;
29909 swig_obj[0] = args;
29910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29911 if (!SWIG_IsOK(res1)) {
29912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29913 }
29914 arg1 = reinterpret_cast< wxWindow * >(argp1);
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (bool)(arg1)->DestroyChildren();
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 {
29922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29923 }
29924 return resultobj;
29925 fail:
29926 return NULL;
29927 }
29928
29929
29930 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29931 PyObject *resultobj = 0;
29932 wxWindow *arg1 = (wxWindow *) 0 ;
29933 bool result;
29934 void *argp1 = 0 ;
29935 int res1 = 0 ;
29936 PyObject *swig_obj[1] ;
29937
29938 if (!args) SWIG_fail;
29939 swig_obj[0] = args;
29940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29941 if (!SWIG_IsOK(res1)) {
29942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29943 }
29944 arg1 = reinterpret_cast< wxWindow * >(argp1);
29945 {
29946 PyThreadState* __tstate = wxPyBeginAllowThreads();
29947 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29948 wxPyEndAllowThreads(__tstate);
29949 if (PyErr_Occurred()) SWIG_fail;
29950 }
29951 {
29952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29953 }
29954 return resultobj;
29955 fail:
29956 return NULL;
29957 }
29958
29959
29960 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29961 PyObject *resultobj = 0;
29962 wxWindow *arg1 = (wxWindow *) 0 ;
29963 wxString *arg2 = 0 ;
29964 void *argp1 = 0 ;
29965 int res1 = 0 ;
29966 bool temp2 = false ;
29967 PyObject * obj0 = 0 ;
29968 PyObject * obj1 = 0 ;
29969 char * kwnames[] = {
29970 (char *) "self",(char *) "label", NULL
29971 };
29972
29973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29975 if (!SWIG_IsOK(res1)) {
29976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29977 }
29978 arg1 = reinterpret_cast< wxWindow * >(argp1);
29979 {
29980 arg2 = wxString_in_helper(obj1);
29981 if (arg2 == NULL) SWIG_fail;
29982 temp2 = true;
29983 }
29984 {
29985 PyThreadState* __tstate = wxPyBeginAllowThreads();
29986 (arg1)->SetLabel((wxString const &)*arg2);
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 resultobj = SWIG_Py_Void();
29991 {
29992 if (temp2)
29993 delete arg2;
29994 }
29995 return resultobj;
29996 fail:
29997 {
29998 if (temp2)
29999 delete arg2;
30000 }
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30006 PyObject *resultobj = 0;
30007 wxWindow *arg1 = (wxWindow *) 0 ;
30008 wxString result;
30009 void *argp1 = 0 ;
30010 int res1 = 0 ;
30011 PyObject *swig_obj[1] ;
30012
30013 if (!args) SWIG_fail;
30014 swig_obj[0] = args;
30015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30016 if (!SWIG_IsOK(res1)) {
30017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30018 }
30019 arg1 = reinterpret_cast< wxWindow * >(argp1);
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = ((wxWindow const *)arg1)->GetLabel();
30023 wxPyEndAllowThreads(__tstate);
30024 if (PyErr_Occurred()) SWIG_fail;
30025 }
30026 {
30027 #if wxUSE_UNICODE
30028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30029 #else
30030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30031 #endif
30032 }
30033 return resultobj;
30034 fail:
30035 return NULL;
30036 }
30037
30038
30039 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30040 PyObject *resultobj = 0;
30041 wxWindow *arg1 = (wxWindow *) 0 ;
30042 wxString *arg2 = 0 ;
30043 void *argp1 = 0 ;
30044 int res1 = 0 ;
30045 bool temp2 = false ;
30046 PyObject * obj0 = 0 ;
30047 PyObject * obj1 = 0 ;
30048 char * kwnames[] = {
30049 (char *) "self",(char *) "name", NULL
30050 };
30051
30052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30056 }
30057 arg1 = reinterpret_cast< wxWindow * >(argp1);
30058 {
30059 arg2 = wxString_in_helper(obj1);
30060 if (arg2 == NULL) SWIG_fail;
30061 temp2 = true;
30062 }
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 (arg1)->SetName((wxString const &)*arg2);
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_Py_Void();
30070 {
30071 if (temp2)
30072 delete arg2;
30073 }
30074 return resultobj;
30075 fail:
30076 {
30077 if (temp2)
30078 delete arg2;
30079 }
30080 return NULL;
30081 }
30082
30083
30084 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30085 PyObject *resultobj = 0;
30086 wxWindow *arg1 = (wxWindow *) 0 ;
30087 wxString result;
30088 void *argp1 = 0 ;
30089 int res1 = 0 ;
30090 PyObject *swig_obj[1] ;
30091
30092 if (!args) SWIG_fail;
30093 swig_obj[0] = args;
30094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30095 if (!SWIG_IsOK(res1)) {
30096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30097 }
30098 arg1 = reinterpret_cast< wxWindow * >(argp1);
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 result = ((wxWindow const *)arg1)->GetName();
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 {
30106 #if wxUSE_UNICODE
30107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30108 #else
30109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30110 #endif
30111 }
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxWindowVariant arg2 ;
30122 void *argp1 = 0 ;
30123 int res1 = 0 ;
30124 int val2 ;
30125 int ecode2 = 0 ;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char * kwnames[] = {
30129 (char *) "self",(char *) "variant", NULL
30130 };
30131
30132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30134 if (!SWIG_IsOK(res1)) {
30135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30136 }
30137 arg1 = reinterpret_cast< wxWindow * >(argp1);
30138 ecode2 = SWIG_AsVal_int(obj1, &val2);
30139 if (!SWIG_IsOK(ecode2)) {
30140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30141 }
30142 arg2 = static_cast< wxWindowVariant >(val2);
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 (arg1)->SetWindowVariant(arg2);
30146 wxPyEndAllowThreads(__tstate);
30147 if (PyErr_Occurred()) SWIG_fail;
30148 }
30149 resultobj = SWIG_Py_Void();
30150 return resultobj;
30151 fail:
30152 return NULL;
30153 }
30154
30155
30156 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30157 PyObject *resultobj = 0;
30158 wxWindow *arg1 = (wxWindow *) 0 ;
30159 wxWindowVariant result;
30160 void *argp1 = 0 ;
30161 int res1 = 0 ;
30162 PyObject *swig_obj[1] ;
30163
30164 if (!args) SWIG_fail;
30165 swig_obj[0] = args;
30166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30167 if (!SWIG_IsOK(res1)) {
30168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30169 }
30170 arg1 = reinterpret_cast< wxWindow * >(argp1);
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 resultobj = SWIG_From_int(static_cast< int >(result));
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30185 PyObject *resultobj = 0;
30186 wxWindow *arg1 = (wxWindow *) 0 ;
30187 int arg2 ;
30188 void *argp1 = 0 ;
30189 int res1 = 0 ;
30190 int val2 ;
30191 int ecode2 = 0 ;
30192 PyObject * obj0 = 0 ;
30193 PyObject * obj1 = 0 ;
30194 char * kwnames[] = {
30195 (char *) "self",(char *) "winid", NULL
30196 };
30197
30198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30200 if (!SWIG_IsOK(res1)) {
30201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30202 }
30203 arg1 = reinterpret_cast< wxWindow * >(argp1);
30204 ecode2 = SWIG_AsVal_int(obj1, &val2);
30205 if (!SWIG_IsOK(ecode2)) {
30206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30207 }
30208 arg2 = static_cast< int >(val2);
30209 {
30210 PyThreadState* __tstate = wxPyBeginAllowThreads();
30211 (arg1)->SetId(arg2);
30212 wxPyEndAllowThreads(__tstate);
30213 if (PyErr_Occurred()) SWIG_fail;
30214 }
30215 resultobj = SWIG_Py_Void();
30216 return resultobj;
30217 fail:
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223 PyObject *resultobj = 0;
30224 wxWindow *arg1 = (wxWindow *) 0 ;
30225 int result;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 PyObject *swig_obj[1] ;
30229
30230 if (!args) SWIG_fail;
30231 swig_obj[0] = args;
30232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30233 if (!SWIG_IsOK(res1)) {
30234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30235 }
30236 arg1 = reinterpret_cast< wxWindow * >(argp1);
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 result = (int)((wxWindow const *)arg1)->GetId();
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 resultobj = SWIG_From_int(static_cast< int >(result));
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30251 PyObject *resultobj = 0;
30252 int result;
30253
30254 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (int)wxWindow::NewControlId();
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_From_int(static_cast< int >(result));
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 int arg1 ;
30271 int result;
30272 int val1 ;
30273 int ecode1 = 0 ;
30274 PyObject * obj0 = 0 ;
30275 char * kwnames[] = {
30276 (char *) "winid", NULL
30277 };
30278
30279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30280 ecode1 = SWIG_AsVal_int(obj0, &val1);
30281 if (!SWIG_IsOK(ecode1)) {
30282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30283 }
30284 arg1 = static_cast< int >(val1);
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = (int)wxWindow::NextControlId(arg1);
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 resultobj = SWIG_From_int(static_cast< int >(result));
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj = 0;
30300 int arg1 ;
30301 int result;
30302 int val1 ;
30303 int ecode1 = 0 ;
30304 PyObject * obj0 = 0 ;
30305 char * kwnames[] = {
30306 (char *) "winid", NULL
30307 };
30308
30309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30310 ecode1 = SWIG_AsVal_int(obj0, &val1);
30311 if (!SWIG_IsOK(ecode1)) {
30312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30313 }
30314 arg1 = static_cast< int >(val1);
30315 {
30316 PyThreadState* __tstate = wxPyBeginAllowThreads();
30317 result = (int)wxWindow::PrevControlId(arg1);
30318 wxPyEndAllowThreads(__tstate);
30319 if (PyErr_Occurred()) SWIG_fail;
30320 }
30321 resultobj = SWIG_From_int(static_cast< int >(result));
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30329 PyObject *resultobj = 0;
30330 wxWindow *arg1 = (wxWindow *) 0 ;
30331 wxSize *arg2 = 0 ;
30332 void *argp1 = 0 ;
30333 int res1 = 0 ;
30334 wxSize temp2 ;
30335 PyObject * obj0 = 0 ;
30336 PyObject * obj1 = 0 ;
30337 char * kwnames[] = {
30338 (char *) "self",(char *) "size", NULL
30339 };
30340
30341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30343 if (!SWIG_IsOK(res1)) {
30344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30345 }
30346 arg1 = reinterpret_cast< wxWindow * >(argp1);
30347 {
30348 arg2 = &temp2;
30349 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30350 }
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 (arg1)->SetSize((wxSize const &)*arg2);
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj = 0;
30366 wxWindow *arg1 = (wxWindow *) 0 ;
30367 int arg2 ;
30368 int arg3 ;
30369 int arg4 ;
30370 int arg5 ;
30371 int arg6 = (int) wxSIZE_AUTO ;
30372 void *argp1 = 0 ;
30373 int res1 = 0 ;
30374 int val2 ;
30375 int ecode2 = 0 ;
30376 int val3 ;
30377 int ecode3 = 0 ;
30378 int val4 ;
30379 int ecode4 = 0 ;
30380 int val5 ;
30381 int ecode5 = 0 ;
30382 int val6 ;
30383 int ecode6 = 0 ;
30384 PyObject * obj0 = 0 ;
30385 PyObject * obj1 = 0 ;
30386 PyObject * obj2 = 0 ;
30387 PyObject * obj3 = 0 ;
30388 PyObject * obj4 = 0 ;
30389 PyObject * obj5 = 0 ;
30390 char * kwnames[] = {
30391 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30392 };
30393
30394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30398 }
30399 arg1 = reinterpret_cast< wxWindow * >(argp1);
30400 ecode2 = SWIG_AsVal_int(obj1, &val2);
30401 if (!SWIG_IsOK(ecode2)) {
30402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30403 }
30404 arg2 = static_cast< int >(val2);
30405 ecode3 = SWIG_AsVal_int(obj2, &val3);
30406 if (!SWIG_IsOK(ecode3)) {
30407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30408 }
30409 arg3 = static_cast< int >(val3);
30410 ecode4 = SWIG_AsVal_int(obj3, &val4);
30411 if (!SWIG_IsOK(ecode4)) {
30412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30413 }
30414 arg4 = static_cast< int >(val4);
30415 ecode5 = SWIG_AsVal_int(obj4, &val5);
30416 if (!SWIG_IsOK(ecode5)) {
30417 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30418 }
30419 arg5 = static_cast< int >(val5);
30420 if (obj5) {
30421 ecode6 = SWIG_AsVal_int(obj5, &val6);
30422 if (!SWIG_IsOK(ecode6)) {
30423 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30424 }
30425 arg6 = static_cast< int >(val6);
30426 }
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_Py_Void();
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj = 0;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 wxRect *arg2 = 0 ;
30444 int arg3 = (int) wxSIZE_AUTO ;
30445 void *argp1 = 0 ;
30446 int res1 = 0 ;
30447 wxRect temp2 ;
30448 int val3 ;
30449 int ecode3 = 0 ;
30450 PyObject * obj0 = 0 ;
30451 PyObject * obj1 = 0 ;
30452 PyObject * obj2 = 0 ;
30453 char * kwnames[] = {
30454 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30455 };
30456
30457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30459 if (!SWIG_IsOK(res1)) {
30460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30461 }
30462 arg1 = reinterpret_cast< wxWindow * >(argp1);
30463 {
30464 arg2 = &temp2;
30465 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30466 }
30467 if (obj2) {
30468 ecode3 = SWIG_AsVal_int(obj2, &val3);
30469 if (!SWIG_IsOK(ecode3)) {
30470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30471 }
30472 arg3 = static_cast< int >(val3);
30473 }
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30477 wxPyEndAllowThreads(__tstate);
30478 if (PyErr_Occurred()) SWIG_fail;
30479 }
30480 resultobj = SWIG_Py_Void();
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj = 0;
30489 wxWindow *arg1 = (wxWindow *) 0 ;
30490 int arg2 ;
30491 int arg3 ;
30492 void *argp1 = 0 ;
30493 int res1 = 0 ;
30494 int val2 ;
30495 int ecode2 = 0 ;
30496 int val3 ;
30497 int ecode3 = 0 ;
30498 PyObject * obj0 = 0 ;
30499 PyObject * obj1 = 0 ;
30500 PyObject * obj2 = 0 ;
30501 char * kwnames[] = {
30502 (char *) "self",(char *) "width",(char *) "height", NULL
30503 };
30504
30505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30507 if (!SWIG_IsOK(res1)) {
30508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30509 }
30510 arg1 = reinterpret_cast< wxWindow * >(argp1);
30511 ecode2 = SWIG_AsVal_int(obj1, &val2);
30512 if (!SWIG_IsOK(ecode2)) {
30513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30514 }
30515 arg2 = static_cast< int >(val2);
30516 ecode3 = SWIG_AsVal_int(obj2, &val3);
30517 if (!SWIG_IsOK(ecode3)) {
30518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30519 }
30520 arg3 = static_cast< int >(val3);
30521 {
30522 PyThreadState* __tstate = wxPyBeginAllowThreads();
30523 (arg1)->SetSize(arg2,arg3);
30524 wxPyEndAllowThreads(__tstate);
30525 if (PyErr_Occurred()) SWIG_fail;
30526 }
30527 resultobj = SWIG_Py_Void();
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30535 PyObject *resultobj = 0;
30536 wxWindow *arg1 = (wxWindow *) 0 ;
30537 wxPoint *arg2 = 0 ;
30538 int arg3 = (int) wxSIZE_USE_EXISTING ;
30539 void *argp1 = 0 ;
30540 int res1 = 0 ;
30541 wxPoint temp2 ;
30542 int val3 ;
30543 int ecode3 = 0 ;
30544 PyObject * obj0 = 0 ;
30545 PyObject * obj1 = 0 ;
30546 PyObject * obj2 = 0 ;
30547 char * kwnames[] = {
30548 (char *) "self",(char *) "pt",(char *) "flags", NULL
30549 };
30550
30551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30553 if (!SWIG_IsOK(res1)) {
30554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30555 }
30556 arg1 = reinterpret_cast< wxWindow * >(argp1);
30557 {
30558 arg2 = &temp2;
30559 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30560 }
30561 if (obj2) {
30562 ecode3 = SWIG_AsVal_int(obj2, &val3);
30563 if (!SWIG_IsOK(ecode3)) {
30564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30565 }
30566 arg3 = static_cast< int >(val3);
30567 }
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->Move((wxPoint const &)*arg2,arg3);
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30582 PyObject *resultobj = 0;
30583 wxWindow *arg1 = (wxWindow *) 0 ;
30584 int arg2 ;
30585 int arg3 ;
30586 int arg4 = (int) wxSIZE_USE_EXISTING ;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 int val2 ;
30590 int ecode2 = 0 ;
30591 int val3 ;
30592 int ecode3 = 0 ;
30593 int val4 ;
30594 int ecode4 = 0 ;
30595 PyObject * obj0 = 0 ;
30596 PyObject * obj1 = 0 ;
30597 PyObject * obj2 = 0 ;
30598 PyObject * obj3 = 0 ;
30599 char * kwnames[] = {
30600 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30601 };
30602
30603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30605 if (!SWIG_IsOK(res1)) {
30606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30607 }
30608 arg1 = reinterpret_cast< wxWindow * >(argp1);
30609 ecode2 = SWIG_AsVal_int(obj1, &val2);
30610 if (!SWIG_IsOK(ecode2)) {
30611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30612 }
30613 arg2 = static_cast< int >(val2);
30614 ecode3 = SWIG_AsVal_int(obj2, &val3);
30615 if (!SWIG_IsOK(ecode3)) {
30616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30617 }
30618 arg3 = static_cast< int >(val3);
30619 if (obj3) {
30620 ecode4 = SWIG_AsVal_int(obj3, &val4);
30621 if (!SWIG_IsOK(ecode4)) {
30622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30623 }
30624 arg4 = static_cast< int >(val4);
30625 }
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 (arg1)->Move(arg2,arg3,arg4);
30629 wxPyEndAllowThreads(__tstate);
30630 if (PyErr_Occurred()) SWIG_fail;
30631 }
30632 resultobj = SWIG_Py_Void();
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30640 PyObject *resultobj = 0;
30641 wxWindow *arg1 = (wxWindow *) 0 ;
30642 wxSize const &arg2_defvalue = wxDefaultSize ;
30643 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 wxSize temp2 ;
30647 PyObject * obj0 = 0 ;
30648 PyObject * obj1 = 0 ;
30649 char * kwnames[] = {
30650 (char *) "self",(char *) "size", NULL
30651 };
30652
30653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30657 }
30658 arg1 = reinterpret_cast< wxWindow * >(argp1);
30659 if (obj1) {
30660 {
30661 arg2 = &temp2;
30662 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30663 }
30664 }
30665 {
30666 PyThreadState* __tstate = wxPyBeginAllowThreads();
30667 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30668 wxPyEndAllowThreads(__tstate);
30669 if (PyErr_Occurred()) SWIG_fail;
30670 }
30671 resultobj = SWIG_Py_Void();
30672 return resultobj;
30673 fail:
30674 return NULL;
30675 }
30676
30677
30678 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30679 PyObject *resultobj = 0;
30680 wxWindow *arg1 = (wxWindow *) 0 ;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 PyObject *swig_obj[1] ;
30684
30685 if (!args) SWIG_fail;
30686 swig_obj[0] = args;
30687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res1)) {
30689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30690 }
30691 arg1 = reinterpret_cast< wxWindow * >(argp1);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 (arg1)->Raise();
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_Py_Void();
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 PyObject *swig_obj[1] ;
30711
30712 if (!args) SWIG_fail;
30713 swig_obj[0] = args;
30714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30715 if (!SWIG_IsOK(res1)) {
30716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30717 }
30718 arg1 = reinterpret_cast< wxWindow * >(argp1);
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 (arg1)->Lower();
30722 wxPyEndAllowThreads(__tstate);
30723 if (PyErr_Occurred()) SWIG_fail;
30724 }
30725 resultobj = SWIG_Py_Void();
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30733 PyObject *resultobj = 0;
30734 wxWindow *arg1 = (wxWindow *) 0 ;
30735 wxSize *arg2 = 0 ;
30736 void *argp1 = 0 ;
30737 int res1 = 0 ;
30738 wxSize temp2 ;
30739 PyObject * obj0 = 0 ;
30740 PyObject * obj1 = 0 ;
30741 char * kwnames[] = {
30742 (char *) "self",(char *) "size", NULL
30743 };
30744
30745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30747 if (!SWIG_IsOK(res1)) {
30748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30749 }
30750 arg1 = reinterpret_cast< wxWindow * >(argp1);
30751 {
30752 arg2 = &temp2;
30753 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30754 }
30755 {
30756 PyThreadState* __tstate = wxPyBeginAllowThreads();
30757 (arg1)->SetClientSize((wxSize const &)*arg2);
30758 wxPyEndAllowThreads(__tstate);
30759 if (PyErr_Occurred()) SWIG_fail;
30760 }
30761 resultobj = SWIG_Py_Void();
30762 return resultobj;
30763 fail:
30764 return NULL;
30765 }
30766
30767
30768 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30769 PyObject *resultobj = 0;
30770 wxWindow *arg1 = (wxWindow *) 0 ;
30771 int arg2 ;
30772 int arg3 ;
30773 void *argp1 = 0 ;
30774 int res1 = 0 ;
30775 int val2 ;
30776 int ecode2 = 0 ;
30777 int val3 ;
30778 int ecode3 = 0 ;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 PyObject * obj2 = 0 ;
30782 char * kwnames[] = {
30783 (char *) "self",(char *) "width",(char *) "height", NULL
30784 };
30785
30786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30788 if (!SWIG_IsOK(res1)) {
30789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30790 }
30791 arg1 = reinterpret_cast< wxWindow * >(argp1);
30792 ecode2 = SWIG_AsVal_int(obj1, &val2);
30793 if (!SWIG_IsOK(ecode2)) {
30794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30795 }
30796 arg2 = static_cast< int >(val2);
30797 ecode3 = SWIG_AsVal_int(obj2, &val3);
30798 if (!SWIG_IsOK(ecode3)) {
30799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30800 }
30801 arg3 = static_cast< int >(val3);
30802 {
30803 PyThreadState* __tstate = wxPyBeginAllowThreads();
30804 (arg1)->SetClientSize(arg2,arg3);
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 resultobj = SWIG_Py_Void();
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj = 0;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 wxRect *arg2 = 0 ;
30819 void *argp1 = 0 ;
30820 int res1 = 0 ;
30821 wxRect temp2 ;
30822 PyObject * obj0 = 0 ;
30823 PyObject * obj1 = 0 ;
30824 char * kwnames[] = {
30825 (char *) "self",(char *) "rect", NULL
30826 };
30827
30828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30832 }
30833 arg1 = reinterpret_cast< wxWindow * >(argp1);
30834 {
30835 arg2 = &temp2;
30836 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30837 }
30838 {
30839 PyThreadState* __tstate = wxPyBeginAllowThreads();
30840 (arg1)->SetClientSize((wxRect const &)*arg2);
30841 wxPyEndAllowThreads(__tstate);
30842 if (PyErr_Occurred()) SWIG_fail;
30843 }
30844 resultobj = SWIG_Py_Void();
30845 return resultobj;
30846 fail:
30847 return NULL;
30848 }
30849
30850
30851 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30852 PyObject *resultobj = 0;
30853 wxWindow *arg1 = (wxWindow *) 0 ;
30854 wxPoint result;
30855 void *argp1 = 0 ;
30856 int res1 = 0 ;
30857 PyObject *swig_obj[1] ;
30858
30859 if (!args) SWIG_fail;
30860 swig_obj[0] = args;
30861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30862 if (!SWIG_IsOK(res1)) {
30863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30864 }
30865 arg1 = reinterpret_cast< wxWindow * >(argp1);
30866 {
30867 PyThreadState* __tstate = wxPyBeginAllowThreads();
30868 result = ((wxWindow const *)arg1)->GetPosition();
30869 wxPyEndAllowThreads(__tstate);
30870 if (PyErr_Occurred()) SWIG_fail;
30871 }
30872 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30880 PyObject *resultobj = 0;
30881 wxWindow *arg1 = (wxWindow *) 0 ;
30882 int *arg2 = (int *) 0 ;
30883 int *arg3 = (int *) 0 ;
30884 void *argp1 = 0 ;
30885 int res1 = 0 ;
30886 int temp2 ;
30887 int res2 = SWIG_TMPOBJ ;
30888 int temp3 ;
30889 int res3 = SWIG_TMPOBJ ;
30890 PyObject *swig_obj[1] ;
30891
30892 arg2 = &temp2;
30893 arg3 = &temp3;
30894 if (!args) SWIG_fail;
30895 swig_obj[0] = args;
30896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30897 if (!SWIG_IsOK(res1)) {
30898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30899 }
30900 arg1 = reinterpret_cast< wxWindow * >(argp1);
30901 {
30902 PyThreadState* __tstate = wxPyBeginAllowThreads();
30903 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30904 wxPyEndAllowThreads(__tstate);
30905 if (PyErr_Occurred()) SWIG_fail;
30906 }
30907 resultobj = SWIG_Py_Void();
30908 if (SWIG_IsTmpObj(res2)) {
30909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30910 } else {
30911 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30913 }
30914 if (SWIG_IsTmpObj(res3)) {
30915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30916 } else {
30917 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30919 }
30920 return resultobj;
30921 fail:
30922 return NULL;
30923 }
30924
30925
30926 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30927 PyObject *resultobj = 0;
30928 wxWindow *arg1 = (wxWindow *) 0 ;
30929 wxPoint result;
30930 void *argp1 = 0 ;
30931 int res1 = 0 ;
30932 PyObject *swig_obj[1] ;
30933
30934 if (!args) SWIG_fail;
30935 swig_obj[0] = args;
30936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30937 if (!SWIG_IsOK(res1)) {
30938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30939 }
30940 arg1 = reinterpret_cast< wxWindow * >(argp1);
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 result = ((wxWindow const *)arg1)->GetScreenPosition();
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30948 return resultobj;
30949 fail:
30950 return NULL;
30951 }
30952
30953
30954 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30955 PyObject *resultobj = 0;
30956 wxWindow *arg1 = (wxWindow *) 0 ;
30957 int *arg2 = (int *) 0 ;
30958 int *arg3 = (int *) 0 ;
30959 void *argp1 = 0 ;
30960 int res1 = 0 ;
30961 int temp2 ;
30962 int res2 = SWIG_TMPOBJ ;
30963 int temp3 ;
30964 int res3 = SWIG_TMPOBJ ;
30965 PyObject *swig_obj[1] ;
30966
30967 arg2 = &temp2;
30968 arg3 = &temp3;
30969 if (!args) SWIG_fail;
30970 swig_obj[0] = args;
30971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30972 if (!SWIG_IsOK(res1)) {
30973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30974 }
30975 arg1 = reinterpret_cast< wxWindow * >(argp1);
30976 {
30977 PyThreadState* __tstate = wxPyBeginAllowThreads();
30978 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30979 wxPyEndAllowThreads(__tstate);
30980 if (PyErr_Occurred()) SWIG_fail;
30981 }
30982 resultobj = SWIG_Py_Void();
30983 if (SWIG_IsTmpObj(res2)) {
30984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30985 } else {
30986 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30988 }
30989 if (SWIG_IsTmpObj(res3)) {
30990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30991 } else {
30992 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30994 }
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31002 PyObject *resultobj = 0;
31003 wxWindow *arg1 = (wxWindow *) 0 ;
31004 wxRect result;
31005 void *argp1 = 0 ;
31006 int res1 = 0 ;
31007 PyObject *swig_obj[1] ;
31008
31009 if (!args) SWIG_fail;
31010 swig_obj[0] = args;
31011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31012 if (!SWIG_IsOK(res1)) {
31013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31014 }
31015 arg1 = reinterpret_cast< wxWindow * >(argp1);
31016 {
31017 PyThreadState* __tstate = wxPyBeginAllowThreads();
31018 result = ((wxWindow const *)arg1)->GetScreenRect();
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31030 PyObject *resultobj = 0;
31031 wxWindow *arg1 = (wxWindow *) 0 ;
31032 wxSize result;
31033 void *argp1 = 0 ;
31034 int res1 = 0 ;
31035 PyObject *swig_obj[1] ;
31036
31037 if (!args) SWIG_fail;
31038 swig_obj[0] = args;
31039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31042 }
31043 arg1 = reinterpret_cast< wxWindow * >(argp1);
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 result = ((wxWindow const *)arg1)->GetSize();
31047 wxPyEndAllowThreads(__tstate);
31048 if (PyErr_Occurred()) SWIG_fail;
31049 }
31050 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31051 return resultobj;
31052 fail:
31053 return NULL;
31054 }
31055
31056
31057 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31058 PyObject *resultobj = 0;
31059 wxWindow *arg1 = (wxWindow *) 0 ;
31060 int *arg2 = (int *) 0 ;
31061 int *arg3 = (int *) 0 ;
31062 void *argp1 = 0 ;
31063 int res1 = 0 ;
31064 int temp2 ;
31065 int res2 = SWIG_TMPOBJ ;
31066 int temp3 ;
31067 int res3 = SWIG_TMPOBJ ;
31068 PyObject *swig_obj[1] ;
31069
31070 arg2 = &temp2;
31071 arg3 = &temp3;
31072 if (!args) SWIG_fail;
31073 swig_obj[0] = args;
31074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31075 if (!SWIG_IsOK(res1)) {
31076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31077 }
31078 arg1 = reinterpret_cast< wxWindow * >(argp1);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 resultobj = SWIG_Py_Void();
31086 if (SWIG_IsTmpObj(res2)) {
31087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31088 } else {
31089 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31091 }
31092 if (SWIG_IsTmpObj(res3)) {
31093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31094 } else {
31095 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31097 }
31098 return resultobj;
31099 fail:
31100 return NULL;
31101 }
31102
31103
31104 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31105 PyObject *resultobj = 0;
31106 wxWindow *arg1 = (wxWindow *) 0 ;
31107 wxRect result;
31108 void *argp1 = 0 ;
31109 int res1 = 0 ;
31110 PyObject *swig_obj[1] ;
31111
31112 if (!args) SWIG_fail;
31113 swig_obj[0] = args;
31114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31117 }
31118 arg1 = reinterpret_cast< wxWindow * >(argp1);
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 result = ((wxWindow const *)arg1)->GetRect();
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31126 return resultobj;
31127 fail:
31128 return NULL;
31129 }
31130
31131
31132 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31133 PyObject *resultobj = 0;
31134 wxWindow *arg1 = (wxWindow *) 0 ;
31135 wxSize result;
31136 void *argp1 = 0 ;
31137 int res1 = 0 ;
31138 PyObject *swig_obj[1] ;
31139
31140 if (!args) SWIG_fail;
31141 swig_obj[0] = args;
31142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31143 if (!SWIG_IsOK(res1)) {
31144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31145 }
31146 arg1 = reinterpret_cast< wxWindow * >(argp1);
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = ((wxWindow const *)arg1)->GetClientSize();
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31161 PyObject *resultobj = 0;
31162 wxWindow *arg1 = (wxWindow *) 0 ;
31163 int *arg2 = (int *) 0 ;
31164 int *arg3 = (int *) 0 ;
31165 void *argp1 = 0 ;
31166 int res1 = 0 ;
31167 int temp2 ;
31168 int res2 = SWIG_TMPOBJ ;
31169 int temp3 ;
31170 int res3 = SWIG_TMPOBJ ;
31171 PyObject *swig_obj[1] ;
31172
31173 arg2 = &temp2;
31174 arg3 = &temp3;
31175 if (!args) SWIG_fail;
31176 swig_obj[0] = args;
31177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31178 if (!SWIG_IsOK(res1)) {
31179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31180 }
31181 arg1 = reinterpret_cast< wxWindow * >(argp1);
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 resultobj = SWIG_Py_Void();
31189 if (SWIG_IsTmpObj(res2)) {
31190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31191 } else {
31192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31194 }
31195 if (SWIG_IsTmpObj(res3)) {
31196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31197 } else {
31198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31200 }
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31208 PyObject *resultobj = 0;
31209 wxWindow *arg1 = (wxWindow *) 0 ;
31210 wxPoint result;
31211 void *argp1 = 0 ;
31212 int res1 = 0 ;
31213 PyObject *swig_obj[1] ;
31214
31215 if (!args) SWIG_fail;
31216 swig_obj[0] = args;
31217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31220 }
31221 arg1 = reinterpret_cast< wxWindow * >(argp1);
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31229 return resultobj;
31230 fail:
31231 return NULL;
31232 }
31233
31234
31235 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31236 PyObject *resultobj = 0;
31237 wxWindow *arg1 = (wxWindow *) 0 ;
31238 wxRect result;
31239 void *argp1 = 0 ;
31240 int res1 = 0 ;
31241 PyObject *swig_obj[1] ;
31242
31243 if (!args) SWIG_fail;
31244 swig_obj[0] = args;
31245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31246 if (!SWIG_IsOK(res1)) {
31247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31248 }
31249 arg1 = reinterpret_cast< wxWindow * >(argp1);
31250 {
31251 PyThreadState* __tstate = wxPyBeginAllowThreads();
31252 result = ((wxWindow const *)arg1)->GetClientRect();
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31264 PyObject *resultobj = 0;
31265 wxWindow *arg1 = (wxWindow *) 0 ;
31266 wxSize result;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 PyObject *swig_obj[1] ;
31270
31271 if (!args) SWIG_fail;
31272 swig_obj[0] = args;
31273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31274 if (!SWIG_IsOK(res1)) {
31275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31276 }
31277 arg1 = reinterpret_cast< wxWindow * >(argp1);
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = ((wxWindow const *)arg1)->GetBestSize();
31281 wxPyEndAllowThreads(__tstate);
31282 if (PyErr_Occurred()) SWIG_fail;
31283 }
31284 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31285 return resultobj;
31286 fail:
31287 return NULL;
31288 }
31289
31290
31291 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31292 PyObject *resultobj = 0;
31293 wxWindow *arg1 = (wxWindow *) 0 ;
31294 int *arg2 = (int *) 0 ;
31295 int *arg3 = (int *) 0 ;
31296 void *argp1 = 0 ;
31297 int res1 = 0 ;
31298 int temp2 ;
31299 int res2 = SWIG_TMPOBJ ;
31300 int temp3 ;
31301 int res3 = SWIG_TMPOBJ ;
31302 PyObject *swig_obj[1] ;
31303
31304 arg2 = &temp2;
31305 arg3 = &temp3;
31306 if (!args) SWIG_fail;
31307 swig_obj[0] = args;
31308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31309 if (!SWIG_IsOK(res1)) {
31310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31311 }
31312 arg1 = reinterpret_cast< wxWindow * >(argp1);
31313 {
31314 PyThreadState* __tstate = wxPyBeginAllowThreads();
31315 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31316 wxPyEndAllowThreads(__tstate);
31317 if (PyErr_Occurred()) SWIG_fail;
31318 }
31319 resultobj = SWIG_Py_Void();
31320 if (SWIG_IsTmpObj(res2)) {
31321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31322 } else {
31323 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31325 }
31326 if (SWIG_IsTmpObj(res3)) {
31327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31328 } else {
31329 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31331 }
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31339 PyObject *resultobj = 0;
31340 wxWindow *arg1 = (wxWindow *) 0 ;
31341 void *argp1 = 0 ;
31342 int res1 = 0 ;
31343 PyObject *swig_obj[1] ;
31344
31345 if (!args) SWIG_fail;
31346 swig_obj[0] = args;
31347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31348 if (!SWIG_IsOK(res1)) {
31349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31350 }
31351 arg1 = reinterpret_cast< wxWindow * >(argp1);
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 (arg1)->InvalidateBestSize();
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 resultobj = SWIG_Py_Void();
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31366 PyObject *resultobj = 0;
31367 wxWindow *arg1 = (wxWindow *) 0 ;
31368 wxSize *arg2 = 0 ;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 wxSize temp2 ;
31372 PyObject * obj0 = 0 ;
31373 PyObject * obj1 = 0 ;
31374 char * kwnames[] = {
31375 (char *) "self",(char *) "size", NULL
31376 };
31377
31378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31380 if (!SWIG_IsOK(res1)) {
31381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31382 }
31383 arg1 = reinterpret_cast< wxWindow * >(argp1);
31384 {
31385 arg2 = &temp2;
31386 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31387 }
31388 {
31389 PyThreadState* __tstate = wxPyBeginAllowThreads();
31390 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 resultobj = SWIG_Py_Void();
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31402 PyObject *resultobj = 0;
31403 wxWindow *arg1 = (wxWindow *) 0 ;
31404 wxSize result;
31405 void *argp1 = 0 ;
31406 int res1 = 0 ;
31407 PyObject *swig_obj[1] ;
31408
31409 if (!args) SWIG_fail;
31410 swig_obj[0] = args;
31411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31412 if (!SWIG_IsOK(res1)) {
31413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31414 }
31415 arg1 = reinterpret_cast< wxWindow * >(argp1);
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31423 return resultobj;
31424 fail:
31425 return NULL;
31426 }
31427
31428
31429 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31430 PyObject *resultobj = 0;
31431 wxWindow *arg1 = (wxWindow *) 0 ;
31432 wxSize result;
31433 void *argp1 = 0 ;
31434 int res1 = 0 ;
31435 PyObject *swig_obj[1] ;
31436
31437 if (!args) SWIG_fail;
31438 swig_obj[0] = args;
31439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31440 if (!SWIG_IsOK(res1)) {
31441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31442 }
31443 arg1 = reinterpret_cast< wxWindow * >(argp1);
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31458 PyObject *resultobj = 0;
31459 wxWindow *arg1 = (wxWindow *) 0 ;
31460 int arg2 = (int) wxBOTH ;
31461 void *argp1 = 0 ;
31462 int res1 = 0 ;
31463 int val2 ;
31464 int ecode2 = 0 ;
31465 PyObject * obj0 = 0 ;
31466 PyObject * obj1 = 0 ;
31467 char * kwnames[] = {
31468 (char *) "self",(char *) "direction", NULL
31469 };
31470
31471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31473 if (!SWIG_IsOK(res1)) {
31474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31475 }
31476 arg1 = reinterpret_cast< wxWindow * >(argp1);
31477 if (obj1) {
31478 ecode2 = SWIG_AsVal_int(obj1, &val2);
31479 if (!SWIG_IsOK(ecode2)) {
31480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31481 }
31482 arg2 = static_cast< int >(val2);
31483 }
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 (arg1)->Center(arg2);
31487 wxPyEndAllowThreads(__tstate);
31488 if (PyErr_Occurred()) SWIG_fail;
31489 }
31490 resultobj = SWIG_Py_Void();
31491 return resultobj;
31492 fail:
31493 return NULL;
31494 }
31495
31496
31497 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31498 PyObject *resultobj = 0;
31499 wxWindow *arg1 = (wxWindow *) 0 ;
31500 int arg2 = (int) wxBOTH ;
31501 void *argp1 = 0 ;
31502 int res1 = 0 ;
31503 int val2 ;
31504 int ecode2 = 0 ;
31505 PyObject * obj0 = 0 ;
31506 PyObject * obj1 = 0 ;
31507 char * kwnames[] = {
31508 (char *) "self",(char *) "dir", NULL
31509 };
31510
31511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31513 if (!SWIG_IsOK(res1)) {
31514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31515 }
31516 arg1 = reinterpret_cast< wxWindow * >(argp1);
31517 if (obj1) {
31518 ecode2 = SWIG_AsVal_int(obj1, &val2);
31519 if (!SWIG_IsOK(ecode2)) {
31520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31521 }
31522 arg2 = static_cast< int >(val2);
31523 }
31524 {
31525 PyThreadState* __tstate = wxPyBeginAllowThreads();
31526 (arg1)->CenterOnParent(arg2);
31527 wxPyEndAllowThreads(__tstate);
31528 if (PyErr_Occurred()) SWIG_fail;
31529 }
31530 resultobj = SWIG_Py_Void();
31531 return resultobj;
31532 fail:
31533 return NULL;
31534 }
31535
31536
31537 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31538 PyObject *resultobj = 0;
31539 wxWindow *arg1 = (wxWindow *) 0 ;
31540 void *argp1 = 0 ;
31541 int res1 = 0 ;
31542 PyObject *swig_obj[1] ;
31543
31544 if (!args) SWIG_fail;
31545 swig_obj[0] = args;
31546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31547 if (!SWIG_IsOK(res1)) {
31548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31549 }
31550 arg1 = reinterpret_cast< wxWindow * >(argp1);
31551 {
31552 PyThreadState* __tstate = wxPyBeginAllowThreads();
31553 (arg1)->Fit();
31554 wxPyEndAllowThreads(__tstate);
31555 if (PyErr_Occurred()) SWIG_fail;
31556 }
31557 resultobj = SWIG_Py_Void();
31558 return resultobj;
31559 fail:
31560 return NULL;
31561 }
31562
31563
31564 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31565 PyObject *resultobj = 0;
31566 wxWindow *arg1 = (wxWindow *) 0 ;
31567 void *argp1 = 0 ;
31568 int res1 = 0 ;
31569 PyObject *swig_obj[1] ;
31570
31571 if (!args) SWIG_fail;
31572 swig_obj[0] = args;
31573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31574 if (!SWIG_IsOK(res1)) {
31575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31576 }
31577 arg1 = reinterpret_cast< wxWindow * >(argp1);
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 (arg1)->FitInside();
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 resultobj = SWIG_Py_Void();
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj = 0;
31593 wxWindow *arg1 = (wxWindow *) 0 ;
31594 int arg2 ;
31595 int arg3 ;
31596 int arg4 = (int) -1 ;
31597 int arg5 = (int) -1 ;
31598 int arg6 = (int) -1 ;
31599 int arg7 = (int) -1 ;
31600 void *argp1 = 0 ;
31601 int res1 = 0 ;
31602 int val2 ;
31603 int ecode2 = 0 ;
31604 int val3 ;
31605 int ecode3 = 0 ;
31606 int val4 ;
31607 int ecode4 = 0 ;
31608 int val5 ;
31609 int ecode5 = 0 ;
31610 int val6 ;
31611 int ecode6 = 0 ;
31612 int val7 ;
31613 int ecode7 = 0 ;
31614 PyObject * obj0 = 0 ;
31615 PyObject * obj1 = 0 ;
31616 PyObject * obj2 = 0 ;
31617 PyObject * obj3 = 0 ;
31618 PyObject * obj4 = 0 ;
31619 PyObject * obj5 = 0 ;
31620 PyObject * obj6 = 0 ;
31621 char * kwnames[] = {
31622 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31623 };
31624
31625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31627 if (!SWIG_IsOK(res1)) {
31628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31629 }
31630 arg1 = reinterpret_cast< wxWindow * >(argp1);
31631 ecode2 = SWIG_AsVal_int(obj1, &val2);
31632 if (!SWIG_IsOK(ecode2)) {
31633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31634 }
31635 arg2 = static_cast< int >(val2);
31636 ecode3 = SWIG_AsVal_int(obj2, &val3);
31637 if (!SWIG_IsOK(ecode3)) {
31638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31639 }
31640 arg3 = static_cast< int >(val3);
31641 if (obj3) {
31642 ecode4 = SWIG_AsVal_int(obj3, &val4);
31643 if (!SWIG_IsOK(ecode4)) {
31644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31645 }
31646 arg4 = static_cast< int >(val4);
31647 }
31648 if (obj4) {
31649 ecode5 = SWIG_AsVal_int(obj4, &val5);
31650 if (!SWIG_IsOK(ecode5)) {
31651 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31652 }
31653 arg5 = static_cast< int >(val5);
31654 }
31655 if (obj5) {
31656 ecode6 = SWIG_AsVal_int(obj5, &val6);
31657 if (!SWIG_IsOK(ecode6)) {
31658 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31659 }
31660 arg6 = static_cast< int >(val6);
31661 }
31662 if (obj6) {
31663 ecode7 = SWIG_AsVal_int(obj6, &val7);
31664 if (!SWIG_IsOK(ecode7)) {
31665 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31666 }
31667 arg7 = static_cast< int >(val7);
31668 }
31669 {
31670 PyThreadState* __tstate = wxPyBeginAllowThreads();
31671 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31672 wxPyEndAllowThreads(__tstate);
31673 if (PyErr_Occurred()) SWIG_fail;
31674 }
31675 resultobj = SWIG_Py_Void();
31676 return resultobj;
31677 fail:
31678 return NULL;
31679 }
31680
31681
31682 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31683 PyObject *resultobj = 0;
31684 wxWindow *arg1 = (wxWindow *) 0 ;
31685 wxSize *arg2 = 0 ;
31686 wxSize const &arg3_defvalue = wxDefaultSize ;
31687 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31688 wxSize const &arg4_defvalue = wxDefaultSize ;
31689 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 wxSize temp2 ;
31693 wxSize temp3 ;
31694 wxSize temp4 ;
31695 PyObject * obj0 = 0 ;
31696 PyObject * obj1 = 0 ;
31697 PyObject * obj2 = 0 ;
31698 PyObject * obj3 = 0 ;
31699 char * kwnames[] = {
31700 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31701 };
31702
31703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31705 if (!SWIG_IsOK(res1)) {
31706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31707 }
31708 arg1 = reinterpret_cast< wxWindow * >(argp1);
31709 {
31710 arg2 = &temp2;
31711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31712 }
31713 if (obj2) {
31714 {
31715 arg3 = &temp3;
31716 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31717 }
31718 }
31719 if (obj3) {
31720 {
31721 arg4 = &temp4;
31722 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31723 }
31724 }
31725 {
31726 PyThreadState* __tstate = wxPyBeginAllowThreads();
31727 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 resultobj = SWIG_Py_Void();
31732 return resultobj;
31733 fail:
31734 return NULL;
31735 }
31736
31737
31738 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31739 PyObject *resultobj = 0;
31740 wxWindow *arg1 = (wxWindow *) 0 ;
31741 int arg2 ;
31742 int arg3 ;
31743 int arg4 = (int) -1 ;
31744 int arg5 = (int) -1 ;
31745 void *argp1 = 0 ;
31746 int res1 = 0 ;
31747 int val2 ;
31748 int ecode2 = 0 ;
31749 int val3 ;
31750 int ecode3 = 0 ;
31751 int val4 ;
31752 int ecode4 = 0 ;
31753 int val5 ;
31754 int ecode5 = 0 ;
31755 PyObject * obj0 = 0 ;
31756 PyObject * obj1 = 0 ;
31757 PyObject * obj2 = 0 ;
31758 PyObject * obj3 = 0 ;
31759 PyObject * obj4 = 0 ;
31760 char * kwnames[] = {
31761 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31762 };
31763
31764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31766 if (!SWIG_IsOK(res1)) {
31767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31768 }
31769 arg1 = reinterpret_cast< wxWindow * >(argp1);
31770 ecode2 = SWIG_AsVal_int(obj1, &val2);
31771 if (!SWIG_IsOK(ecode2)) {
31772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31773 }
31774 arg2 = static_cast< int >(val2);
31775 ecode3 = SWIG_AsVal_int(obj2, &val3);
31776 if (!SWIG_IsOK(ecode3)) {
31777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31778 }
31779 arg3 = static_cast< int >(val3);
31780 if (obj3) {
31781 ecode4 = SWIG_AsVal_int(obj3, &val4);
31782 if (!SWIG_IsOK(ecode4)) {
31783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31784 }
31785 arg4 = static_cast< int >(val4);
31786 }
31787 if (obj4) {
31788 ecode5 = SWIG_AsVal_int(obj4, &val5);
31789 if (!SWIG_IsOK(ecode5)) {
31790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31791 }
31792 arg5 = static_cast< int >(val5);
31793 }
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_Py_Void();
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31808 PyObject *resultobj = 0;
31809 wxWindow *arg1 = (wxWindow *) 0 ;
31810 wxSize *arg2 = 0 ;
31811 wxSize const &arg3_defvalue = wxDefaultSize ;
31812 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31813 void *argp1 = 0 ;
31814 int res1 = 0 ;
31815 wxSize temp2 ;
31816 wxSize temp3 ;
31817 PyObject * obj0 = 0 ;
31818 PyObject * obj1 = 0 ;
31819 PyObject * obj2 = 0 ;
31820 char * kwnames[] = {
31821 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31822 };
31823
31824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31828 }
31829 arg1 = reinterpret_cast< wxWindow * >(argp1);
31830 {
31831 arg2 = &temp2;
31832 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31833 }
31834 if (obj2) {
31835 {
31836 arg3 = &temp3;
31837 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31838 }
31839 }
31840 {
31841 PyThreadState* __tstate = wxPyBeginAllowThreads();
31842 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31843 wxPyEndAllowThreads(__tstate);
31844 if (PyErr_Occurred()) SWIG_fail;
31845 }
31846 resultobj = SWIG_Py_Void();
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31854 PyObject *resultobj = 0;
31855 wxWindow *arg1 = (wxWindow *) 0 ;
31856 wxSize result;
31857 void *argp1 = 0 ;
31858 int res1 = 0 ;
31859 PyObject *swig_obj[1] ;
31860
31861 if (!args) SWIG_fail;
31862 swig_obj[0] = args;
31863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31866 }
31867 arg1 = reinterpret_cast< wxWindow * >(argp1);
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 result = ((wxWindow const *)arg1)->GetMaxSize();
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31882 PyObject *resultobj = 0;
31883 wxWindow *arg1 = (wxWindow *) 0 ;
31884 wxSize result;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 PyObject *swig_obj[1] ;
31888
31889 if (!args) SWIG_fail;
31890 swig_obj[0] = args;
31891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31892 if (!SWIG_IsOK(res1)) {
31893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31894 }
31895 arg1 = reinterpret_cast< wxWindow * >(argp1);
31896 {
31897 PyThreadState* __tstate = wxPyBeginAllowThreads();
31898 result = ((wxWindow const *)arg1)->GetMinSize();
31899 wxPyEndAllowThreads(__tstate);
31900 if (PyErr_Occurred()) SWIG_fail;
31901 }
31902 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31903 return resultobj;
31904 fail:
31905 return NULL;
31906 }
31907
31908
31909 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31910 PyObject *resultobj = 0;
31911 wxWindow *arg1 = (wxWindow *) 0 ;
31912 wxSize *arg2 = 0 ;
31913 void *argp1 = 0 ;
31914 int res1 = 0 ;
31915 wxSize temp2 ;
31916 PyObject * obj0 = 0 ;
31917 PyObject * obj1 = 0 ;
31918 char * kwnames[] = {
31919 (char *) "self",(char *) "minSize", NULL
31920 };
31921
31922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31924 if (!SWIG_IsOK(res1)) {
31925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31926 }
31927 arg1 = reinterpret_cast< wxWindow * >(argp1);
31928 {
31929 arg2 = &temp2;
31930 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31931 }
31932 {
31933 PyThreadState* __tstate = wxPyBeginAllowThreads();
31934 (arg1)->SetMinSize((wxSize const &)*arg2);
31935 wxPyEndAllowThreads(__tstate);
31936 if (PyErr_Occurred()) SWIG_fail;
31937 }
31938 resultobj = SWIG_Py_Void();
31939 return resultobj;
31940 fail:
31941 return NULL;
31942 }
31943
31944
31945 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31946 PyObject *resultobj = 0;
31947 wxWindow *arg1 = (wxWindow *) 0 ;
31948 wxSize *arg2 = 0 ;
31949 void *argp1 = 0 ;
31950 int res1 = 0 ;
31951 wxSize temp2 ;
31952 PyObject * obj0 = 0 ;
31953 PyObject * obj1 = 0 ;
31954 char * kwnames[] = {
31955 (char *) "self",(char *) "maxSize", NULL
31956 };
31957
31958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31962 }
31963 arg1 = reinterpret_cast< wxWindow * >(argp1);
31964 {
31965 arg2 = &temp2;
31966 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31967 }
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 (arg1)->SetMaxSize((wxSize const &)*arg2);
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 resultobj = SWIG_Py_Void();
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 int result;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 PyObject *swig_obj[1] ;
31988
31989 if (!args) SWIG_fail;
31990 swig_obj[0] = args;
31991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31992 if (!SWIG_IsOK(res1)) {
31993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31994 }
31995 arg1 = reinterpret_cast< wxWindow * >(argp1);
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 resultobj = SWIG_From_int(static_cast< int >(result));
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32010 PyObject *resultobj = 0;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 int result;
32013 void *argp1 = 0 ;
32014 int res1 = 0 ;
32015 PyObject *swig_obj[1] ;
32016
32017 if (!args) SWIG_fail;
32018 swig_obj[0] = args;
32019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32020 if (!SWIG_IsOK(res1)) {
32021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32022 }
32023 arg1 = reinterpret_cast< wxWindow * >(argp1);
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_From_int(static_cast< int >(result));
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 int result;
32041 void *argp1 = 0 ;
32042 int res1 = 0 ;
32043 PyObject *swig_obj[1] ;
32044
32045 if (!args) SWIG_fail;
32046 swig_obj[0] = args;
32047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32048 if (!SWIG_IsOK(res1)) {
32049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32050 }
32051 arg1 = reinterpret_cast< wxWindow * >(argp1);
32052 {
32053 PyThreadState* __tstate = wxPyBeginAllowThreads();
32054 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32055 wxPyEndAllowThreads(__tstate);
32056 if (PyErr_Occurred()) SWIG_fail;
32057 }
32058 resultobj = SWIG_From_int(static_cast< int >(result));
32059 return resultobj;
32060 fail:
32061 return NULL;
32062 }
32063
32064
32065 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32066 PyObject *resultobj = 0;
32067 wxWindow *arg1 = (wxWindow *) 0 ;
32068 int result;
32069 void *argp1 = 0 ;
32070 int res1 = 0 ;
32071 PyObject *swig_obj[1] ;
32072
32073 if (!args) SWIG_fail;
32074 swig_obj[0] = args;
32075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32076 if (!SWIG_IsOK(res1)) {
32077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32078 }
32079 arg1 = reinterpret_cast< wxWindow * >(argp1);
32080 {
32081 PyThreadState* __tstate = wxPyBeginAllowThreads();
32082 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 resultobj = SWIG_From_int(static_cast< int >(result));
32087 return resultobj;
32088 fail:
32089 return NULL;
32090 }
32091
32092
32093 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32094 PyObject *resultobj = 0;
32095 wxWindow *arg1 = (wxWindow *) 0 ;
32096 wxSize *arg2 = 0 ;
32097 void *argp1 = 0 ;
32098 int res1 = 0 ;
32099 wxSize temp2 ;
32100 PyObject * obj0 = 0 ;
32101 PyObject * obj1 = 0 ;
32102 char * kwnames[] = {
32103 (char *) "self",(char *) "size", NULL
32104 };
32105
32106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32108 if (!SWIG_IsOK(res1)) {
32109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32110 }
32111 arg1 = reinterpret_cast< wxWindow * >(argp1);
32112 {
32113 arg2 = &temp2;
32114 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32115 }
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 resultobj = SWIG_Py_Void();
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32130 PyObject *resultobj = 0;
32131 wxWindow *arg1 = (wxWindow *) 0 ;
32132 int arg2 ;
32133 int arg3 ;
32134 void *argp1 = 0 ;
32135 int res1 = 0 ;
32136 int val2 ;
32137 int ecode2 = 0 ;
32138 int val3 ;
32139 int ecode3 = 0 ;
32140 PyObject * obj0 = 0 ;
32141 PyObject * obj1 = 0 ;
32142 PyObject * obj2 = 0 ;
32143 char * kwnames[] = {
32144 (char *) "self",(char *) "w",(char *) "h", NULL
32145 };
32146
32147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32149 if (!SWIG_IsOK(res1)) {
32150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32151 }
32152 arg1 = reinterpret_cast< wxWindow * >(argp1);
32153 ecode2 = SWIG_AsVal_int(obj1, &val2);
32154 if (!SWIG_IsOK(ecode2)) {
32155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32156 }
32157 arg2 = static_cast< int >(val2);
32158 ecode3 = SWIG_AsVal_int(obj2, &val3);
32159 if (!SWIG_IsOK(ecode3)) {
32160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32161 }
32162 arg3 = static_cast< int >(val3);
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 (arg1)->SetVirtualSize(arg2,arg3);
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 resultobj = SWIG_Py_Void();
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32177 PyObject *resultobj = 0;
32178 wxWindow *arg1 = (wxWindow *) 0 ;
32179 wxSize result;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 PyObject *swig_obj[1] ;
32183
32184 if (!args) SWIG_fail;
32185 swig_obj[0] = args;
32186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32187 if (!SWIG_IsOK(res1)) {
32188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32189 }
32190 arg1 = reinterpret_cast< wxWindow * >(argp1);
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = ((wxWindow const *)arg1)->GetVirtualSize();
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32198 return resultobj;
32199 fail:
32200 return NULL;
32201 }
32202
32203
32204 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32205 PyObject *resultobj = 0;
32206 wxWindow *arg1 = (wxWindow *) 0 ;
32207 int *arg2 = (int *) 0 ;
32208 int *arg3 = (int *) 0 ;
32209 void *argp1 = 0 ;
32210 int res1 = 0 ;
32211 int temp2 ;
32212 int res2 = SWIG_TMPOBJ ;
32213 int temp3 ;
32214 int res3 = SWIG_TMPOBJ ;
32215 PyObject *swig_obj[1] ;
32216
32217 arg2 = &temp2;
32218 arg3 = &temp3;
32219 if (!args) SWIG_fail;
32220 swig_obj[0] = args;
32221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32222 if (!SWIG_IsOK(res1)) {
32223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32224 }
32225 arg1 = reinterpret_cast< wxWindow * >(argp1);
32226 {
32227 PyThreadState* __tstate = wxPyBeginAllowThreads();
32228 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 resultobj = SWIG_Py_Void();
32233 if (SWIG_IsTmpObj(res2)) {
32234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32235 } else {
32236 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32238 }
32239 if (SWIG_IsTmpObj(res3)) {
32240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32241 } else {
32242 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32244 }
32245 return resultobj;
32246 fail:
32247 return NULL;
32248 }
32249
32250
32251 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32252 PyObject *resultobj = 0;
32253 wxWindow *arg1 = (wxWindow *) 0 ;
32254 wxSize result;
32255 void *argp1 = 0 ;
32256 int res1 = 0 ;
32257 PyObject *swig_obj[1] ;
32258
32259 if (!args) SWIG_fail;
32260 swig_obj[0] = args;
32261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32262 if (!SWIG_IsOK(res1)) {
32263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32264 }
32265 arg1 = reinterpret_cast< wxWindow * >(argp1);
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32273 return resultobj;
32274 fail:
32275 return NULL;
32276 }
32277
32278
32279 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32280 PyObject *resultobj = 0;
32281 wxWindow *arg1 = (wxWindow *) 0 ;
32282 bool arg2 = (bool) true ;
32283 bool result;
32284 void *argp1 = 0 ;
32285 int res1 = 0 ;
32286 bool val2 ;
32287 int ecode2 = 0 ;
32288 PyObject * obj0 = 0 ;
32289 PyObject * obj1 = 0 ;
32290 char * kwnames[] = {
32291 (char *) "self",(char *) "show", NULL
32292 };
32293
32294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32296 if (!SWIG_IsOK(res1)) {
32297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32298 }
32299 arg1 = reinterpret_cast< wxWindow * >(argp1);
32300 if (obj1) {
32301 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32302 if (!SWIG_IsOK(ecode2)) {
32303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32304 }
32305 arg2 = static_cast< bool >(val2);
32306 }
32307 {
32308 PyThreadState* __tstate = wxPyBeginAllowThreads();
32309 result = (bool)(arg1)->Show(arg2);
32310 wxPyEndAllowThreads(__tstate);
32311 if (PyErr_Occurred()) SWIG_fail;
32312 }
32313 {
32314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32315 }
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 bool result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32335 }
32336 arg1 = reinterpret_cast< wxWindow * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = (bool)(arg1)->Hide();
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 {
32344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32345 }
32346 return resultobj;
32347 fail:
32348 return NULL;
32349 }
32350
32351
32352 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32353 PyObject *resultobj = 0;
32354 wxWindow *arg1 = (wxWindow *) 0 ;
32355 bool arg2 = (bool) true ;
32356 bool result;
32357 void *argp1 = 0 ;
32358 int res1 = 0 ;
32359 bool val2 ;
32360 int ecode2 = 0 ;
32361 PyObject * obj0 = 0 ;
32362 PyObject * obj1 = 0 ;
32363 char * kwnames[] = {
32364 (char *) "self",(char *) "enable", NULL
32365 };
32366
32367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32369 if (!SWIG_IsOK(res1)) {
32370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32371 }
32372 arg1 = reinterpret_cast< wxWindow * >(argp1);
32373 if (obj1) {
32374 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32375 if (!SWIG_IsOK(ecode2)) {
32376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32377 }
32378 arg2 = static_cast< bool >(val2);
32379 }
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 result = (bool)(arg1)->Enable(arg2);
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 {
32387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32388 }
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxWindow *arg1 = (wxWindow *) 0 ;
32398 bool result;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject *swig_obj[1] ;
32402
32403 if (!args) SWIG_fail;
32404 swig_obj[0] = args;
32405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32408 }
32409 arg1 = reinterpret_cast< wxWindow * >(argp1);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (bool)(arg1)->Disable();
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 {
32417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 bool result;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 PyObject *swig_obj[1] ;
32432
32433 if (!args) SWIG_fail;
32434 swig_obj[0] = args;
32435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32438 }
32439 arg1 = reinterpret_cast< wxWindow * >(argp1);
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = (bool)((wxWindow const *)arg1)->IsShown();
32443 wxPyEndAllowThreads(__tstate);
32444 if (PyErr_Occurred()) SWIG_fail;
32445 }
32446 {
32447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32448 }
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxWindow *arg1 = (wxWindow *) 0 ;
32458 bool result;
32459 void *argp1 = 0 ;
32460 int res1 = 0 ;
32461 PyObject *swig_obj[1] ;
32462
32463 if (!args) SWIG_fail;
32464 swig_obj[0] = args;
32465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32466 if (!SWIG_IsOK(res1)) {
32467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32468 }
32469 arg1 = reinterpret_cast< wxWindow * >(argp1);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 {
32477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32478 }
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32486 PyObject *resultobj = 0;
32487 wxWindow *arg1 = (wxWindow *) 0 ;
32488 long arg2 ;
32489 void *argp1 = 0 ;
32490 int res1 = 0 ;
32491 long val2 ;
32492 int ecode2 = 0 ;
32493 PyObject * obj0 = 0 ;
32494 PyObject * obj1 = 0 ;
32495 char * kwnames[] = {
32496 (char *) "self",(char *) "style", NULL
32497 };
32498
32499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32501 if (!SWIG_IsOK(res1)) {
32502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32503 }
32504 arg1 = reinterpret_cast< wxWindow * >(argp1);
32505 ecode2 = SWIG_AsVal_long(obj1, &val2);
32506 if (!SWIG_IsOK(ecode2)) {
32507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32508 }
32509 arg2 = static_cast< long >(val2);
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 (arg1)->SetWindowStyleFlag(arg2);
32513 wxPyEndAllowThreads(__tstate);
32514 if (PyErr_Occurred()) SWIG_fail;
32515 }
32516 resultobj = SWIG_Py_Void();
32517 return resultobj;
32518 fail:
32519 return NULL;
32520 }
32521
32522
32523 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32524 PyObject *resultobj = 0;
32525 wxWindow *arg1 = (wxWindow *) 0 ;
32526 long result;
32527 void *argp1 = 0 ;
32528 int res1 = 0 ;
32529 PyObject *swig_obj[1] ;
32530
32531 if (!args) SWIG_fail;
32532 swig_obj[0] = args;
32533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32536 }
32537 arg1 = reinterpret_cast< wxWindow * >(argp1);
32538 {
32539 PyThreadState* __tstate = wxPyBeginAllowThreads();
32540 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 resultobj = SWIG_From_long(static_cast< long >(result));
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32552 PyObject *resultobj = 0;
32553 wxWindow *arg1 = (wxWindow *) 0 ;
32554 int arg2 ;
32555 bool result;
32556 void *argp1 = 0 ;
32557 int res1 = 0 ;
32558 int val2 ;
32559 int ecode2 = 0 ;
32560 PyObject * obj0 = 0 ;
32561 PyObject * obj1 = 0 ;
32562 char * kwnames[] = {
32563 (char *) "self",(char *) "flag", NULL
32564 };
32565
32566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32568 if (!SWIG_IsOK(res1)) {
32569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32570 }
32571 arg1 = reinterpret_cast< wxWindow * >(argp1);
32572 ecode2 = SWIG_AsVal_int(obj1, &val2);
32573 if (!SWIG_IsOK(ecode2)) {
32574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32575 }
32576 arg2 = static_cast< int >(val2);
32577 {
32578 PyThreadState* __tstate = wxPyBeginAllowThreads();
32579 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 {
32584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32585 }
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32593 PyObject *resultobj = 0;
32594 wxWindow *arg1 = (wxWindow *) 0 ;
32595 bool result;
32596 void *argp1 = 0 ;
32597 int res1 = 0 ;
32598 PyObject *swig_obj[1] ;
32599
32600 if (!args) SWIG_fail;
32601 swig_obj[0] = args;
32602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32603 if (!SWIG_IsOK(res1)) {
32604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32605 }
32606 arg1 = reinterpret_cast< wxWindow * >(argp1);
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (bool)((wxWindow const *)arg1)->IsRetained();
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 {
32614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32615 }
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32623 PyObject *resultobj = 0;
32624 wxWindow *arg1 = (wxWindow *) 0 ;
32625 long arg2 ;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 long val2 ;
32629 int ecode2 = 0 ;
32630 PyObject * obj0 = 0 ;
32631 PyObject * obj1 = 0 ;
32632 char * kwnames[] = {
32633 (char *) "self",(char *) "exStyle", NULL
32634 };
32635
32636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32638 if (!SWIG_IsOK(res1)) {
32639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32640 }
32641 arg1 = reinterpret_cast< wxWindow * >(argp1);
32642 ecode2 = SWIG_AsVal_long(obj1, &val2);
32643 if (!SWIG_IsOK(ecode2)) {
32644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32645 }
32646 arg2 = static_cast< long >(val2);
32647 {
32648 PyThreadState* __tstate = wxPyBeginAllowThreads();
32649 (arg1)->SetExtraStyle(arg2);
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 resultobj = SWIG_Py_Void();
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32661 PyObject *resultobj = 0;
32662 wxWindow *arg1 = (wxWindow *) 0 ;
32663 long result;
32664 void *argp1 = 0 ;
32665 int res1 = 0 ;
32666 PyObject *swig_obj[1] ;
32667
32668 if (!args) SWIG_fail;
32669 swig_obj[0] = args;
32670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32671 if (!SWIG_IsOK(res1)) {
32672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32673 }
32674 arg1 = reinterpret_cast< wxWindow * >(argp1);
32675 {
32676 PyThreadState* __tstate = wxPyBeginAllowThreads();
32677 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32678 wxPyEndAllowThreads(__tstate);
32679 if (PyErr_Occurred()) SWIG_fail;
32680 }
32681 resultobj = SWIG_From_long(static_cast< long >(result));
32682 return resultobj;
32683 fail:
32684 return NULL;
32685 }
32686
32687
32688 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32689 PyObject *resultobj = 0;
32690 wxWindow *arg1 = (wxWindow *) 0 ;
32691 bool arg2 = (bool) true ;
32692 void *argp1 = 0 ;
32693 int res1 = 0 ;
32694 bool val2 ;
32695 int ecode2 = 0 ;
32696 PyObject * obj0 = 0 ;
32697 PyObject * obj1 = 0 ;
32698 char * kwnames[] = {
32699 (char *) "self",(char *) "modal", NULL
32700 };
32701
32702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32704 if (!SWIG_IsOK(res1)) {
32705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32706 }
32707 arg1 = reinterpret_cast< wxWindow * >(argp1);
32708 if (obj1) {
32709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32710 if (!SWIG_IsOK(ecode2)) {
32711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32712 }
32713 arg2 = static_cast< bool >(val2);
32714 }
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 (arg1)->MakeModal(arg2);
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 resultobj = SWIG_Py_Void();
32722 return resultobj;
32723 fail:
32724 return NULL;
32725 }
32726
32727
32728 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32729 PyObject *resultobj = 0;
32730 wxWindow *arg1 = (wxWindow *) 0 ;
32731 bool arg2 ;
32732 void *argp1 = 0 ;
32733 int res1 = 0 ;
32734 bool val2 ;
32735 int ecode2 = 0 ;
32736 PyObject * obj0 = 0 ;
32737 PyObject * obj1 = 0 ;
32738 char * kwnames[] = {
32739 (char *) "self",(char *) "enableTheme", NULL
32740 };
32741
32742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32744 if (!SWIG_IsOK(res1)) {
32745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32746 }
32747 arg1 = reinterpret_cast< wxWindow * >(argp1);
32748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32749 if (!SWIG_IsOK(ecode2)) {
32750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32751 }
32752 arg2 = static_cast< bool >(val2);
32753 {
32754 PyThreadState* __tstate = wxPyBeginAllowThreads();
32755 (arg1)->SetThemeEnabled(arg2);
32756 wxPyEndAllowThreads(__tstate);
32757 if (PyErr_Occurred()) SWIG_fail;
32758 }
32759 resultobj = SWIG_Py_Void();
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32767 PyObject *resultobj = 0;
32768 wxWindow *arg1 = (wxWindow *) 0 ;
32769 bool result;
32770 void *argp1 = 0 ;
32771 int res1 = 0 ;
32772 PyObject *swig_obj[1] ;
32773
32774 if (!args) SWIG_fail;
32775 swig_obj[0] = args;
32776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32779 }
32780 arg1 = reinterpret_cast< wxWindow * >(argp1);
32781 {
32782 PyThreadState* __tstate = wxPyBeginAllowThreads();
32783 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32784 wxPyEndAllowThreads(__tstate);
32785 if (PyErr_Occurred()) SWIG_fail;
32786 }
32787 {
32788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32789 }
32790 return resultobj;
32791 fail:
32792 return NULL;
32793 }
32794
32795
32796 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32797 PyObject *resultobj = 0;
32798 wxWindow *arg1 = (wxWindow *) 0 ;
32799 void *argp1 = 0 ;
32800 int res1 = 0 ;
32801 PyObject *swig_obj[1] ;
32802
32803 if (!args) SWIG_fail;
32804 swig_obj[0] = args;
32805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32806 if (!SWIG_IsOK(res1)) {
32807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32808 }
32809 arg1 = reinterpret_cast< wxWindow * >(argp1);
32810 {
32811 PyThreadState* __tstate = wxPyBeginAllowThreads();
32812 (arg1)->SetFocus();
32813 wxPyEndAllowThreads(__tstate);
32814 if (PyErr_Occurred()) SWIG_fail;
32815 }
32816 resultobj = SWIG_Py_Void();
32817 return resultobj;
32818 fail:
32819 return NULL;
32820 }
32821
32822
32823 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32824 PyObject *resultobj = 0;
32825 wxWindow *arg1 = (wxWindow *) 0 ;
32826 void *argp1 = 0 ;
32827 int res1 = 0 ;
32828 PyObject *swig_obj[1] ;
32829
32830 if (!args) SWIG_fail;
32831 swig_obj[0] = args;
32832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 {
32838 PyThreadState* __tstate = wxPyBeginAllowThreads();
32839 (arg1)->SetFocusFromKbd();
32840 wxPyEndAllowThreads(__tstate);
32841 if (PyErr_Occurred()) SWIG_fail;
32842 }
32843 resultobj = SWIG_Py_Void();
32844 return resultobj;
32845 fail:
32846 return NULL;
32847 }
32848
32849
32850 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32851 PyObject *resultobj = 0;
32852 wxWindow *result = 0 ;
32853
32854 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32855 {
32856 if (!wxPyCheckForApp()) SWIG_fail;
32857 PyThreadState* __tstate = wxPyBeginAllowThreads();
32858 result = (wxWindow *)wxWindow::FindFocus();
32859 wxPyEndAllowThreads(__tstate);
32860 if (PyErr_Occurred()) SWIG_fail;
32861 }
32862 {
32863 resultobj = wxPyMake_wxObject(result, 0);
32864 }
32865 return resultobj;
32866 fail:
32867 return NULL;
32868 }
32869
32870
32871 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32872 PyObject *resultobj = 0;
32873 wxWindow *arg1 = (wxWindow *) 0 ;
32874 bool result;
32875 void *argp1 = 0 ;
32876 int res1 = 0 ;
32877 PyObject *swig_obj[1] ;
32878
32879 if (!args) SWIG_fail;
32880 swig_obj[0] = args;
32881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32882 if (!SWIG_IsOK(res1)) {
32883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32884 }
32885 arg1 = reinterpret_cast< wxWindow * >(argp1);
32886 {
32887 PyThreadState* __tstate = wxPyBeginAllowThreads();
32888 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32889 wxPyEndAllowThreads(__tstate);
32890 if (PyErr_Occurred()) SWIG_fail;
32891 }
32892 {
32893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32894 }
32895 return resultobj;
32896 fail:
32897 return NULL;
32898 }
32899
32900
32901 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32902 PyObject *resultobj = 0;
32903 wxWindow *arg1 = (wxWindow *) 0 ;
32904 bool result;
32905 void *argp1 = 0 ;
32906 int res1 = 0 ;
32907 PyObject *swig_obj[1] ;
32908
32909 if (!args) SWIG_fail;
32910 swig_obj[0] = args;
32911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32912 if (!SWIG_IsOK(res1)) {
32913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32914 }
32915 arg1 = reinterpret_cast< wxWindow * >(argp1);
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 {
32923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32924 }
32925 return resultobj;
32926 fail:
32927 return NULL;
32928 }
32929
32930
32931 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32932 PyObject *resultobj = 0;
32933 wxWindow *arg1 = (wxWindow *) 0 ;
32934 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32935 bool result;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 int val2 ;
32939 int ecode2 = 0 ;
32940 PyObject * obj0 = 0 ;
32941 PyObject * obj1 = 0 ;
32942 char * kwnames[] = {
32943 (char *) "self",(char *) "flags", NULL
32944 };
32945
32946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32948 if (!SWIG_IsOK(res1)) {
32949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32950 }
32951 arg1 = reinterpret_cast< wxWindow * >(argp1);
32952 if (obj1) {
32953 ecode2 = SWIG_AsVal_int(obj1, &val2);
32954 if (!SWIG_IsOK(ecode2)) {
32955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32956 }
32957 arg2 = static_cast< int >(val2);
32958 }
32959 {
32960 PyThreadState* __tstate = wxPyBeginAllowThreads();
32961 result = (bool)(arg1)->Navigate(arg2);
32962 wxPyEndAllowThreads(__tstate);
32963 if (PyErr_Occurred()) SWIG_fail;
32964 }
32965 {
32966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32967 }
32968 return resultobj;
32969 fail:
32970 return NULL;
32971 }
32972
32973
32974 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32975 PyObject *resultobj = 0;
32976 wxWindow *arg1 = (wxWindow *) 0 ;
32977 wxWindow *arg2 = (wxWindow *) 0 ;
32978 void *argp1 = 0 ;
32979 int res1 = 0 ;
32980 void *argp2 = 0 ;
32981 int res2 = 0 ;
32982 PyObject * obj0 = 0 ;
32983 PyObject * obj1 = 0 ;
32984 char * kwnames[] = {
32985 (char *) "self",(char *) "win", NULL
32986 };
32987
32988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32990 if (!SWIG_IsOK(res1)) {
32991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32992 }
32993 arg1 = reinterpret_cast< wxWindow * >(argp1);
32994 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32995 if (!SWIG_IsOK(res2)) {
32996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32997 }
32998 arg2 = reinterpret_cast< wxWindow * >(argp2);
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 (arg1)->MoveAfterInTabOrder(arg2);
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 resultobj = SWIG_Py_Void();
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33013 PyObject *resultobj = 0;
33014 wxWindow *arg1 = (wxWindow *) 0 ;
33015 wxWindow *arg2 = (wxWindow *) 0 ;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 void *argp2 = 0 ;
33019 int res2 = 0 ;
33020 PyObject * obj0 = 0 ;
33021 PyObject * obj1 = 0 ;
33022 char * kwnames[] = {
33023 (char *) "self",(char *) "win", NULL
33024 };
33025
33026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33028 if (!SWIG_IsOK(res1)) {
33029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33030 }
33031 arg1 = reinterpret_cast< wxWindow * >(argp1);
33032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res2)) {
33034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33035 }
33036 arg2 = reinterpret_cast< wxWindow * >(argp2);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 (arg1)->MoveBeforeInTabOrder(arg2);
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 resultobj = SWIG_Py_Void();
33044 return resultobj;
33045 fail:
33046 return NULL;
33047 }
33048
33049
33050 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33051 PyObject *resultobj = 0;
33052 wxWindow *arg1 = (wxWindow *) 0 ;
33053 PyObject *result = 0 ;
33054 void *argp1 = 0 ;
33055 int res1 = 0 ;
33056 PyObject *swig_obj[1] ;
33057
33058 if (!args) SWIG_fail;
33059 swig_obj[0] = args;
33060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33061 if (!SWIG_IsOK(res1)) {
33062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33063 }
33064 arg1 = reinterpret_cast< wxWindow * >(argp1);
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = (PyObject *)wxWindow_GetChildren(arg1);
33068 wxPyEndAllowThreads(__tstate);
33069 if (PyErr_Occurred()) SWIG_fail;
33070 }
33071 resultobj = result;
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33079 PyObject *resultobj = 0;
33080 wxWindow *arg1 = (wxWindow *) 0 ;
33081 wxWindow *result = 0 ;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 PyObject *swig_obj[1] ;
33085
33086 if (!args) SWIG_fail;
33087 swig_obj[0] = args;
33088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33089 if (!SWIG_IsOK(res1)) {
33090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33091 }
33092 arg1 = reinterpret_cast< wxWindow * >(argp1);
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33096 wxPyEndAllowThreads(__tstate);
33097 if (PyErr_Occurred()) SWIG_fail;
33098 }
33099 {
33100 resultobj = wxPyMake_wxObject(result, 0);
33101 }
33102 return resultobj;
33103 fail:
33104 return NULL;
33105 }
33106
33107
33108 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33109 PyObject *resultobj = 0;
33110 wxWindow *arg1 = (wxWindow *) 0 ;
33111 wxWindow *result = 0 ;
33112 void *argp1 = 0 ;
33113 int res1 = 0 ;
33114 PyObject *swig_obj[1] ;
33115
33116 if (!args) SWIG_fail;
33117 swig_obj[0] = args;
33118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33119 if (!SWIG_IsOK(res1)) {
33120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33121 }
33122 arg1 = reinterpret_cast< wxWindow * >(argp1);
33123 {
33124 PyThreadState* __tstate = wxPyBeginAllowThreads();
33125 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33126 wxPyEndAllowThreads(__tstate);
33127 if (PyErr_Occurred()) SWIG_fail;
33128 }
33129 {
33130 resultobj = wxPyMake_wxObject(result, 0);
33131 }
33132 return resultobj;
33133 fail:
33134 return NULL;
33135 }
33136
33137
33138 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33139 PyObject *resultobj = 0;
33140 wxWindow *arg1 = (wxWindow *) 0 ;
33141 bool result;
33142 void *argp1 = 0 ;
33143 int res1 = 0 ;
33144 PyObject *swig_obj[1] ;
33145
33146 if (!args) SWIG_fail;
33147 swig_obj[0] = args;
33148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33149 if (!SWIG_IsOK(res1)) {
33150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33151 }
33152 arg1 = reinterpret_cast< wxWindow * >(argp1);
33153 {
33154 PyThreadState* __tstate = wxPyBeginAllowThreads();
33155 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33156 wxPyEndAllowThreads(__tstate);
33157 if (PyErr_Occurred()) SWIG_fail;
33158 }
33159 {
33160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33161 }
33162 return resultobj;
33163 fail:
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33169 PyObject *resultobj = 0;
33170 wxWindow *arg1 = (wxWindow *) 0 ;
33171 wxWindow *arg2 = (wxWindow *) 0 ;
33172 bool result;
33173 void *argp1 = 0 ;
33174 int res1 = 0 ;
33175 void *argp2 = 0 ;
33176 int res2 = 0 ;
33177 PyObject * obj0 = 0 ;
33178 PyObject * obj1 = 0 ;
33179 char * kwnames[] = {
33180 (char *) "self",(char *) "newParent", NULL
33181 };
33182
33183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33185 if (!SWIG_IsOK(res1)) {
33186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33187 }
33188 arg1 = reinterpret_cast< wxWindow * >(argp1);
33189 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33190 if (!SWIG_IsOK(res2)) {
33191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33192 }
33193 arg2 = reinterpret_cast< wxWindow * >(argp2);
33194 {
33195 PyThreadState* __tstate = wxPyBeginAllowThreads();
33196 result = (bool)(arg1)->Reparent(arg2);
33197 wxPyEndAllowThreads(__tstate);
33198 if (PyErr_Occurred()) SWIG_fail;
33199 }
33200 {
33201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33202 }
33203 return resultobj;
33204 fail:
33205 return NULL;
33206 }
33207
33208
33209 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33210 PyObject *resultobj = 0;
33211 wxWindow *arg1 = (wxWindow *) 0 ;
33212 wxWindow *arg2 = (wxWindow *) 0 ;
33213 void *argp1 = 0 ;
33214 int res1 = 0 ;
33215 void *argp2 = 0 ;
33216 int res2 = 0 ;
33217 PyObject * obj0 = 0 ;
33218 PyObject * obj1 = 0 ;
33219 char * kwnames[] = {
33220 (char *) "self",(char *) "child", NULL
33221 };
33222
33223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33225 if (!SWIG_IsOK(res1)) {
33226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33227 }
33228 arg1 = reinterpret_cast< wxWindow * >(argp1);
33229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33230 if (!SWIG_IsOK(res2)) {
33231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33232 }
33233 arg2 = reinterpret_cast< wxWindow * >(argp2);
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 (arg1)->AddChild(arg2);
33237 wxPyEndAllowThreads(__tstate);
33238 if (PyErr_Occurred()) SWIG_fail;
33239 }
33240 resultobj = SWIG_Py_Void();
33241 return resultobj;
33242 fail:
33243 return NULL;
33244 }
33245
33246
33247 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33248 PyObject *resultobj = 0;
33249 wxWindow *arg1 = (wxWindow *) 0 ;
33250 wxWindow *arg2 = (wxWindow *) 0 ;
33251 void *argp1 = 0 ;
33252 int res1 = 0 ;
33253 void *argp2 = 0 ;
33254 int res2 = 0 ;
33255 PyObject * obj0 = 0 ;
33256 PyObject * obj1 = 0 ;
33257 char * kwnames[] = {
33258 (char *) "self",(char *) "child", NULL
33259 };
33260
33261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33263 if (!SWIG_IsOK(res1)) {
33264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33265 }
33266 arg1 = reinterpret_cast< wxWindow * >(argp1);
33267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33268 if (!SWIG_IsOK(res2)) {
33269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33270 }
33271 arg2 = reinterpret_cast< wxWindow * >(argp2);
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 (arg1)->RemoveChild(arg2);
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 resultobj = SWIG_Py_Void();
33279 return resultobj;
33280 fail:
33281 return NULL;
33282 }
33283
33284
33285 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33286 PyObject *resultobj = 0;
33287 wxWindow *arg1 = (wxWindow *) 0 ;
33288 bool arg2 ;
33289 void *argp1 = 0 ;
33290 int res1 = 0 ;
33291 bool val2 ;
33292 int ecode2 = 0 ;
33293 PyObject * obj0 = 0 ;
33294 PyObject * obj1 = 0 ;
33295 char * kwnames[] = {
33296 (char *) "self",(char *) "on", NULL
33297 };
33298
33299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33301 if (!SWIG_IsOK(res1)) {
33302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33303 }
33304 arg1 = reinterpret_cast< wxWindow * >(argp1);
33305 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33306 if (!SWIG_IsOK(ecode2)) {
33307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33308 }
33309 arg2 = static_cast< bool >(val2);
33310 {
33311 PyThreadState* __tstate = wxPyBeginAllowThreads();
33312 (arg1)->SetDoubleBuffered(arg2);
33313 wxPyEndAllowThreads(__tstate);
33314 if (PyErr_Occurred()) SWIG_fail;
33315 }
33316 resultobj = SWIG_Py_Void();
33317 return resultobj;
33318 fail:
33319 return NULL;
33320 }
33321
33322
33323 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33324 PyObject *resultobj = 0;
33325 wxWindow *arg1 = (wxWindow *) 0 ;
33326 long arg2 ;
33327 wxWindow *result = 0 ;
33328 void *argp1 = 0 ;
33329 int res1 = 0 ;
33330 long val2 ;
33331 int ecode2 = 0 ;
33332 PyObject * obj0 = 0 ;
33333 PyObject * obj1 = 0 ;
33334 char * kwnames[] = {
33335 (char *) "self",(char *) "winid", NULL
33336 };
33337
33338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33340 if (!SWIG_IsOK(res1)) {
33341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33342 }
33343 arg1 = reinterpret_cast< wxWindow * >(argp1);
33344 ecode2 = SWIG_AsVal_long(obj1, &val2);
33345 if (!SWIG_IsOK(ecode2)) {
33346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33347 }
33348 arg2 = static_cast< long >(val2);
33349 {
33350 PyThreadState* __tstate = wxPyBeginAllowThreads();
33351 result = (wxWindow *)(arg1)->FindWindow(arg2);
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 {
33356 resultobj = wxPyMake_wxObject(result, 0);
33357 }
33358 return resultobj;
33359 fail:
33360 return NULL;
33361 }
33362
33363
33364 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33365 PyObject *resultobj = 0;
33366 wxWindow *arg1 = (wxWindow *) 0 ;
33367 wxString *arg2 = 0 ;
33368 wxWindow *result = 0 ;
33369 void *argp1 = 0 ;
33370 int res1 = 0 ;
33371 bool temp2 = false ;
33372 PyObject * obj0 = 0 ;
33373 PyObject * obj1 = 0 ;
33374 char * kwnames[] = {
33375 (char *) "self",(char *) "name", NULL
33376 };
33377
33378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33380 if (!SWIG_IsOK(res1)) {
33381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33382 }
33383 arg1 = reinterpret_cast< wxWindow * >(argp1);
33384 {
33385 arg2 = wxString_in_helper(obj1);
33386 if (arg2 == NULL) SWIG_fail;
33387 temp2 = true;
33388 }
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33392 wxPyEndAllowThreads(__tstate);
33393 if (PyErr_Occurred()) SWIG_fail;
33394 }
33395 {
33396 resultobj = wxPyMake_wxObject(result, 0);
33397 }
33398 {
33399 if (temp2)
33400 delete arg2;
33401 }
33402 return resultobj;
33403 fail:
33404 {
33405 if (temp2)
33406 delete arg2;
33407 }
33408 return NULL;
33409 }
33410
33411
33412 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33413 PyObject *resultobj = 0;
33414 wxWindow *arg1 = (wxWindow *) 0 ;
33415 wxEvtHandler *result = 0 ;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 PyObject *swig_obj[1] ;
33419
33420 if (!args) SWIG_fail;
33421 swig_obj[0] = args;
33422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33423 if (!SWIG_IsOK(res1)) {
33424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33425 }
33426 arg1 = reinterpret_cast< wxWindow * >(argp1);
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 {
33434 resultobj = wxPyMake_wxObject(result, 0);
33435 }
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33443 PyObject *resultobj = 0;
33444 wxWindow *arg1 = (wxWindow *) 0 ;
33445 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33446 void *argp1 = 0 ;
33447 int res1 = 0 ;
33448 void *argp2 = 0 ;
33449 int res2 = 0 ;
33450 PyObject * obj0 = 0 ;
33451 PyObject * obj1 = 0 ;
33452 char * kwnames[] = {
33453 (char *) "self",(char *) "handler", NULL
33454 };
33455
33456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33458 if (!SWIG_IsOK(res1)) {
33459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33460 }
33461 arg1 = reinterpret_cast< wxWindow * >(argp1);
33462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33463 if (!SWIG_IsOK(res2)) {
33464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33465 }
33466 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33467 {
33468 PyThreadState* __tstate = wxPyBeginAllowThreads();
33469 (arg1)->SetEventHandler(arg2);
33470 wxPyEndAllowThreads(__tstate);
33471 if (PyErr_Occurred()) SWIG_fail;
33472 }
33473 resultobj = SWIG_Py_Void();
33474 return resultobj;
33475 fail:
33476 return NULL;
33477 }
33478
33479
33480 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33481 PyObject *resultobj = 0;
33482 wxWindow *arg1 = (wxWindow *) 0 ;
33483 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33484 void *argp1 = 0 ;
33485 int res1 = 0 ;
33486 void *argp2 = 0 ;
33487 int res2 = 0 ;
33488 PyObject * obj0 = 0 ;
33489 PyObject * obj1 = 0 ;
33490 char * kwnames[] = {
33491 (char *) "self",(char *) "handler", NULL
33492 };
33493
33494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33496 if (!SWIG_IsOK(res1)) {
33497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33498 }
33499 arg1 = reinterpret_cast< wxWindow * >(argp1);
33500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33501 if (!SWIG_IsOK(res2)) {
33502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33503 }
33504 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33505 {
33506 PyThreadState* __tstate = wxPyBeginAllowThreads();
33507 (arg1)->PushEventHandler(arg2);
33508 wxPyEndAllowThreads(__tstate);
33509 if (PyErr_Occurred()) SWIG_fail;
33510 }
33511 resultobj = SWIG_Py_Void();
33512 return resultobj;
33513 fail:
33514 return NULL;
33515 }
33516
33517
33518 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33519 PyObject *resultobj = 0;
33520 wxWindow *arg1 = (wxWindow *) 0 ;
33521 bool arg2 = (bool) false ;
33522 wxEvtHandler *result = 0 ;
33523 void *argp1 = 0 ;
33524 int res1 = 0 ;
33525 bool val2 ;
33526 int ecode2 = 0 ;
33527 PyObject * obj0 = 0 ;
33528 PyObject * obj1 = 0 ;
33529 char * kwnames[] = {
33530 (char *) "self",(char *) "deleteHandler", NULL
33531 };
33532
33533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33535 if (!SWIG_IsOK(res1)) {
33536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33537 }
33538 arg1 = reinterpret_cast< wxWindow * >(argp1);
33539 if (obj1) {
33540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33541 if (!SWIG_IsOK(ecode2)) {
33542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33543 }
33544 arg2 = static_cast< bool >(val2);
33545 }
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 {
33553 resultobj = wxPyMake_wxObject(result, 0);
33554 }
33555 return resultobj;
33556 fail:
33557 return NULL;
33558 }
33559
33560
33561 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33562 PyObject *resultobj = 0;
33563 wxWindow *arg1 = (wxWindow *) 0 ;
33564 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33565 bool result;
33566 void *argp1 = 0 ;
33567 int res1 = 0 ;
33568 void *argp2 = 0 ;
33569 int res2 = 0 ;
33570 PyObject * obj0 = 0 ;
33571 PyObject * obj1 = 0 ;
33572 char * kwnames[] = {
33573 (char *) "self",(char *) "handler", NULL
33574 };
33575
33576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33578 if (!SWIG_IsOK(res1)) {
33579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33580 }
33581 arg1 = reinterpret_cast< wxWindow * >(argp1);
33582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33583 if (!SWIG_IsOK(res2)) {
33584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33585 }
33586 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33587 {
33588 PyThreadState* __tstate = wxPyBeginAllowThreads();
33589 result = (bool)(arg1)->RemoveEventHandler(arg2);
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 {
33594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33595 }
33596 return resultobj;
33597 fail:
33598 return NULL;
33599 }
33600
33601
33602 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33603 PyObject *resultobj = 0;
33604 wxWindow *arg1 = (wxWindow *) 0 ;
33605 wxValidator *arg2 = 0 ;
33606 void *argp1 = 0 ;
33607 int res1 = 0 ;
33608 void *argp2 = 0 ;
33609 int res2 = 0 ;
33610 PyObject * obj0 = 0 ;
33611 PyObject * obj1 = 0 ;
33612 char * kwnames[] = {
33613 (char *) "self",(char *) "validator", NULL
33614 };
33615
33616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33618 if (!SWIG_IsOK(res1)) {
33619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33620 }
33621 arg1 = reinterpret_cast< wxWindow * >(argp1);
33622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33623 if (!SWIG_IsOK(res2)) {
33624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33625 }
33626 if (!argp2) {
33627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33628 }
33629 arg2 = reinterpret_cast< wxValidator * >(argp2);
33630 {
33631 PyThreadState* __tstate = wxPyBeginAllowThreads();
33632 (arg1)->SetValidator((wxValidator const &)*arg2);
33633 wxPyEndAllowThreads(__tstate);
33634 if (PyErr_Occurred()) SWIG_fail;
33635 }
33636 resultobj = SWIG_Py_Void();
33637 return resultobj;
33638 fail:
33639 return NULL;
33640 }
33641
33642
33643 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33644 PyObject *resultobj = 0;
33645 wxWindow *arg1 = (wxWindow *) 0 ;
33646 wxValidator *result = 0 ;
33647 void *argp1 = 0 ;
33648 int res1 = 0 ;
33649 PyObject *swig_obj[1] ;
33650
33651 if (!args) SWIG_fail;
33652 swig_obj[0] = args;
33653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33654 if (!SWIG_IsOK(res1)) {
33655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33656 }
33657 arg1 = reinterpret_cast< wxWindow * >(argp1);
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 result = (wxValidator *)(arg1)->GetValidator();
33661 wxPyEndAllowThreads(__tstate);
33662 if (PyErr_Occurred()) SWIG_fail;
33663 }
33664 {
33665 resultobj = wxPyMake_wxObject(result, (bool)0);
33666 }
33667 return resultobj;
33668 fail:
33669 return NULL;
33670 }
33671
33672
33673 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33674 PyObject *resultobj = 0;
33675 wxWindow *arg1 = (wxWindow *) 0 ;
33676 bool result;
33677 void *argp1 = 0 ;
33678 int res1 = 0 ;
33679 PyObject *swig_obj[1] ;
33680
33681 if (!args) SWIG_fail;
33682 swig_obj[0] = args;
33683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33684 if (!SWIG_IsOK(res1)) {
33685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33686 }
33687 arg1 = reinterpret_cast< wxWindow * >(argp1);
33688 {
33689 PyThreadState* __tstate = wxPyBeginAllowThreads();
33690 result = (bool)(arg1)->Validate();
33691 wxPyEndAllowThreads(__tstate);
33692 if (PyErr_Occurred()) SWIG_fail;
33693 }
33694 {
33695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33696 }
33697 return resultobj;
33698 fail:
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 bool result;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 PyObject *swig_obj[1] ;
33710
33711 if (!args) SWIG_fail;
33712 swig_obj[0] = args;
33713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33714 if (!SWIG_IsOK(res1)) {
33715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33716 }
33717 arg1 = reinterpret_cast< wxWindow * >(argp1);
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 result = (bool)(arg1)->TransferDataToWindow();
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 {
33725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33726 }
33727 return resultobj;
33728 fail:
33729 return NULL;
33730 }
33731
33732
33733 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33734 PyObject *resultobj = 0;
33735 wxWindow *arg1 = (wxWindow *) 0 ;
33736 bool result;
33737 void *argp1 = 0 ;
33738 int res1 = 0 ;
33739 PyObject *swig_obj[1] ;
33740
33741 if (!args) SWIG_fail;
33742 swig_obj[0] = args;
33743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33744 if (!SWIG_IsOK(res1)) {
33745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33746 }
33747 arg1 = reinterpret_cast< wxWindow * >(argp1);
33748 {
33749 PyThreadState* __tstate = wxPyBeginAllowThreads();
33750 result = (bool)(arg1)->TransferDataFromWindow();
33751 wxPyEndAllowThreads(__tstate);
33752 if (PyErr_Occurred()) SWIG_fail;
33753 }
33754 {
33755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33756 }
33757 return resultobj;
33758 fail:
33759 return NULL;
33760 }
33761
33762
33763 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33764 PyObject *resultobj = 0;
33765 wxWindow *arg1 = (wxWindow *) 0 ;
33766 void *argp1 = 0 ;
33767 int res1 = 0 ;
33768 PyObject *swig_obj[1] ;
33769
33770 if (!args) SWIG_fail;
33771 swig_obj[0] = args;
33772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33773 if (!SWIG_IsOK(res1)) {
33774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33775 }
33776 arg1 = reinterpret_cast< wxWindow * >(argp1);
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 (arg1)->InitDialog();
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 resultobj = SWIG_Py_Void();
33784 return resultobj;
33785 fail:
33786 return NULL;
33787 }
33788
33789
33790 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33791 PyObject *resultobj = 0;
33792 wxWindow *arg1 = (wxWindow *) 0 ;
33793 wxAcceleratorTable *arg2 = 0 ;
33794 void *argp1 = 0 ;
33795 int res1 = 0 ;
33796 void *argp2 = 0 ;
33797 int res2 = 0 ;
33798 PyObject * obj0 = 0 ;
33799 PyObject * obj1 = 0 ;
33800 char * kwnames[] = {
33801 (char *) "self",(char *) "accel", NULL
33802 };
33803
33804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33806 if (!SWIG_IsOK(res1)) {
33807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33808 }
33809 arg1 = reinterpret_cast< wxWindow * >(argp1);
33810 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33811 if (!SWIG_IsOK(res2)) {
33812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33813 }
33814 if (!argp2) {
33815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33816 }
33817 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33821 wxPyEndAllowThreads(__tstate);
33822 if (PyErr_Occurred()) SWIG_fail;
33823 }
33824 resultobj = SWIG_Py_Void();
33825 return resultobj;
33826 fail:
33827 return NULL;
33828 }
33829
33830
33831 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33832 PyObject *resultobj = 0;
33833 wxWindow *arg1 = (wxWindow *) 0 ;
33834 wxAcceleratorTable *result = 0 ;
33835 void *argp1 = 0 ;
33836 int res1 = 0 ;
33837 PyObject *swig_obj[1] ;
33838
33839 if (!args) SWIG_fail;
33840 swig_obj[0] = args;
33841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33842 if (!SWIG_IsOK(res1)) {
33843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33844 }
33845 arg1 = reinterpret_cast< wxWindow * >(argp1);
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj = 0;
33861 wxWindow *arg1 = (wxWindow *) 0 ;
33862 int arg2 ;
33863 int arg3 ;
33864 int arg4 ;
33865 bool result;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 int val2 ;
33869 int ecode2 = 0 ;
33870 int val3 ;
33871 int ecode3 = 0 ;
33872 int val4 ;
33873 int ecode4 = 0 ;
33874 PyObject * obj0 = 0 ;
33875 PyObject * obj1 = 0 ;
33876 PyObject * obj2 = 0 ;
33877 PyObject * obj3 = 0 ;
33878 char * kwnames[] = {
33879 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33880 };
33881
33882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33884 if (!SWIG_IsOK(res1)) {
33885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33886 }
33887 arg1 = reinterpret_cast< wxWindow * >(argp1);
33888 ecode2 = SWIG_AsVal_int(obj1, &val2);
33889 if (!SWIG_IsOK(ecode2)) {
33890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33891 }
33892 arg2 = static_cast< int >(val2);
33893 ecode3 = SWIG_AsVal_int(obj2, &val3);
33894 if (!SWIG_IsOK(ecode3)) {
33895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33896 }
33897 arg3 = static_cast< int >(val3);
33898 ecode4 = SWIG_AsVal_int(obj3, &val4);
33899 if (!SWIG_IsOK(ecode4)) {
33900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33901 }
33902 arg4 = static_cast< int >(val4);
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 {
33910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33911 }
33912 return resultobj;
33913 fail:
33914 return NULL;
33915 }
33916
33917
33918 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33919 PyObject *resultobj = 0;
33920 wxWindow *arg1 = (wxWindow *) 0 ;
33921 int arg2 ;
33922 bool result;
33923 void *argp1 = 0 ;
33924 int res1 = 0 ;
33925 int val2 ;
33926 int ecode2 = 0 ;
33927 PyObject * obj0 = 0 ;
33928 PyObject * obj1 = 0 ;
33929 char * kwnames[] = {
33930 (char *) "self",(char *) "hotkeyId", NULL
33931 };
33932
33933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33935 if (!SWIG_IsOK(res1)) {
33936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33937 }
33938 arg1 = reinterpret_cast< wxWindow * >(argp1);
33939 ecode2 = SWIG_AsVal_int(obj1, &val2);
33940 if (!SWIG_IsOK(ecode2)) {
33941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33942 }
33943 arg2 = static_cast< int >(val2);
33944 {
33945 PyThreadState* __tstate = wxPyBeginAllowThreads();
33946 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33947 wxPyEndAllowThreads(__tstate);
33948 if (PyErr_Occurred()) SWIG_fail;
33949 }
33950 {
33951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33952 }
33953 return resultobj;
33954 fail:
33955 return NULL;
33956 }
33957
33958
33959 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33960 PyObject *resultobj = 0;
33961 wxWindow *arg1 = (wxWindow *) 0 ;
33962 wxPoint *arg2 = 0 ;
33963 wxPoint result;
33964 void *argp1 = 0 ;
33965 int res1 = 0 ;
33966 wxPoint temp2 ;
33967 PyObject * obj0 = 0 ;
33968 PyObject * obj1 = 0 ;
33969 char * kwnames[] = {
33970 (char *) "self",(char *) "pt", NULL
33971 };
33972
33973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33975 if (!SWIG_IsOK(res1)) {
33976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33977 }
33978 arg1 = reinterpret_cast< wxWindow * >(argp1);
33979 {
33980 arg2 = &temp2;
33981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33982 }
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 wxWindow *arg1 = (wxWindow *) 0 ;
33999 wxSize *arg2 = 0 ;
34000 wxSize result;
34001 void *argp1 = 0 ;
34002 int res1 = 0 ;
34003 wxSize temp2 ;
34004 PyObject * obj0 = 0 ;
34005 PyObject * obj1 = 0 ;
34006 char * kwnames[] = {
34007 (char *) "self",(char *) "sz", NULL
34008 };
34009
34010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34012 if (!SWIG_IsOK(res1)) {
34013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34014 }
34015 arg1 = reinterpret_cast< wxWindow * >(argp1);
34016 {
34017 arg2 = &temp2;
34018 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34019 }
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34034 PyObject *resultobj = 0;
34035 wxWindow *arg1 = (wxWindow *) 0 ;
34036 wxPoint *arg2 = 0 ;
34037 wxPoint result;
34038 void *argp1 = 0 ;
34039 int res1 = 0 ;
34040 wxPoint temp2 ;
34041 PyObject * obj0 = 0 ;
34042 PyObject * obj1 = 0 ;
34043 char * kwnames[] = {
34044 (char *) "self",(char *) "pt", NULL
34045 };
34046
34047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34049 if (!SWIG_IsOK(res1)) {
34050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34051 }
34052 arg1 = reinterpret_cast< wxWindow * >(argp1);
34053 {
34054 arg2 = &temp2;
34055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34056 }
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxWindow *arg1 = (wxWindow *) 0 ;
34073 wxSize *arg2 = 0 ;
34074 wxSize result;
34075 void *argp1 = 0 ;
34076 int res1 = 0 ;
34077 wxSize temp2 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "sz", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34088 }
34089 arg1 = reinterpret_cast< wxWindow * >(argp1);
34090 {
34091 arg2 = &temp2;
34092 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34093 }
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxPoint *arg2 = 0 ;
34111 wxPoint result;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 wxPoint temp2 ;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char * kwnames[] = {
34118 (char *) "self",(char *) "pt", NULL
34119 };
34120
34121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34123 if (!SWIG_IsOK(res1)) {
34124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34125 }
34126 arg1 = reinterpret_cast< wxWindow * >(argp1);
34127 {
34128 arg2 = &temp2;
34129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34130 }
34131 {
34132 PyThreadState* __tstate = wxPyBeginAllowThreads();
34133 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34138 return resultobj;
34139 fail:
34140 return NULL;
34141 }
34142
34143
34144 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34145 PyObject *resultobj = 0;
34146 wxWindow *arg1 = (wxWindow *) 0 ;
34147 wxSize *arg2 = 0 ;
34148 wxSize result;
34149 void *argp1 = 0 ;
34150 int res1 = 0 ;
34151 wxSize temp2 ;
34152 PyObject * obj0 = 0 ;
34153 PyObject * obj1 = 0 ;
34154 char * kwnames[] = {
34155 (char *) "self",(char *) "sz", NULL
34156 };
34157
34158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34160 if (!SWIG_IsOK(res1)) {
34161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34162 }
34163 arg1 = reinterpret_cast< wxWindow * >(argp1);
34164 {
34165 arg2 = &temp2;
34166 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34167 }
34168 {
34169 PyThreadState* __tstate = wxPyBeginAllowThreads();
34170 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34171 wxPyEndAllowThreads(__tstate);
34172 if (PyErr_Occurred()) SWIG_fail;
34173 }
34174 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34175 return resultobj;
34176 fail:
34177 return NULL;
34178 }
34179
34180
34181 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34182 PyObject *resultobj = 0;
34183 wxWindow *arg1 = (wxWindow *) 0 ;
34184 int arg2 ;
34185 int arg3 ;
34186 void *argp1 = 0 ;
34187 int res1 = 0 ;
34188 int val2 ;
34189 int ecode2 = 0 ;
34190 int val3 ;
34191 int ecode3 = 0 ;
34192 PyObject * obj0 = 0 ;
34193 PyObject * obj1 = 0 ;
34194 PyObject * obj2 = 0 ;
34195 char * kwnames[] = {
34196 (char *) "self",(char *) "x",(char *) "y", NULL
34197 };
34198
34199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34201 if (!SWIG_IsOK(res1)) {
34202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34203 }
34204 arg1 = reinterpret_cast< wxWindow * >(argp1);
34205 ecode2 = SWIG_AsVal_int(obj1, &val2);
34206 if (!SWIG_IsOK(ecode2)) {
34207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34208 }
34209 arg2 = static_cast< int >(val2);
34210 ecode3 = SWIG_AsVal_int(obj2, &val3);
34211 if (!SWIG_IsOK(ecode3)) {
34212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34213 }
34214 arg3 = static_cast< int >(val3);
34215 {
34216 PyThreadState* __tstate = wxPyBeginAllowThreads();
34217 (arg1)->WarpPointer(arg2,arg3);
34218 wxPyEndAllowThreads(__tstate);
34219 if (PyErr_Occurred()) SWIG_fail;
34220 }
34221 resultobj = SWIG_Py_Void();
34222 return resultobj;
34223 fail:
34224 return NULL;
34225 }
34226
34227
34228 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34229 PyObject *resultobj = 0;
34230 wxWindow *arg1 = (wxWindow *) 0 ;
34231 void *argp1 = 0 ;
34232 int res1 = 0 ;
34233 PyObject *swig_obj[1] ;
34234
34235 if (!args) SWIG_fail;
34236 swig_obj[0] = args;
34237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34238 if (!SWIG_IsOK(res1)) {
34239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34240 }
34241 arg1 = reinterpret_cast< wxWindow * >(argp1);
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 (arg1)->CaptureMouse();
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 resultobj = SWIG_Py_Void();
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34256 PyObject *resultobj = 0;
34257 wxWindow *arg1 = (wxWindow *) 0 ;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 PyObject *swig_obj[1] ;
34261
34262 if (!args) SWIG_fail;
34263 swig_obj[0] = args;
34264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34265 if (!SWIG_IsOK(res1)) {
34266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34267 }
34268 arg1 = reinterpret_cast< wxWindow * >(argp1);
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 (arg1)->ReleaseMouse();
34272 wxPyEndAllowThreads(__tstate);
34273 if (PyErr_Occurred()) SWIG_fail;
34274 }
34275 resultobj = SWIG_Py_Void();
34276 return resultobj;
34277 fail:
34278 return NULL;
34279 }
34280
34281
34282 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34283 PyObject *resultobj = 0;
34284 wxWindow *result = 0 ;
34285
34286 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34287 {
34288 if (!wxPyCheckForApp()) SWIG_fail;
34289 PyThreadState* __tstate = wxPyBeginAllowThreads();
34290 result = (wxWindow *)wxWindow::GetCapture();
34291 wxPyEndAllowThreads(__tstate);
34292 if (PyErr_Occurred()) SWIG_fail;
34293 }
34294 {
34295 resultobj = wxPyMake_wxObject(result, 0);
34296 }
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34304 PyObject *resultobj = 0;
34305 wxWindow *arg1 = (wxWindow *) 0 ;
34306 bool result;
34307 void *argp1 = 0 ;
34308 int res1 = 0 ;
34309 PyObject *swig_obj[1] ;
34310
34311 if (!args) SWIG_fail;
34312 swig_obj[0] = args;
34313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34314 if (!SWIG_IsOK(res1)) {
34315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34316 }
34317 arg1 = reinterpret_cast< wxWindow * >(argp1);
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 result = (bool)((wxWindow const *)arg1)->HasCapture();
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 {
34325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34326 }
34327 return resultobj;
34328 fail:
34329 return NULL;
34330 }
34331
34332
34333 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34334 PyObject *resultobj = 0;
34335 wxWindow *arg1 = (wxWindow *) 0 ;
34336 bool arg2 = (bool) true ;
34337 wxRect *arg3 = (wxRect *) NULL ;
34338 void *argp1 = 0 ;
34339 int res1 = 0 ;
34340 bool val2 ;
34341 int ecode2 = 0 ;
34342 void *argp3 = 0 ;
34343 int res3 = 0 ;
34344 PyObject * obj0 = 0 ;
34345 PyObject * obj1 = 0 ;
34346 PyObject * obj2 = 0 ;
34347 char * kwnames[] = {
34348 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34349 };
34350
34351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34353 if (!SWIG_IsOK(res1)) {
34354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34355 }
34356 arg1 = reinterpret_cast< wxWindow * >(argp1);
34357 if (obj1) {
34358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34359 if (!SWIG_IsOK(ecode2)) {
34360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34361 }
34362 arg2 = static_cast< bool >(val2);
34363 }
34364 if (obj2) {
34365 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34366 if (!SWIG_IsOK(res3)) {
34367 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34368 }
34369 arg3 = reinterpret_cast< wxRect * >(argp3);
34370 }
34371 {
34372 PyThreadState* __tstate = wxPyBeginAllowThreads();
34373 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34374 wxPyEndAllowThreads(__tstate);
34375 if (PyErr_Occurred()) SWIG_fail;
34376 }
34377 resultobj = SWIG_Py_Void();
34378 return resultobj;
34379 fail:
34380 return NULL;
34381 }
34382
34383
34384 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34385 PyObject *resultobj = 0;
34386 wxWindow *arg1 = (wxWindow *) 0 ;
34387 wxRect *arg2 = 0 ;
34388 bool arg3 = (bool) true ;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 wxRect temp2 ;
34392 bool val3 ;
34393 int ecode3 = 0 ;
34394 PyObject * obj0 = 0 ;
34395 PyObject * obj1 = 0 ;
34396 PyObject * obj2 = 0 ;
34397 char * kwnames[] = {
34398 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34399 };
34400
34401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34403 if (!SWIG_IsOK(res1)) {
34404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34405 }
34406 arg1 = reinterpret_cast< wxWindow * >(argp1);
34407 {
34408 arg2 = &temp2;
34409 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34410 }
34411 if (obj2) {
34412 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34413 if (!SWIG_IsOK(ecode3)) {
34414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34415 }
34416 arg3 = static_cast< bool >(val3);
34417 }
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_Py_Void();
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 void *argp1 = 0 ;
34435 int res1 = 0 ;
34436 PyObject *swig_obj[1] ;
34437
34438 if (!args) SWIG_fail;
34439 swig_obj[0] = args;
34440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34441 if (!SWIG_IsOK(res1)) {
34442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34443 }
34444 arg1 = reinterpret_cast< wxWindow * >(argp1);
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 (arg1)->Update();
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 resultobj = SWIG_Py_Void();
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34459 PyObject *resultobj = 0;
34460 wxWindow *arg1 = (wxWindow *) 0 ;
34461 void *argp1 = 0 ;
34462 int res1 = 0 ;
34463 PyObject *swig_obj[1] ;
34464
34465 if (!args) SWIG_fail;
34466 swig_obj[0] = args;
34467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34468 if (!SWIG_IsOK(res1)) {
34469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34470 }
34471 arg1 = reinterpret_cast< wxWindow * >(argp1);
34472 {
34473 PyThreadState* __tstate = wxPyBeginAllowThreads();
34474 (arg1)->ClearBackground();
34475 wxPyEndAllowThreads(__tstate);
34476 if (PyErr_Occurred()) SWIG_fail;
34477 }
34478 resultobj = SWIG_Py_Void();
34479 return resultobj;
34480 fail:
34481 return NULL;
34482 }
34483
34484
34485 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34486 PyObject *resultobj = 0;
34487 wxWindow *arg1 = (wxWindow *) 0 ;
34488 void *argp1 = 0 ;
34489 int res1 = 0 ;
34490 PyObject *swig_obj[1] ;
34491
34492 if (!args) SWIG_fail;
34493 swig_obj[0] = args;
34494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34495 if (!SWIG_IsOK(res1)) {
34496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34497 }
34498 arg1 = reinterpret_cast< wxWindow * >(argp1);
34499 {
34500 PyThreadState* __tstate = wxPyBeginAllowThreads();
34501 (arg1)->Freeze();
34502 wxPyEndAllowThreads(__tstate);
34503 if (PyErr_Occurred()) SWIG_fail;
34504 }
34505 resultobj = SWIG_Py_Void();
34506 return resultobj;
34507 fail:
34508 return NULL;
34509 }
34510
34511
34512 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34513 PyObject *resultobj = 0;
34514 wxWindow *arg1 = (wxWindow *) 0 ;
34515 void *argp1 = 0 ;
34516 int res1 = 0 ;
34517 PyObject *swig_obj[1] ;
34518
34519 if (!args) SWIG_fail;
34520 swig_obj[0] = args;
34521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34522 if (!SWIG_IsOK(res1)) {
34523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34524 }
34525 arg1 = reinterpret_cast< wxWindow * >(argp1);
34526 {
34527 PyThreadState* __tstate = wxPyBeginAllowThreads();
34528 (arg1)->Thaw();
34529 wxPyEndAllowThreads(__tstate);
34530 if (PyErr_Occurred()) SWIG_fail;
34531 }
34532 resultobj = SWIG_Py_Void();
34533 return resultobj;
34534 fail:
34535 return NULL;
34536 }
34537
34538
34539 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34540 PyObject *resultobj = 0;
34541 wxWindow *arg1 = (wxWindow *) 0 ;
34542 wxDC *arg2 = 0 ;
34543 void *argp1 = 0 ;
34544 int res1 = 0 ;
34545 void *argp2 = 0 ;
34546 int res2 = 0 ;
34547 PyObject * obj0 = 0 ;
34548 PyObject * obj1 = 0 ;
34549 char * kwnames[] = {
34550 (char *) "self",(char *) "dc", NULL
34551 };
34552
34553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34555 if (!SWIG_IsOK(res1)) {
34556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34557 }
34558 arg1 = reinterpret_cast< wxWindow * >(argp1);
34559 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34560 if (!SWIG_IsOK(res2)) {
34561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34562 }
34563 if (!argp2) {
34564 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34565 }
34566 arg2 = reinterpret_cast< wxDC * >(argp2);
34567 {
34568 PyThreadState* __tstate = wxPyBeginAllowThreads();
34569 (arg1)->PrepareDC(*arg2);
34570 wxPyEndAllowThreads(__tstate);
34571 if (PyErr_Occurred()) SWIG_fail;
34572 }
34573 resultobj = SWIG_Py_Void();
34574 return resultobj;
34575 fail:
34576 return NULL;
34577 }
34578
34579
34580 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34581 PyObject *resultobj = 0;
34582 wxWindow *arg1 = (wxWindow *) 0 ;
34583 wxRegion *result = 0 ;
34584 void *argp1 = 0 ;
34585 int res1 = 0 ;
34586 PyObject *swig_obj[1] ;
34587
34588 if (!args) SWIG_fail;
34589 swig_obj[0] = args;
34590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 {
34598 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34599 result = (wxRegion *) &_result_ref;
34600 }
34601 wxPyEndAllowThreads(__tstate);
34602 if (PyErr_Occurred()) SWIG_fail;
34603 }
34604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34612 PyObject *resultobj = 0;
34613 wxWindow *arg1 = (wxWindow *) 0 ;
34614 wxRect result;
34615 void *argp1 = 0 ;
34616 int res1 = 0 ;
34617 PyObject *swig_obj[1] ;
34618
34619 if (!args) SWIG_fail;
34620 swig_obj[0] = args;
34621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34622 if (!SWIG_IsOK(res1)) {
34623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34624 }
34625 arg1 = reinterpret_cast< wxWindow * >(argp1);
34626 {
34627 PyThreadState* __tstate = wxPyBeginAllowThreads();
34628 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34629 wxPyEndAllowThreads(__tstate);
34630 if (PyErr_Occurred()) SWIG_fail;
34631 }
34632 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34633 return resultobj;
34634 fail:
34635 return NULL;
34636 }
34637
34638
34639 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34640 PyObject *resultobj = 0;
34641 wxWindow *arg1 = (wxWindow *) 0 ;
34642 int arg2 ;
34643 int arg3 ;
34644 int arg4 = (int) 1 ;
34645 int arg5 = (int) 1 ;
34646 bool result;
34647 void *argp1 = 0 ;
34648 int res1 = 0 ;
34649 int val2 ;
34650 int ecode2 = 0 ;
34651 int val3 ;
34652 int ecode3 = 0 ;
34653 int val4 ;
34654 int ecode4 = 0 ;
34655 int val5 ;
34656 int ecode5 = 0 ;
34657 PyObject * obj0 = 0 ;
34658 PyObject * obj1 = 0 ;
34659 PyObject * obj2 = 0 ;
34660 PyObject * obj3 = 0 ;
34661 PyObject * obj4 = 0 ;
34662 char * kwnames[] = {
34663 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34664 };
34665
34666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34668 if (!SWIG_IsOK(res1)) {
34669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34670 }
34671 arg1 = reinterpret_cast< wxWindow * >(argp1);
34672 ecode2 = SWIG_AsVal_int(obj1, &val2);
34673 if (!SWIG_IsOK(ecode2)) {
34674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34675 }
34676 arg2 = static_cast< int >(val2);
34677 ecode3 = SWIG_AsVal_int(obj2, &val3);
34678 if (!SWIG_IsOK(ecode3)) {
34679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34680 }
34681 arg3 = static_cast< int >(val3);
34682 if (obj3) {
34683 ecode4 = SWIG_AsVal_int(obj3, &val4);
34684 if (!SWIG_IsOK(ecode4)) {
34685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34686 }
34687 arg4 = static_cast< int >(val4);
34688 }
34689 if (obj4) {
34690 ecode5 = SWIG_AsVal_int(obj4, &val5);
34691 if (!SWIG_IsOK(ecode5)) {
34692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34693 }
34694 arg5 = static_cast< int >(val5);
34695 }
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 {
34703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34704 }
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 wxPoint *arg2 = 0 ;
34715 bool result;
34716 void *argp1 = 0 ;
34717 int res1 = 0 ;
34718 wxPoint temp2 ;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 char * kwnames[] = {
34722 (char *) "self",(char *) "pt", NULL
34723 };
34724
34725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34727 if (!SWIG_IsOK(res1)) {
34728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34729 }
34730 arg1 = reinterpret_cast< wxWindow * >(argp1);
34731 {
34732 arg2 = &temp2;
34733 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34734 }
34735 {
34736 PyThreadState* __tstate = wxPyBeginAllowThreads();
34737 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 {
34742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34743 }
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj = 0;
34752 wxWindow *arg1 = (wxWindow *) 0 ;
34753 wxRect *arg2 = 0 ;
34754 bool result;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 wxRect temp2 ;
34758 PyObject * obj0 = 0 ;
34759 PyObject * obj1 = 0 ;
34760 char * kwnames[] = {
34761 (char *) "self",(char *) "rect", NULL
34762 };
34763
34764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34766 if (!SWIG_IsOK(res1)) {
34767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34768 }
34769 arg1 = reinterpret_cast< wxWindow * >(argp1);
34770 {
34771 arg2 = &temp2;
34772 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34773 }
34774 {
34775 PyThreadState* __tstate = wxPyBeginAllowThreads();
34776 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34777 wxPyEndAllowThreads(__tstate);
34778 if (PyErr_Occurred()) SWIG_fail;
34779 }
34780 {
34781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34782 }
34783 return resultobj;
34784 fail:
34785 return NULL;
34786 }
34787
34788
34789 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34790 PyObject *resultobj = 0;
34791 wxWindow *arg1 = (wxWindow *) 0 ;
34792 SwigValueWrapper<wxVisualAttributes > result;
34793 void *argp1 = 0 ;
34794 int res1 = 0 ;
34795 PyObject *swig_obj[1] ;
34796
34797 if (!args) SWIG_fail;
34798 swig_obj[0] = args;
34799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34800 if (!SWIG_IsOK(res1)) {
34801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34802 }
34803 arg1 = reinterpret_cast< wxWindow * >(argp1);
34804 {
34805 PyThreadState* __tstate = wxPyBeginAllowThreads();
34806 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34807 wxPyEndAllowThreads(__tstate);
34808 if (PyErr_Occurred()) SWIG_fail;
34809 }
34810 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34811 return resultobj;
34812 fail:
34813 return NULL;
34814 }
34815
34816
34817 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34818 PyObject *resultobj = 0;
34819 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34820 SwigValueWrapper<wxVisualAttributes > result;
34821 int val1 ;
34822 int ecode1 = 0 ;
34823 PyObject * obj0 = 0 ;
34824 char * kwnames[] = {
34825 (char *) "variant", NULL
34826 };
34827
34828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34829 if (obj0) {
34830 ecode1 = SWIG_AsVal_int(obj0, &val1);
34831 if (!SWIG_IsOK(ecode1)) {
34832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34833 }
34834 arg1 = static_cast< wxWindowVariant >(val1);
34835 }
34836 {
34837 if (!wxPyCheckForApp()) SWIG_fail;
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = wxWindow::GetClassDefaultAttributes(arg1);
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 wxColour *arg2 = 0 ;
34854 bool result;
34855 void *argp1 = 0 ;
34856 int res1 = 0 ;
34857 wxColour temp2 ;
34858 PyObject * obj0 = 0 ;
34859 PyObject * obj1 = 0 ;
34860 char * kwnames[] = {
34861 (char *) "self",(char *) "colour", NULL
34862 };
34863
34864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34866 if (!SWIG_IsOK(res1)) {
34867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34868 }
34869 arg1 = reinterpret_cast< wxWindow * >(argp1);
34870 {
34871 arg2 = &temp2;
34872 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34873 }
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 {
34881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34882 }
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34890 PyObject *resultobj = 0;
34891 wxWindow *arg1 = (wxWindow *) 0 ;
34892 wxColour *arg2 = 0 ;
34893 void *argp1 = 0 ;
34894 int res1 = 0 ;
34895 wxColour temp2 ;
34896 PyObject * obj0 = 0 ;
34897 PyObject * obj1 = 0 ;
34898 char * kwnames[] = {
34899 (char *) "self",(char *) "colour", NULL
34900 };
34901
34902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34904 if (!SWIG_IsOK(res1)) {
34905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34906 }
34907 arg1 = reinterpret_cast< wxWindow * >(argp1);
34908 {
34909 arg2 = &temp2;
34910 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34911 }
34912 {
34913 PyThreadState* __tstate = wxPyBeginAllowThreads();
34914 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34915 wxPyEndAllowThreads(__tstate);
34916 if (PyErr_Occurred()) SWIG_fail;
34917 }
34918 resultobj = SWIG_Py_Void();
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34926 PyObject *resultobj = 0;
34927 wxWindow *arg1 = (wxWindow *) 0 ;
34928 wxColour *arg2 = 0 ;
34929 bool result;
34930 void *argp1 = 0 ;
34931 int res1 = 0 ;
34932 wxColour temp2 ;
34933 PyObject * obj0 = 0 ;
34934 PyObject * obj1 = 0 ;
34935 char * kwnames[] = {
34936 (char *) "self",(char *) "colour", NULL
34937 };
34938
34939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34941 if (!SWIG_IsOK(res1)) {
34942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34943 }
34944 arg1 = reinterpret_cast< wxWindow * >(argp1);
34945 {
34946 arg2 = &temp2;
34947 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34948 }
34949 {
34950 PyThreadState* __tstate = wxPyBeginAllowThreads();
34951 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34952 wxPyEndAllowThreads(__tstate);
34953 if (PyErr_Occurred()) SWIG_fail;
34954 }
34955 {
34956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34957 }
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34965 PyObject *resultobj = 0;
34966 wxWindow *arg1 = (wxWindow *) 0 ;
34967 wxColour *arg2 = 0 ;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 wxColour temp2 ;
34971 PyObject * obj0 = 0 ;
34972 PyObject * obj1 = 0 ;
34973 char * kwnames[] = {
34974 (char *) "self",(char *) "colour", NULL
34975 };
34976
34977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34979 if (!SWIG_IsOK(res1)) {
34980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34981 }
34982 arg1 = reinterpret_cast< wxWindow * >(argp1);
34983 {
34984 arg2 = &temp2;
34985 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34986 }
34987 {
34988 PyThreadState* __tstate = wxPyBeginAllowThreads();
34989 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 resultobj = SWIG_Py_Void();
34994 return resultobj;
34995 fail:
34996 return NULL;
34997 }
34998
34999
35000 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35001 PyObject *resultobj = 0;
35002 wxWindow *arg1 = (wxWindow *) 0 ;
35003 wxColour result;
35004 void *argp1 = 0 ;
35005 int res1 = 0 ;
35006 PyObject *swig_obj[1] ;
35007
35008 if (!args) SWIG_fail;
35009 swig_obj[0] = args;
35010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35011 if (!SWIG_IsOK(res1)) {
35012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35013 }
35014 arg1 = reinterpret_cast< wxWindow * >(argp1);
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35018 wxPyEndAllowThreads(__tstate);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 }
35021 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35029 PyObject *resultobj = 0;
35030 wxWindow *arg1 = (wxWindow *) 0 ;
35031 wxColour result;
35032 void *argp1 = 0 ;
35033 int res1 = 0 ;
35034 PyObject *swig_obj[1] ;
35035
35036 if (!args) SWIG_fail;
35037 swig_obj[0] = args;
35038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35039 if (!SWIG_IsOK(res1)) {
35040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35041 }
35042 arg1 = reinterpret_cast< wxWindow * >(argp1);
35043 {
35044 PyThreadState* __tstate = wxPyBeginAllowThreads();
35045 result = ((wxWindow const *)arg1)->GetForegroundColour();
35046 wxPyEndAllowThreads(__tstate);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 }
35049 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35057 PyObject *resultobj = 0;
35058 wxWindow *arg1 = (wxWindow *) 0 ;
35059 bool result;
35060 void *argp1 = 0 ;
35061 int res1 = 0 ;
35062 PyObject *swig_obj[1] ;
35063
35064 if (!args) SWIG_fail;
35065 swig_obj[0] = args;
35066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35067 if (!SWIG_IsOK(res1)) {
35068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35069 }
35070 arg1 = reinterpret_cast< wxWindow * >(argp1);
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 {
35078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35079 }
35080 return resultobj;
35081 fail:
35082 return NULL;
35083 }
35084
35085
35086 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35087 PyObject *resultobj = 0;
35088 wxWindow *arg1 = (wxWindow *) 0 ;
35089 bool result;
35090 void *argp1 = 0 ;
35091 int res1 = 0 ;
35092 PyObject *swig_obj[1] ;
35093
35094 if (!args) SWIG_fail;
35095 swig_obj[0] = args;
35096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35097 if (!SWIG_IsOK(res1)) {
35098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35099 }
35100 arg1 = reinterpret_cast< wxWindow * >(argp1);
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 {
35108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35109 }
35110 return resultobj;
35111 fail:
35112 return NULL;
35113 }
35114
35115
35116 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35117 PyObject *resultobj = 0;
35118 wxWindow *arg1 = (wxWindow *) 0 ;
35119 wxBackgroundStyle arg2 ;
35120 bool result;
35121 void *argp1 = 0 ;
35122 int res1 = 0 ;
35123 int val2 ;
35124 int ecode2 = 0 ;
35125 PyObject * obj0 = 0 ;
35126 PyObject * obj1 = 0 ;
35127 char * kwnames[] = {
35128 (char *) "self",(char *) "style", NULL
35129 };
35130
35131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35133 if (!SWIG_IsOK(res1)) {
35134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35135 }
35136 arg1 = reinterpret_cast< wxWindow * >(argp1);
35137 ecode2 = SWIG_AsVal_int(obj1, &val2);
35138 if (!SWIG_IsOK(ecode2)) {
35139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35140 }
35141 arg2 = static_cast< wxBackgroundStyle >(val2);
35142 {
35143 PyThreadState* __tstate = wxPyBeginAllowThreads();
35144 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35145 wxPyEndAllowThreads(__tstate);
35146 if (PyErr_Occurred()) SWIG_fail;
35147 }
35148 {
35149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35150 }
35151 return resultobj;
35152 fail:
35153 return NULL;
35154 }
35155
35156
35157 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35158 PyObject *resultobj = 0;
35159 wxWindow *arg1 = (wxWindow *) 0 ;
35160 wxBackgroundStyle result;
35161 void *argp1 = 0 ;
35162 int res1 = 0 ;
35163 PyObject *swig_obj[1] ;
35164
35165 if (!args) SWIG_fail;
35166 swig_obj[0] = args;
35167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35168 if (!SWIG_IsOK(res1)) {
35169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35170 }
35171 arg1 = reinterpret_cast< wxWindow * >(argp1);
35172 {
35173 PyThreadState* __tstate = wxPyBeginAllowThreads();
35174 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35175 wxPyEndAllowThreads(__tstate);
35176 if (PyErr_Occurred()) SWIG_fail;
35177 }
35178 resultobj = SWIG_From_int(static_cast< int >(result));
35179 return resultobj;
35180 fail:
35181 return NULL;
35182 }
35183
35184
35185 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35186 PyObject *resultobj = 0;
35187 wxWindow *arg1 = (wxWindow *) 0 ;
35188 bool result;
35189 void *argp1 = 0 ;
35190 int res1 = 0 ;
35191 PyObject *swig_obj[1] ;
35192
35193 if (!args) SWIG_fail;
35194 swig_obj[0] = args;
35195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35196 if (!SWIG_IsOK(res1)) {
35197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35198 }
35199 arg1 = reinterpret_cast< wxWindow * >(argp1);
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 result = (bool)(arg1)->HasTransparentBackground();
35203 wxPyEndAllowThreads(__tstate);
35204 if (PyErr_Occurred()) SWIG_fail;
35205 }
35206 {
35207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35208 }
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35216 PyObject *resultobj = 0;
35217 wxWindow *arg1 = (wxWindow *) 0 ;
35218 wxCursor *arg2 = 0 ;
35219 bool result;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 void *argp2 = 0 ;
35223 int res2 = 0 ;
35224 PyObject * obj0 = 0 ;
35225 PyObject * obj1 = 0 ;
35226 char * kwnames[] = {
35227 (char *) "self",(char *) "cursor", NULL
35228 };
35229
35230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35232 if (!SWIG_IsOK(res1)) {
35233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35234 }
35235 arg1 = reinterpret_cast< wxWindow * >(argp1);
35236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35237 if (!SWIG_IsOK(res2)) {
35238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35239 }
35240 if (!argp2) {
35241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35242 }
35243 arg2 = reinterpret_cast< wxCursor * >(argp2);
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 {
35251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35252 }
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxCursor result;
35263 void *argp1 = 0 ;
35264 int res1 = 0 ;
35265 PyObject *swig_obj[1] ;
35266
35267 if (!args) SWIG_fail;
35268 swig_obj[0] = args;
35269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35270 if (!SWIG_IsOK(res1)) {
35271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35272 }
35273 arg1 = reinterpret_cast< wxWindow * >(argp1);
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 result = (arg1)->GetCursor();
35277 wxPyEndAllowThreads(__tstate);
35278 if (PyErr_Occurred()) SWIG_fail;
35279 }
35280 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj = 0;
35289 wxWindow *arg1 = (wxWindow *) 0 ;
35290 wxFont *arg2 = 0 ;
35291 bool result;
35292 void *argp1 = 0 ;
35293 int res1 = 0 ;
35294 void *argp2 = 0 ;
35295 int res2 = 0 ;
35296 PyObject * obj0 = 0 ;
35297 PyObject * obj1 = 0 ;
35298 char * kwnames[] = {
35299 (char *) "self",(char *) "font", NULL
35300 };
35301
35302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35304 if (!SWIG_IsOK(res1)) {
35305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35306 }
35307 arg1 = reinterpret_cast< wxWindow * >(argp1);
35308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35309 if (!SWIG_IsOK(res2)) {
35310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35311 }
35312 if (!argp2) {
35313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35314 }
35315 arg2 = reinterpret_cast< wxFont * >(argp2);
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 {
35323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35324 }
35325 return resultobj;
35326 fail:
35327 return NULL;
35328 }
35329
35330
35331 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35332 PyObject *resultobj = 0;
35333 wxWindow *arg1 = (wxWindow *) 0 ;
35334 wxFont *arg2 = 0 ;
35335 void *argp1 = 0 ;
35336 int res1 = 0 ;
35337 void *argp2 = 0 ;
35338 int res2 = 0 ;
35339 PyObject * obj0 = 0 ;
35340 PyObject * obj1 = 0 ;
35341 char * kwnames[] = {
35342 (char *) "self",(char *) "font", NULL
35343 };
35344
35345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35347 if (!SWIG_IsOK(res1)) {
35348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35349 }
35350 arg1 = reinterpret_cast< wxWindow * >(argp1);
35351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35352 if (!SWIG_IsOK(res2)) {
35353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35354 }
35355 if (!argp2) {
35356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35357 }
35358 arg2 = reinterpret_cast< wxFont * >(argp2);
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 (arg1)->SetOwnFont((wxFont const &)*arg2);
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 resultobj = SWIG_Py_Void();
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35373 PyObject *resultobj = 0;
35374 wxWindow *arg1 = (wxWindow *) 0 ;
35375 wxFont result;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 PyObject *swig_obj[1] ;
35379
35380 if (!args) SWIG_fail;
35381 swig_obj[0] = args;
35382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35383 if (!SWIG_IsOK(res1)) {
35384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35385 }
35386 arg1 = reinterpret_cast< wxWindow * >(argp1);
35387 {
35388 PyThreadState* __tstate = wxPyBeginAllowThreads();
35389 result = (arg1)->GetFont();
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35401 PyObject *resultobj = 0;
35402 wxWindow *arg1 = (wxWindow *) 0 ;
35403 wxCaret *arg2 = (wxCaret *) 0 ;
35404 void *argp1 = 0 ;
35405 int res1 = 0 ;
35406 int res2 = 0 ;
35407 PyObject * obj0 = 0 ;
35408 PyObject * obj1 = 0 ;
35409 char * kwnames[] = {
35410 (char *) "self",(char *) "caret", NULL
35411 };
35412
35413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35415 if (!SWIG_IsOK(res1)) {
35416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35417 }
35418 arg1 = reinterpret_cast< wxWindow * >(argp1);
35419 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35420 if (!SWIG_IsOK(res2)) {
35421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35422 }
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 (arg1)->SetCaret(arg2);
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 resultobj = SWIG_Py_Void();
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35437 PyObject *resultobj = 0;
35438 wxWindow *arg1 = (wxWindow *) 0 ;
35439 wxCaret *result = 0 ;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35449 }
35450 arg1 = reinterpret_cast< wxWindow * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35458 return resultobj;
35459 fail:
35460 return NULL;
35461 }
35462
35463
35464 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35465 PyObject *resultobj = 0;
35466 wxWindow *arg1 = (wxWindow *) 0 ;
35467 int result;
35468 void *argp1 = 0 ;
35469 int res1 = 0 ;
35470 PyObject *swig_obj[1] ;
35471
35472 if (!args) SWIG_fail;
35473 swig_obj[0] = args;
35474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35475 if (!SWIG_IsOK(res1)) {
35476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35477 }
35478 arg1 = reinterpret_cast< wxWindow * >(argp1);
35479 {
35480 PyThreadState* __tstate = wxPyBeginAllowThreads();
35481 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35482 wxPyEndAllowThreads(__tstate);
35483 if (PyErr_Occurred()) SWIG_fail;
35484 }
35485 resultobj = SWIG_From_int(static_cast< int >(result));
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35493 PyObject *resultobj = 0;
35494 wxWindow *arg1 = (wxWindow *) 0 ;
35495 int result;
35496 void *argp1 = 0 ;
35497 int res1 = 0 ;
35498 PyObject *swig_obj[1] ;
35499
35500 if (!args) SWIG_fail;
35501 swig_obj[0] = args;
35502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35503 if (!SWIG_IsOK(res1)) {
35504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35505 }
35506 arg1 = reinterpret_cast< wxWindow * >(argp1);
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35510 wxPyEndAllowThreads(__tstate);
35511 if (PyErr_Occurred()) SWIG_fail;
35512 }
35513 resultobj = SWIG_From_int(static_cast< int >(result));
35514 return resultobj;
35515 fail:
35516 return NULL;
35517 }
35518
35519
35520 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35521 PyObject *resultobj = 0;
35522 wxWindow *arg1 = (wxWindow *) 0 ;
35523 wxString *arg2 = 0 ;
35524 int *arg3 = (int *) 0 ;
35525 int *arg4 = (int *) 0 ;
35526 void *argp1 = 0 ;
35527 int res1 = 0 ;
35528 bool temp2 = false ;
35529 int temp3 ;
35530 int res3 = SWIG_TMPOBJ ;
35531 int temp4 ;
35532 int res4 = SWIG_TMPOBJ ;
35533 PyObject * obj0 = 0 ;
35534 PyObject * obj1 = 0 ;
35535 char * kwnames[] = {
35536 (char *) "self",(char *) "string", NULL
35537 };
35538
35539 arg3 = &temp3;
35540 arg4 = &temp4;
35541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35543 if (!SWIG_IsOK(res1)) {
35544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35545 }
35546 arg1 = reinterpret_cast< wxWindow * >(argp1);
35547 {
35548 arg2 = wxString_in_helper(obj1);
35549 if (arg2 == NULL) SWIG_fail;
35550 temp2 = true;
35551 }
35552 {
35553 PyThreadState* __tstate = wxPyBeginAllowThreads();
35554 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35555 wxPyEndAllowThreads(__tstate);
35556 if (PyErr_Occurred()) SWIG_fail;
35557 }
35558 resultobj = SWIG_Py_Void();
35559 if (SWIG_IsTmpObj(res3)) {
35560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35561 } else {
35562 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35564 }
35565 if (SWIG_IsTmpObj(res4)) {
35566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35567 } else {
35568 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35570 }
35571 {
35572 if (temp2)
35573 delete arg2;
35574 }
35575 return resultobj;
35576 fail:
35577 {
35578 if (temp2)
35579 delete arg2;
35580 }
35581 return NULL;
35582 }
35583
35584
35585 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35586 PyObject *resultobj = 0;
35587 wxWindow *arg1 = (wxWindow *) 0 ;
35588 wxString *arg2 = 0 ;
35589 int *arg3 = (int *) 0 ;
35590 int *arg4 = (int *) 0 ;
35591 int *arg5 = (int *) 0 ;
35592 int *arg6 = (int *) 0 ;
35593 wxFont *arg7 = (wxFont *) NULL ;
35594 void *argp1 = 0 ;
35595 int res1 = 0 ;
35596 bool temp2 = false ;
35597 int temp3 ;
35598 int res3 = SWIG_TMPOBJ ;
35599 int temp4 ;
35600 int res4 = SWIG_TMPOBJ ;
35601 int temp5 ;
35602 int res5 = SWIG_TMPOBJ ;
35603 int temp6 ;
35604 int res6 = SWIG_TMPOBJ ;
35605 void *argp7 = 0 ;
35606 int res7 = 0 ;
35607 PyObject * obj0 = 0 ;
35608 PyObject * obj1 = 0 ;
35609 PyObject * obj2 = 0 ;
35610 char * kwnames[] = {
35611 (char *) "self",(char *) "string",(char *) "font", NULL
35612 };
35613
35614 arg3 = &temp3;
35615 arg4 = &temp4;
35616 arg5 = &temp5;
35617 arg6 = &temp6;
35618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35620 if (!SWIG_IsOK(res1)) {
35621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35622 }
35623 arg1 = reinterpret_cast< wxWindow * >(argp1);
35624 {
35625 arg2 = wxString_in_helper(obj1);
35626 if (arg2 == NULL) SWIG_fail;
35627 temp2 = true;
35628 }
35629 if (obj2) {
35630 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35631 if (!SWIG_IsOK(res7)) {
35632 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35633 }
35634 arg7 = reinterpret_cast< wxFont * >(argp7);
35635 }
35636 {
35637 PyThreadState* __tstate = wxPyBeginAllowThreads();
35638 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35639 wxPyEndAllowThreads(__tstate);
35640 if (PyErr_Occurred()) SWIG_fail;
35641 }
35642 resultobj = SWIG_Py_Void();
35643 if (SWIG_IsTmpObj(res3)) {
35644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35645 } else {
35646 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35648 }
35649 if (SWIG_IsTmpObj(res4)) {
35650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35651 } else {
35652 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35653 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35654 }
35655 if (SWIG_IsTmpObj(res5)) {
35656 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35657 } else {
35658 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35659 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35660 }
35661 if (SWIG_IsTmpObj(res6)) {
35662 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35663 } else {
35664 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35666 }
35667 {
35668 if (temp2)
35669 delete arg2;
35670 }
35671 return resultobj;
35672 fail:
35673 {
35674 if (temp2)
35675 delete arg2;
35676 }
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35682 PyObject *resultobj = 0;
35683 wxWindow *arg1 = (wxWindow *) 0 ;
35684 int *arg2 = (int *) 0 ;
35685 int *arg3 = (int *) 0 ;
35686 void *argp1 = 0 ;
35687 int res1 = 0 ;
35688 int temp2 ;
35689 int res2 = 0 ;
35690 int temp3 ;
35691 int res3 = 0 ;
35692 PyObject * obj0 = 0 ;
35693 PyObject * obj1 = 0 ;
35694 PyObject * obj2 = 0 ;
35695 char * kwnames[] = {
35696 (char *) "self",(char *) "x",(char *) "y", NULL
35697 };
35698
35699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35701 if (!SWIG_IsOK(res1)) {
35702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35706 int val;
35707 int ecode = SWIG_AsVal_int(obj1, &val);
35708 if (!SWIG_IsOK(ecode)) {
35709 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35710 }
35711 temp2 = static_cast< int >(val);
35712 arg2 = &temp2;
35713 res2 = SWIG_AddTmpMask(ecode);
35714 }
35715 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35716 int val;
35717 int ecode = SWIG_AsVal_int(obj2, &val);
35718 if (!SWIG_IsOK(ecode)) {
35719 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35720 }
35721 temp3 = static_cast< int >(val);
35722 arg3 = &temp3;
35723 res3 = SWIG_AddTmpMask(ecode);
35724 }
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 resultobj = SWIG_Py_Void();
35732 if (SWIG_IsTmpObj(res2)) {
35733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35734 } else {
35735 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35737 }
35738 if (SWIG_IsTmpObj(res3)) {
35739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35740 } else {
35741 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35743 }
35744 return resultobj;
35745 fail:
35746 return NULL;
35747 }
35748
35749
35750 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35751 PyObject *resultobj = 0;
35752 wxWindow *arg1 = (wxWindow *) 0 ;
35753 int *arg2 = (int *) 0 ;
35754 int *arg3 = (int *) 0 ;
35755 void *argp1 = 0 ;
35756 int res1 = 0 ;
35757 int temp2 ;
35758 int res2 = 0 ;
35759 int temp3 ;
35760 int res3 = 0 ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 PyObject * obj2 = 0 ;
35764 char * kwnames[] = {
35765 (char *) "self",(char *) "x",(char *) "y", NULL
35766 };
35767
35768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35770 if (!SWIG_IsOK(res1)) {
35771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35772 }
35773 arg1 = reinterpret_cast< wxWindow * >(argp1);
35774 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35775 int val;
35776 int ecode = SWIG_AsVal_int(obj1, &val);
35777 if (!SWIG_IsOK(ecode)) {
35778 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35779 }
35780 temp2 = static_cast< int >(val);
35781 arg2 = &temp2;
35782 res2 = SWIG_AddTmpMask(ecode);
35783 }
35784 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35785 int val;
35786 int ecode = SWIG_AsVal_int(obj2, &val);
35787 if (!SWIG_IsOK(ecode)) {
35788 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35789 }
35790 temp3 = static_cast< int >(val);
35791 arg3 = &temp3;
35792 res3 = SWIG_AddTmpMask(ecode);
35793 }
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35797 wxPyEndAllowThreads(__tstate);
35798 if (PyErr_Occurred()) SWIG_fail;
35799 }
35800 resultobj = SWIG_Py_Void();
35801 if (SWIG_IsTmpObj(res2)) {
35802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35803 } else {
35804 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35806 }
35807 if (SWIG_IsTmpObj(res3)) {
35808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35809 } else {
35810 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35812 }
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxWindow *arg1 = (wxWindow *) 0 ;
35822 wxPoint *arg2 = 0 ;
35823 wxPoint result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 wxPoint temp2 ;
35827 PyObject * obj0 = 0 ;
35828 PyObject * obj1 = 0 ;
35829 char * kwnames[] = {
35830 (char *) "self",(char *) "pt", NULL
35831 };
35832
35833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35835 if (!SWIG_IsOK(res1)) {
35836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35837 }
35838 arg1 = reinterpret_cast< wxWindow * >(argp1);
35839 {
35840 arg2 = &temp2;
35841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35842 }
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 wxPoint *arg2 = 0 ;
35860 wxPoint result;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 wxPoint temp2 ;
35864 PyObject * obj0 = 0 ;
35865 PyObject * obj1 = 0 ;
35866 char * kwnames[] = {
35867 (char *) "self",(char *) "pt", NULL
35868 };
35869
35870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35872 if (!SWIG_IsOK(res1)) {
35873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35874 }
35875 arg1 = reinterpret_cast< wxWindow * >(argp1);
35876 {
35877 arg2 = &temp2;
35878 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35879 }
35880 {
35881 PyThreadState* __tstate = wxPyBeginAllowThreads();
35882 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35883 wxPyEndAllowThreads(__tstate);
35884 if (PyErr_Occurred()) SWIG_fail;
35885 }
35886 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35887 return resultobj;
35888 fail:
35889 return NULL;
35890 }
35891
35892
35893 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35894 PyObject *resultobj = 0;
35895 wxWindow *arg1 = (wxWindow *) 0 ;
35896 int arg2 ;
35897 int arg3 ;
35898 wxHitTest result;
35899 void *argp1 = 0 ;
35900 int res1 = 0 ;
35901 int val2 ;
35902 int ecode2 = 0 ;
35903 int val3 ;
35904 int ecode3 = 0 ;
35905 PyObject * obj0 = 0 ;
35906 PyObject * obj1 = 0 ;
35907 PyObject * obj2 = 0 ;
35908 char * kwnames[] = {
35909 (char *) "self",(char *) "x",(char *) "y", NULL
35910 };
35911
35912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35914 if (!SWIG_IsOK(res1)) {
35915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35916 }
35917 arg1 = reinterpret_cast< wxWindow * >(argp1);
35918 ecode2 = SWIG_AsVal_int(obj1, &val2);
35919 if (!SWIG_IsOK(ecode2)) {
35920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35921 }
35922 arg2 = static_cast< int >(val2);
35923 ecode3 = SWIG_AsVal_int(obj2, &val3);
35924 if (!SWIG_IsOK(ecode3)) {
35925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35926 }
35927 arg3 = static_cast< int >(val3);
35928 {
35929 PyThreadState* __tstate = wxPyBeginAllowThreads();
35930 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 resultobj = SWIG_From_int(static_cast< int >(result));
35935 return resultobj;
35936 fail:
35937 return NULL;
35938 }
35939
35940
35941 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35942 PyObject *resultobj = 0;
35943 wxWindow *arg1 = (wxWindow *) 0 ;
35944 wxPoint *arg2 = 0 ;
35945 wxHitTest result;
35946 void *argp1 = 0 ;
35947 int res1 = 0 ;
35948 wxPoint temp2 ;
35949 PyObject * obj0 = 0 ;
35950 PyObject * obj1 = 0 ;
35951 char * kwnames[] = {
35952 (char *) "self",(char *) "pt", NULL
35953 };
35954
35955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35957 if (!SWIG_IsOK(res1)) {
35958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35959 }
35960 arg1 = reinterpret_cast< wxWindow * >(argp1);
35961 {
35962 arg2 = &temp2;
35963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_From_int(static_cast< int >(result));
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 long arg2 ;
35982 wxBorder result;
35983 void *argp1 = 0 ;
35984 int res1 = 0 ;
35985 long val2 ;
35986 int ecode2 = 0 ;
35987
35988 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35990 if (!SWIG_IsOK(res1)) {
35991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35992 }
35993 arg1 = reinterpret_cast< wxWindow * >(argp1);
35994 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35995 if (!SWIG_IsOK(ecode2)) {
35996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35997 }
35998 arg2 = static_cast< long >(val2);
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 resultobj = SWIG_From_int(static_cast< int >(result));
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36013 PyObject *resultobj = 0;
36014 wxWindow *arg1 = (wxWindow *) 0 ;
36015 wxBorder result;
36016 void *argp1 = 0 ;
36017 int res1 = 0 ;
36018
36019 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36021 if (!SWIG_IsOK(res1)) {
36022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36023 }
36024 arg1 = reinterpret_cast< wxWindow * >(argp1);
36025 {
36026 PyThreadState* __tstate = wxPyBeginAllowThreads();
36027 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36028 wxPyEndAllowThreads(__tstate);
36029 if (PyErr_Occurred()) SWIG_fail;
36030 }
36031 resultobj = SWIG_From_int(static_cast< int >(result));
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36039 int argc;
36040 PyObject *argv[3];
36041
36042 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36043 --argc;
36044 if (argc == 1) {
36045 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36046 }
36047 if (argc == 2) {
36048 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36049 }
36050
36051 fail:
36052 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36053 return NULL;
36054 }
36055
36056
36057 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36058 PyObject *resultobj = 0;
36059 wxWindow *arg1 = (wxWindow *) 0 ;
36060 long arg2 = (long) wxUPDATE_UI_NONE ;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 long val2 ;
36064 int ecode2 = 0 ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char * kwnames[] = {
36068 (char *) "self",(char *) "flags", NULL
36069 };
36070
36071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36073 if (!SWIG_IsOK(res1)) {
36074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36075 }
36076 arg1 = reinterpret_cast< wxWindow * >(argp1);
36077 if (obj1) {
36078 ecode2 = SWIG_AsVal_long(obj1, &val2);
36079 if (!SWIG_IsOK(ecode2)) {
36080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36081 }
36082 arg2 = static_cast< long >(val2);
36083 }
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 (arg1)->UpdateWindowUI(arg2);
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 resultobj = SWIG_Py_Void();
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 wxMenu *arg2 = (wxMenu *) 0 ;
36101 int arg3 = (int) -1 ;
36102 int arg4 = (int) -1 ;
36103 bool result;
36104 void *argp1 = 0 ;
36105 int res1 = 0 ;
36106 void *argp2 = 0 ;
36107 int res2 = 0 ;
36108 int val3 ;
36109 int ecode3 = 0 ;
36110 int val4 ;
36111 int ecode4 = 0 ;
36112 PyObject * obj0 = 0 ;
36113 PyObject * obj1 = 0 ;
36114 PyObject * obj2 = 0 ;
36115 PyObject * obj3 = 0 ;
36116 char * kwnames[] = {
36117 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36118 };
36119
36120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36122 if (!SWIG_IsOK(res1)) {
36123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36124 }
36125 arg1 = reinterpret_cast< wxWindow * >(argp1);
36126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36127 if (!SWIG_IsOK(res2)) {
36128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36129 }
36130 arg2 = reinterpret_cast< wxMenu * >(argp2);
36131 if (obj2) {
36132 ecode3 = SWIG_AsVal_int(obj2, &val3);
36133 if (!SWIG_IsOK(ecode3)) {
36134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36135 }
36136 arg3 = static_cast< int >(val3);
36137 }
36138 if (obj3) {
36139 ecode4 = SWIG_AsVal_int(obj3, &val4);
36140 if (!SWIG_IsOK(ecode4)) {
36141 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36142 }
36143 arg4 = static_cast< int >(val4);
36144 }
36145 {
36146 PyThreadState* __tstate = wxPyBeginAllowThreads();
36147 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36148 wxPyEndAllowThreads(__tstate);
36149 if (PyErr_Occurred()) SWIG_fail;
36150 }
36151 {
36152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36153 }
36154 return resultobj;
36155 fail:
36156 return NULL;
36157 }
36158
36159
36160 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36161 PyObject *resultobj = 0;
36162 wxWindow *arg1 = (wxWindow *) 0 ;
36163 wxMenu *arg2 = (wxMenu *) 0 ;
36164 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36165 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36166 bool result;
36167 void *argp1 = 0 ;
36168 int res1 = 0 ;
36169 void *argp2 = 0 ;
36170 int res2 = 0 ;
36171 wxPoint temp3 ;
36172 PyObject * obj0 = 0 ;
36173 PyObject * obj1 = 0 ;
36174 PyObject * obj2 = 0 ;
36175 char * kwnames[] = {
36176 (char *) "self",(char *) "menu",(char *) "pos", NULL
36177 };
36178
36179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36181 if (!SWIG_IsOK(res1)) {
36182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36183 }
36184 arg1 = reinterpret_cast< wxWindow * >(argp1);
36185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36186 if (!SWIG_IsOK(res2)) {
36187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36188 }
36189 arg2 = reinterpret_cast< wxMenu * >(argp2);
36190 if (obj2) {
36191 {
36192 arg3 = &temp3;
36193 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36194 }
36195 }
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 {
36203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36204 }
36205 return resultobj;
36206 fail:
36207 return NULL;
36208 }
36209
36210
36211 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36212 PyObject *resultobj = 0;
36213 wxWindow *arg1 = (wxWindow *) 0 ;
36214 bool result;
36215 void *argp1 = 0 ;
36216 int res1 = 0 ;
36217 PyObject *swig_obj[1] ;
36218
36219 if (!args) SWIG_fail;
36220 swig_obj[0] = args;
36221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36222 if (!SWIG_IsOK(res1)) {
36223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36224 }
36225 arg1 = reinterpret_cast< wxWindow * >(argp1);
36226 {
36227 PyThreadState* __tstate = wxPyBeginAllowThreads();
36228 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36229 wxPyEndAllowThreads(__tstate);
36230 if (PyErr_Occurred()) SWIG_fail;
36231 }
36232 {
36233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36234 }
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 long result;
36245 void *argp1 = 0 ;
36246 int res1 = 0 ;
36247 PyObject *swig_obj[1] ;
36248
36249 if (!args) SWIG_fail;
36250 swig_obj[0] = args;
36251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36252 if (!SWIG_IsOK(res1)) {
36253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36254 }
36255 arg1 = reinterpret_cast< wxWindow * >(argp1);
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 result = (long)wxWindow_GetHandle(arg1);
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 resultobj = SWIG_From_long(static_cast< long >(result));
36263 return resultobj;
36264 fail:
36265 return NULL;
36266 }
36267
36268
36269 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36270 PyObject *resultobj = 0;
36271 wxWindow *arg1 = (wxWindow *) 0 ;
36272 long arg2 ;
36273 void *argp1 = 0 ;
36274 int res1 = 0 ;
36275 long val2 ;
36276 int ecode2 = 0 ;
36277 PyObject * obj0 = 0 ;
36278 PyObject * obj1 = 0 ;
36279 char * kwnames[] = {
36280 (char *) "self",(char *) "handle", NULL
36281 };
36282
36283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36285 if (!SWIG_IsOK(res1)) {
36286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36287 }
36288 arg1 = reinterpret_cast< wxWindow * >(argp1);
36289 ecode2 = SWIG_AsVal_long(obj1, &val2);
36290 if (!SWIG_IsOK(ecode2)) {
36291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36292 }
36293 arg2 = static_cast< long >(val2);
36294 {
36295 PyThreadState* __tstate = wxPyBeginAllowThreads();
36296 wxWindow_AssociateHandle(arg1,arg2);
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 resultobj = SWIG_Py_Void();
36301 return resultobj;
36302 fail:
36303 return NULL;
36304 }
36305
36306
36307 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36308 PyObject *resultobj = 0;
36309 wxWindow *arg1 = (wxWindow *) 0 ;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 PyObject *swig_obj[1] ;
36313
36314 if (!args) SWIG_fail;
36315 swig_obj[0] = args;
36316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36317 if (!SWIG_IsOK(res1)) {
36318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36319 }
36320 arg1 = reinterpret_cast< wxWindow * >(argp1);
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 (arg1)->DissociateHandle();
36324 wxPyEndAllowThreads(__tstate);
36325 if (PyErr_Occurred()) SWIG_fail;
36326 }
36327 resultobj = SWIG_Py_Void();
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36335 PyObject *resultobj = 0;
36336 wxWindow *arg1 = (wxWindow *) 0 ;
36337 int arg2 ;
36338 bool result;
36339 void *argp1 = 0 ;
36340 int res1 = 0 ;
36341 int val2 ;
36342 int ecode2 = 0 ;
36343 PyObject * obj0 = 0 ;
36344 PyObject * obj1 = 0 ;
36345 char * kwnames[] = {
36346 (char *) "self",(char *) "orient", NULL
36347 };
36348
36349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36351 if (!SWIG_IsOK(res1)) {
36352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36353 }
36354 arg1 = reinterpret_cast< wxWindow * >(argp1);
36355 ecode2 = SWIG_AsVal_int(obj1, &val2);
36356 if (!SWIG_IsOK(ecode2)) {
36357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36358 }
36359 arg2 = static_cast< int >(val2);
36360 {
36361 PyThreadState* __tstate = wxPyBeginAllowThreads();
36362 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 {
36367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36368 }
36369 return resultobj;
36370 fail:
36371 return NULL;
36372 }
36373
36374
36375 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36376 PyObject *resultobj = 0;
36377 wxWindow *arg1 = (wxWindow *) 0 ;
36378 int arg2 ;
36379 int arg3 ;
36380 int arg4 ;
36381 int arg5 ;
36382 bool arg6 = (bool) true ;
36383 void *argp1 = 0 ;
36384 int res1 = 0 ;
36385 int val2 ;
36386 int ecode2 = 0 ;
36387 int val3 ;
36388 int ecode3 = 0 ;
36389 int val4 ;
36390 int ecode4 = 0 ;
36391 int val5 ;
36392 int ecode5 = 0 ;
36393 bool val6 ;
36394 int ecode6 = 0 ;
36395 PyObject * obj0 = 0 ;
36396 PyObject * obj1 = 0 ;
36397 PyObject * obj2 = 0 ;
36398 PyObject * obj3 = 0 ;
36399 PyObject * obj4 = 0 ;
36400 PyObject * obj5 = 0 ;
36401 char * kwnames[] = {
36402 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36403 };
36404
36405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36407 if (!SWIG_IsOK(res1)) {
36408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36409 }
36410 arg1 = reinterpret_cast< wxWindow * >(argp1);
36411 ecode2 = SWIG_AsVal_int(obj1, &val2);
36412 if (!SWIG_IsOK(ecode2)) {
36413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36414 }
36415 arg2 = static_cast< int >(val2);
36416 ecode3 = SWIG_AsVal_int(obj2, &val3);
36417 if (!SWIG_IsOK(ecode3)) {
36418 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36419 }
36420 arg3 = static_cast< int >(val3);
36421 ecode4 = SWIG_AsVal_int(obj3, &val4);
36422 if (!SWIG_IsOK(ecode4)) {
36423 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36424 }
36425 arg4 = static_cast< int >(val4);
36426 ecode5 = SWIG_AsVal_int(obj4, &val5);
36427 if (!SWIG_IsOK(ecode5)) {
36428 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36429 }
36430 arg5 = static_cast< int >(val5);
36431 if (obj5) {
36432 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36433 if (!SWIG_IsOK(ecode6)) {
36434 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36435 }
36436 arg6 = static_cast< bool >(val6);
36437 }
36438 {
36439 PyThreadState* __tstate = wxPyBeginAllowThreads();
36440 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 resultobj = SWIG_Py_Void();
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 int arg2 ;
36455 int arg3 ;
36456 bool arg4 = (bool) true ;
36457 void *argp1 = 0 ;
36458 int res1 = 0 ;
36459 int val2 ;
36460 int ecode2 = 0 ;
36461 int val3 ;
36462 int ecode3 = 0 ;
36463 bool val4 ;
36464 int ecode4 = 0 ;
36465 PyObject * obj0 = 0 ;
36466 PyObject * obj1 = 0 ;
36467 PyObject * obj2 = 0 ;
36468 PyObject * obj3 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 ecode2 = SWIG_AsVal_int(obj1, &val2);
36480 if (!SWIG_IsOK(ecode2)) {
36481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36482 }
36483 arg2 = static_cast< int >(val2);
36484 ecode3 = SWIG_AsVal_int(obj2, &val3);
36485 if (!SWIG_IsOK(ecode3)) {
36486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36487 }
36488 arg3 = static_cast< int >(val3);
36489 if (obj3) {
36490 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36491 if (!SWIG_IsOK(ecode4)) {
36492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36493 }
36494 arg4 = static_cast< bool >(val4);
36495 }
36496 {
36497 PyThreadState* __tstate = wxPyBeginAllowThreads();
36498 (arg1)->SetScrollPos(arg2,arg3,arg4);
36499 wxPyEndAllowThreads(__tstate);
36500 if (PyErr_Occurred()) SWIG_fail;
36501 }
36502 resultobj = SWIG_Py_Void();
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj = 0;
36511 wxWindow *arg1 = (wxWindow *) 0 ;
36512 int arg2 ;
36513 int result;
36514 void *argp1 = 0 ;
36515 int res1 = 0 ;
36516 int val2 ;
36517 int ecode2 = 0 ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char * kwnames[] = {
36521 (char *) "self",(char *) "orientation", NULL
36522 };
36523
36524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36526 if (!SWIG_IsOK(res1)) {
36527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36528 }
36529 arg1 = reinterpret_cast< wxWindow * >(argp1);
36530 ecode2 = SWIG_AsVal_int(obj1, &val2);
36531 if (!SWIG_IsOK(ecode2)) {
36532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36533 }
36534 arg2 = static_cast< int >(val2);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 resultobj = SWIG_From_int(static_cast< int >(result));
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj = 0;
36550 wxWindow *arg1 = (wxWindow *) 0 ;
36551 int arg2 ;
36552 int result;
36553 void *argp1 = 0 ;
36554 int res1 = 0 ;
36555 int val2 ;
36556 int ecode2 = 0 ;
36557 PyObject * obj0 = 0 ;
36558 PyObject * obj1 = 0 ;
36559 char * kwnames[] = {
36560 (char *) "self",(char *) "orientation", NULL
36561 };
36562
36563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36565 if (!SWIG_IsOK(res1)) {
36566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36567 }
36568 arg1 = reinterpret_cast< wxWindow * >(argp1);
36569 ecode2 = SWIG_AsVal_int(obj1, &val2);
36570 if (!SWIG_IsOK(ecode2)) {
36571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36572 }
36573 arg2 = static_cast< int >(val2);
36574 {
36575 PyThreadState* __tstate = wxPyBeginAllowThreads();
36576 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36577 wxPyEndAllowThreads(__tstate);
36578 if (PyErr_Occurred()) SWIG_fail;
36579 }
36580 resultobj = SWIG_From_int(static_cast< int >(result));
36581 return resultobj;
36582 fail:
36583 return NULL;
36584 }
36585
36586
36587 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36588 PyObject *resultobj = 0;
36589 wxWindow *arg1 = (wxWindow *) 0 ;
36590 int arg2 ;
36591 int result;
36592 void *argp1 = 0 ;
36593 int res1 = 0 ;
36594 int val2 ;
36595 int ecode2 = 0 ;
36596 PyObject * obj0 = 0 ;
36597 PyObject * obj1 = 0 ;
36598 char * kwnames[] = {
36599 (char *) "self",(char *) "orientation", NULL
36600 };
36601
36602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36604 if (!SWIG_IsOK(res1)) {
36605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36606 }
36607 arg1 = reinterpret_cast< wxWindow * >(argp1);
36608 ecode2 = SWIG_AsVal_int(obj1, &val2);
36609 if (!SWIG_IsOK(ecode2)) {
36610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36611 }
36612 arg2 = static_cast< int >(val2);
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36616 wxPyEndAllowThreads(__tstate);
36617 if (PyErr_Occurred()) SWIG_fail;
36618 }
36619 resultobj = SWIG_From_int(static_cast< int >(result));
36620 return resultobj;
36621 fail:
36622 return NULL;
36623 }
36624
36625
36626 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36627 PyObject *resultobj = 0;
36628 wxWindow *arg1 = (wxWindow *) 0 ;
36629 int arg2 ;
36630 int arg3 ;
36631 wxRect *arg4 = (wxRect *) NULL ;
36632 void *argp1 = 0 ;
36633 int res1 = 0 ;
36634 int val2 ;
36635 int ecode2 = 0 ;
36636 int val3 ;
36637 int ecode3 = 0 ;
36638 void *argp4 = 0 ;
36639 int res4 = 0 ;
36640 PyObject * obj0 = 0 ;
36641 PyObject * obj1 = 0 ;
36642 PyObject * obj2 = 0 ;
36643 PyObject * obj3 = 0 ;
36644 char * kwnames[] = {
36645 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36646 };
36647
36648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36650 if (!SWIG_IsOK(res1)) {
36651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36652 }
36653 arg1 = reinterpret_cast< wxWindow * >(argp1);
36654 ecode2 = SWIG_AsVal_int(obj1, &val2);
36655 if (!SWIG_IsOK(ecode2)) {
36656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36657 }
36658 arg2 = static_cast< int >(val2);
36659 ecode3 = SWIG_AsVal_int(obj2, &val3);
36660 if (!SWIG_IsOK(ecode3)) {
36661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36662 }
36663 arg3 = static_cast< int >(val3);
36664 if (obj3) {
36665 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36666 if (!SWIG_IsOK(res4)) {
36667 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36668 }
36669 arg4 = reinterpret_cast< wxRect * >(argp4);
36670 }
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 resultobj = SWIG_Py_Void();
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36685 PyObject *resultobj = 0;
36686 wxWindow *arg1 = (wxWindow *) 0 ;
36687 int arg2 ;
36688 bool result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 int val2 ;
36692 int ecode2 = 0 ;
36693 PyObject * obj0 = 0 ;
36694 PyObject * obj1 = 0 ;
36695 char * kwnames[] = {
36696 (char *) "self",(char *) "lines", NULL
36697 };
36698
36699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36701 if (!SWIG_IsOK(res1)) {
36702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36703 }
36704 arg1 = reinterpret_cast< wxWindow * >(argp1);
36705 ecode2 = SWIG_AsVal_int(obj1, &val2);
36706 if (!SWIG_IsOK(ecode2)) {
36707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36708 }
36709 arg2 = static_cast< int >(val2);
36710 {
36711 PyThreadState* __tstate = wxPyBeginAllowThreads();
36712 result = (bool)(arg1)->ScrollLines(arg2);
36713 wxPyEndAllowThreads(__tstate);
36714 if (PyErr_Occurred()) SWIG_fail;
36715 }
36716 {
36717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36718 }
36719 return resultobj;
36720 fail:
36721 return NULL;
36722 }
36723
36724
36725 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36726 PyObject *resultobj = 0;
36727 wxWindow *arg1 = (wxWindow *) 0 ;
36728 int arg2 ;
36729 bool result;
36730 void *argp1 = 0 ;
36731 int res1 = 0 ;
36732 int val2 ;
36733 int ecode2 = 0 ;
36734 PyObject * obj0 = 0 ;
36735 PyObject * obj1 = 0 ;
36736 char * kwnames[] = {
36737 (char *) "self",(char *) "pages", NULL
36738 };
36739
36740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36742 if (!SWIG_IsOK(res1)) {
36743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36744 }
36745 arg1 = reinterpret_cast< wxWindow * >(argp1);
36746 ecode2 = SWIG_AsVal_int(obj1, &val2);
36747 if (!SWIG_IsOK(ecode2)) {
36748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36749 }
36750 arg2 = static_cast< int >(val2);
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 result = (bool)(arg1)->ScrollPages(arg2);
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 {
36758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36759 }
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36767 PyObject *resultobj = 0;
36768 wxWindow *arg1 = (wxWindow *) 0 ;
36769 bool result;
36770 void *argp1 = 0 ;
36771 int res1 = 0 ;
36772 PyObject *swig_obj[1] ;
36773
36774 if (!args) SWIG_fail;
36775 swig_obj[0] = args;
36776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36777 if (!SWIG_IsOK(res1)) {
36778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36779 }
36780 arg1 = reinterpret_cast< wxWindow * >(argp1);
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = (bool)(arg1)->LineUp();
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36797 PyObject *resultobj = 0;
36798 wxWindow *arg1 = (wxWindow *) 0 ;
36799 bool result;
36800 void *argp1 = 0 ;
36801 int res1 = 0 ;
36802 PyObject *swig_obj[1] ;
36803
36804 if (!args) SWIG_fail;
36805 swig_obj[0] = args;
36806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36807 if (!SWIG_IsOK(res1)) {
36808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36809 }
36810 arg1 = reinterpret_cast< wxWindow * >(argp1);
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 result = (bool)(arg1)->LineDown();
36814 wxPyEndAllowThreads(__tstate);
36815 if (PyErr_Occurred()) SWIG_fail;
36816 }
36817 {
36818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36819 }
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36827 PyObject *resultobj = 0;
36828 wxWindow *arg1 = (wxWindow *) 0 ;
36829 bool result;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 PyObject *swig_obj[1] ;
36833
36834 if (!args) SWIG_fail;
36835 swig_obj[0] = args;
36836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36837 if (!SWIG_IsOK(res1)) {
36838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36839 }
36840 arg1 = reinterpret_cast< wxWindow * >(argp1);
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 result = (bool)(arg1)->PageUp();
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 {
36848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36849 }
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36857 PyObject *resultobj = 0;
36858 wxWindow *arg1 = (wxWindow *) 0 ;
36859 bool result;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 PyObject *swig_obj[1] ;
36863
36864 if (!args) SWIG_fail;
36865 swig_obj[0] = args;
36866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (bool)(arg1)->PageDown();
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 {
36878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36879 }
36880 return resultobj;
36881 fail:
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36887 PyObject *resultobj = 0;
36888 wxWindow *arg1 = (wxWindow *) 0 ;
36889 wxString *arg2 = 0 ;
36890 void *argp1 = 0 ;
36891 int res1 = 0 ;
36892 bool temp2 = false ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "text", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 {
36906 arg2 = wxString_in_helper(obj1);
36907 if (arg2 == NULL) SWIG_fail;
36908 temp2 = true;
36909 }
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 (arg1)->SetHelpText((wxString const &)*arg2);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 resultobj = SWIG_Py_Void();
36917 {
36918 if (temp2)
36919 delete arg2;
36920 }
36921 return resultobj;
36922 fail:
36923 {
36924 if (temp2)
36925 delete arg2;
36926 }
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36932 PyObject *resultobj = 0;
36933 wxWindow *arg1 = (wxWindow *) 0 ;
36934 wxString *arg2 = 0 ;
36935 void *argp1 = 0 ;
36936 int res1 = 0 ;
36937 bool temp2 = false ;
36938 PyObject * obj0 = 0 ;
36939 PyObject * obj1 = 0 ;
36940 char * kwnames[] = {
36941 (char *) "self",(char *) "text", NULL
36942 };
36943
36944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36946 if (!SWIG_IsOK(res1)) {
36947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36948 }
36949 arg1 = reinterpret_cast< wxWindow * >(argp1);
36950 {
36951 arg2 = wxString_in_helper(obj1);
36952 if (arg2 == NULL) SWIG_fail;
36953 temp2 = true;
36954 }
36955 {
36956 PyThreadState* __tstate = wxPyBeginAllowThreads();
36957 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 resultobj = SWIG_Py_Void();
36962 {
36963 if (temp2)
36964 delete arg2;
36965 }
36966 return resultobj;
36967 fail:
36968 {
36969 if (temp2)
36970 delete arg2;
36971 }
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 wxPoint *arg2 = 0 ;
36980 wxHelpEvent::Origin arg3 ;
36981 wxString result;
36982 void *argp1 = 0 ;
36983 int res1 = 0 ;
36984 wxPoint temp2 ;
36985 void *argp3 ;
36986 int res3 = 0 ;
36987 PyObject * obj0 = 0 ;
36988 PyObject * obj1 = 0 ;
36989 PyObject * obj2 = 0 ;
36990 char * kwnames[] = {
36991 (char *) "self",(char *) "pt",(char *) "origin", NULL
36992 };
36993
36994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36996 if (!SWIG_IsOK(res1)) {
36997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36998 }
36999 arg1 = reinterpret_cast< wxWindow * >(argp1);
37000 {
37001 arg2 = &temp2;
37002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37003 }
37004 {
37005 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37006 if (!SWIG_IsOK(res3)) {
37007 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37008 }
37009 if (!argp3) {
37010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37011 } else {
37012 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37013 arg3 = *temp;
37014 if (SWIG_IsNewObj(res3)) delete temp;
37015 }
37016 }
37017 {
37018 PyThreadState* __tstate = wxPyBeginAllowThreads();
37019 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37020 wxPyEndAllowThreads(__tstate);
37021 if (PyErr_Occurred()) SWIG_fail;
37022 }
37023 {
37024 #if wxUSE_UNICODE
37025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37026 #else
37027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37028 #endif
37029 }
37030 return resultobj;
37031 fail:
37032 return NULL;
37033 }
37034
37035
37036 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37037 PyObject *resultobj = 0;
37038 wxWindow *arg1 = (wxWindow *) 0 ;
37039 wxString result;
37040 void *argp1 = 0 ;
37041 int res1 = 0 ;
37042 PyObject *swig_obj[1] ;
37043
37044 if (!args) SWIG_fail;
37045 swig_obj[0] = args;
37046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37047 if (!SWIG_IsOK(res1)) {
37048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37049 }
37050 arg1 = reinterpret_cast< wxWindow * >(argp1);
37051 {
37052 PyThreadState* __tstate = wxPyBeginAllowThreads();
37053 result = ((wxWindow const *)arg1)->GetHelpText();
37054 wxPyEndAllowThreads(__tstate);
37055 if (PyErr_Occurred()) SWIG_fail;
37056 }
37057 {
37058 #if wxUSE_UNICODE
37059 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37060 #else
37061 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37062 #endif
37063 }
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 wxString *arg2 = 0 ;
37074 void *argp1 = 0 ;
37075 int res1 = 0 ;
37076 bool temp2 = false ;
37077 PyObject * obj0 = 0 ;
37078 PyObject * obj1 = 0 ;
37079 char * kwnames[] = {
37080 (char *) "self",(char *) "tip", NULL
37081 };
37082
37083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37087 }
37088 arg1 = reinterpret_cast< wxWindow * >(argp1);
37089 {
37090 arg2 = wxString_in_helper(obj1);
37091 if (arg2 == NULL) SWIG_fail;
37092 temp2 = true;
37093 }
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 (arg1)->SetToolTip((wxString const &)*arg2);
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 resultobj = SWIG_Py_Void();
37101 {
37102 if (temp2)
37103 delete arg2;
37104 }
37105 return resultobj;
37106 fail:
37107 {
37108 if (temp2)
37109 delete arg2;
37110 }
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37116 PyObject *resultobj = 0;
37117 wxWindow *arg1 = (wxWindow *) 0 ;
37118 wxToolTip *arg2 = (wxToolTip *) 0 ;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 int res2 = 0 ;
37122 PyObject * obj0 = 0 ;
37123 PyObject * obj1 = 0 ;
37124 char * kwnames[] = {
37125 (char *) "self",(char *) "tip", NULL
37126 };
37127
37128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37130 if (!SWIG_IsOK(res1)) {
37131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37132 }
37133 arg1 = reinterpret_cast< wxWindow * >(argp1);
37134 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37135 if (!SWIG_IsOK(res2)) {
37136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37137 }
37138 {
37139 PyThreadState* __tstate = wxPyBeginAllowThreads();
37140 (arg1)->SetToolTip(arg2);
37141 wxPyEndAllowThreads(__tstate);
37142 if (PyErr_Occurred()) SWIG_fail;
37143 }
37144 resultobj = SWIG_Py_Void();
37145 return resultobj;
37146 fail:
37147 return NULL;
37148 }
37149
37150
37151 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37152 PyObject *resultobj = 0;
37153 wxWindow *arg1 = (wxWindow *) 0 ;
37154 wxToolTip *result = 0 ;
37155 void *argp1 = 0 ;
37156 int res1 = 0 ;
37157 PyObject *swig_obj[1] ;
37158
37159 if (!args) SWIG_fail;
37160 swig_obj[0] = args;
37161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37162 if (!SWIG_IsOK(res1)) {
37163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37164 }
37165 arg1 = reinterpret_cast< wxWindow * >(argp1);
37166 {
37167 PyThreadState* __tstate = wxPyBeginAllowThreads();
37168 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37169 wxPyEndAllowThreads(__tstate);
37170 if (PyErr_Occurred()) SWIG_fail;
37171 }
37172 {
37173 resultobj = wxPyMake_wxObject(result, (bool)0);
37174 }
37175 return resultobj;
37176 fail:
37177 return NULL;
37178 }
37179
37180
37181 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37182 PyObject *resultobj = 0;
37183 wxWindow *arg1 = (wxWindow *) 0 ;
37184 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37185 void *argp1 = 0 ;
37186 int res1 = 0 ;
37187 int res2 = 0 ;
37188 PyObject * obj0 = 0 ;
37189 PyObject * obj1 = 0 ;
37190 char * kwnames[] = {
37191 (char *) "self",(char *) "dropTarget", NULL
37192 };
37193
37194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37198 }
37199 arg1 = reinterpret_cast< wxWindow * >(argp1);
37200 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37201 if (!SWIG_IsOK(res2)) {
37202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37203 }
37204 {
37205 PyThreadState* __tstate = wxPyBeginAllowThreads();
37206 (arg1)->SetDropTarget(arg2);
37207 wxPyEndAllowThreads(__tstate);
37208 if (PyErr_Occurred()) SWIG_fail;
37209 }
37210 resultobj = SWIG_Py_Void();
37211 return resultobj;
37212 fail:
37213 return NULL;
37214 }
37215
37216
37217 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37218 PyObject *resultobj = 0;
37219 wxWindow *arg1 = (wxWindow *) 0 ;
37220 wxPyDropTarget *result = 0 ;
37221 void *argp1 = 0 ;
37222 int res1 = 0 ;
37223 PyObject *swig_obj[1] ;
37224
37225 if (!args) SWIG_fail;
37226 swig_obj[0] = args;
37227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37228 if (!SWIG_IsOK(res1)) {
37229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37230 }
37231 arg1 = reinterpret_cast< wxWindow * >(argp1);
37232 {
37233 PyThreadState* __tstate = wxPyBeginAllowThreads();
37234 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37235 wxPyEndAllowThreads(__tstate);
37236 if (PyErr_Occurred()) SWIG_fail;
37237 }
37238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37239 return resultobj;
37240 fail:
37241 return NULL;
37242 }
37243
37244
37245 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37246 PyObject *resultobj = 0;
37247 wxWindow *arg1 = (wxWindow *) 0 ;
37248 bool arg2 ;
37249 void *argp1 = 0 ;
37250 int res1 = 0 ;
37251 bool val2 ;
37252 int ecode2 = 0 ;
37253 PyObject * obj0 = 0 ;
37254 PyObject * obj1 = 0 ;
37255 char * kwnames[] = {
37256 (char *) "self",(char *) "accept", NULL
37257 };
37258
37259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37261 if (!SWIG_IsOK(res1)) {
37262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37263 }
37264 arg1 = reinterpret_cast< wxWindow * >(argp1);
37265 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37266 if (!SWIG_IsOK(ecode2)) {
37267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37268 }
37269 arg2 = static_cast< bool >(val2);
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 wxWindow_DragAcceptFiles(arg1,arg2);
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 resultobj = SWIG_Py_Void();
37277 return resultobj;
37278 fail:
37279 return NULL;
37280 }
37281
37282
37283 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37284 PyObject *resultobj = 0;
37285 wxWindow *arg1 = (wxWindow *) 0 ;
37286 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37287 void *argp1 = 0 ;
37288 int res1 = 0 ;
37289 int res2 = 0 ;
37290 PyObject * obj0 = 0 ;
37291 PyObject * obj1 = 0 ;
37292 char * kwnames[] = {
37293 (char *) "self",(char *) "constraints", NULL
37294 };
37295
37296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37298 if (!SWIG_IsOK(res1)) {
37299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37300 }
37301 arg1 = reinterpret_cast< wxWindow * >(argp1);
37302 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37303 if (!SWIG_IsOK(res2)) {
37304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37305 }
37306 {
37307 PyThreadState* __tstate = wxPyBeginAllowThreads();
37308 (arg1)->SetConstraints(arg2);
37309 wxPyEndAllowThreads(__tstate);
37310 if (PyErr_Occurred()) SWIG_fail;
37311 }
37312 resultobj = SWIG_Py_Void();
37313 return resultobj;
37314 fail:
37315 return NULL;
37316 }
37317
37318
37319 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37320 PyObject *resultobj = 0;
37321 wxWindow *arg1 = (wxWindow *) 0 ;
37322 wxLayoutConstraints *result = 0 ;
37323 void *argp1 = 0 ;
37324 int res1 = 0 ;
37325 PyObject *swig_obj[1] ;
37326
37327 if (!args) SWIG_fail;
37328 swig_obj[0] = args;
37329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37330 if (!SWIG_IsOK(res1)) {
37331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37332 }
37333 arg1 = reinterpret_cast< wxWindow * >(argp1);
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37341 return resultobj;
37342 fail:
37343 return NULL;
37344 }
37345
37346
37347 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37348 PyObject *resultobj = 0;
37349 wxWindow *arg1 = (wxWindow *) 0 ;
37350 bool arg2 ;
37351 void *argp1 = 0 ;
37352 int res1 = 0 ;
37353 bool val2 ;
37354 int ecode2 = 0 ;
37355 PyObject * obj0 = 0 ;
37356 PyObject * obj1 = 0 ;
37357 char * kwnames[] = {
37358 (char *) "self",(char *) "autoLayout", NULL
37359 };
37360
37361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37363 if (!SWIG_IsOK(res1)) {
37364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37365 }
37366 arg1 = reinterpret_cast< wxWindow * >(argp1);
37367 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37368 if (!SWIG_IsOK(ecode2)) {
37369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37370 }
37371 arg2 = static_cast< bool >(val2);
37372 {
37373 PyThreadState* __tstate = wxPyBeginAllowThreads();
37374 (arg1)->SetAutoLayout(arg2);
37375 wxPyEndAllowThreads(__tstate);
37376 if (PyErr_Occurred()) SWIG_fail;
37377 }
37378 resultobj = SWIG_Py_Void();
37379 return resultobj;
37380 fail:
37381 return NULL;
37382 }
37383
37384
37385 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37386 PyObject *resultobj = 0;
37387 wxWindow *arg1 = (wxWindow *) 0 ;
37388 bool result;
37389 void *argp1 = 0 ;
37390 int res1 = 0 ;
37391 PyObject *swig_obj[1] ;
37392
37393 if (!args) SWIG_fail;
37394 swig_obj[0] = args;
37395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37396 if (!SWIG_IsOK(res1)) {
37397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37398 }
37399 arg1 = reinterpret_cast< wxWindow * >(argp1);
37400 {
37401 PyThreadState* __tstate = wxPyBeginAllowThreads();
37402 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37403 wxPyEndAllowThreads(__tstate);
37404 if (PyErr_Occurred()) SWIG_fail;
37405 }
37406 {
37407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37408 }
37409 return resultobj;
37410 fail:
37411 return NULL;
37412 }
37413
37414
37415 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37416 PyObject *resultobj = 0;
37417 wxWindow *arg1 = (wxWindow *) 0 ;
37418 bool result;
37419 void *argp1 = 0 ;
37420 int res1 = 0 ;
37421 PyObject *swig_obj[1] ;
37422
37423 if (!args) SWIG_fail;
37424 swig_obj[0] = args;
37425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37426 if (!SWIG_IsOK(res1)) {
37427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37428 }
37429 arg1 = reinterpret_cast< wxWindow * >(argp1);
37430 {
37431 PyThreadState* __tstate = wxPyBeginAllowThreads();
37432 result = (bool)(arg1)->Layout();
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 {
37437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37438 }
37439 return resultobj;
37440 fail:
37441 return NULL;
37442 }
37443
37444
37445 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37446 PyObject *resultobj = 0;
37447 wxWindow *arg1 = (wxWindow *) 0 ;
37448 wxSizer *arg2 = (wxSizer *) 0 ;
37449 bool arg3 = (bool) true ;
37450 void *argp1 = 0 ;
37451 int res1 = 0 ;
37452 int res2 = 0 ;
37453 bool val3 ;
37454 int ecode3 = 0 ;
37455 PyObject * obj0 = 0 ;
37456 PyObject * obj1 = 0 ;
37457 PyObject * obj2 = 0 ;
37458 char * kwnames[] = {
37459 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37460 };
37461
37462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37464 if (!SWIG_IsOK(res1)) {
37465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37466 }
37467 arg1 = reinterpret_cast< wxWindow * >(argp1);
37468 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37469 if (!SWIG_IsOK(res2)) {
37470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37471 }
37472 if (obj2) {
37473 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37474 if (!SWIG_IsOK(ecode3)) {
37475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37476 }
37477 arg3 = static_cast< bool >(val3);
37478 }
37479 {
37480 PyThreadState* __tstate = wxPyBeginAllowThreads();
37481 (arg1)->SetSizer(arg2,arg3);
37482 wxPyEndAllowThreads(__tstate);
37483 if (PyErr_Occurred()) SWIG_fail;
37484 }
37485 resultobj = SWIG_Py_Void();
37486 return resultobj;
37487 fail:
37488 return NULL;
37489 }
37490
37491
37492 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37493 PyObject *resultobj = 0;
37494 wxWindow *arg1 = (wxWindow *) 0 ;
37495 wxSizer *arg2 = (wxSizer *) 0 ;
37496 bool arg3 = (bool) true ;
37497 void *argp1 = 0 ;
37498 int res1 = 0 ;
37499 int res2 = 0 ;
37500 bool val3 ;
37501 int ecode3 = 0 ;
37502 PyObject * obj0 = 0 ;
37503 PyObject * obj1 = 0 ;
37504 PyObject * obj2 = 0 ;
37505 char * kwnames[] = {
37506 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37507 };
37508
37509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37511 if (!SWIG_IsOK(res1)) {
37512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37513 }
37514 arg1 = reinterpret_cast< wxWindow * >(argp1);
37515 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37516 if (!SWIG_IsOK(res2)) {
37517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37518 }
37519 if (obj2) {
37520 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37521 if (!SWIG_IsOK(ecode3)) {
37522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37523 }
37524 arg3 = static_cast< bool >(val3);
37525 }
37526 {
37527 PyThreadState* __tstate = wxPyBeginAllowThreads();
37528 (arg1)->SetSizerAndFit(arg2,arg3);
37529 wxPyEndAllowThreads(__tstate);
37530 if (PyErr_Occurred()) SWIG_fail;
37531 }
37532 resultobj = SWIG_Py_Void();
37533 return resultobj;
37534 fail:
37535 return NULL;
37536 }
37537
37538
37539 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37540 PyObject *resultobj = 0;
37541 wxWindow *arg1 = (wxWindow *) 0 ;
37542 wxSizer *result = 0 ;
37543 void *argp1 = 0 ;
37544 int res1 = 0 ;
37545 PyObject *swig_obj[1] ;
37546
37547 if (!args) SWIG_fail;
37548 swig_obj[0] = args;
37549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37550 if (!SWIG_IsOK(res1)) {
37551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37552 }
37553 arg1 = reinterpret_cast< wxWindow * >(argp1);
37554 {
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37557 wxPyEndAllowThreads(__tstate);
37558 if (PyErr_Occurred()) SWIG_fail;
37559 }
37560 {
37561 resultobj = wxPyMake_wxObject(result, (bool)0);
37562 }
37563 return resultobj;
37564 fail:
37565 return NULL;
37566 }
37567
37568
37569 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37570 PyObject *resultobj = 0;
37571 wxWindow *arg1 = (wxWindow *) 0 ;
37572 wxSizer *arg2 = (wxSizer *) 0 ;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 void *argp2 = 0 ;
37576 int res2 = 0 ;
37577 PyObject * obj0 = 0 ;
37578 PyObject * obj1 = 0 ;
37579 char * kwnames[] = {
37580 (char *) "self",(char *) "sizer", NULL
37581 };
37582
37583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37585 if (!SWIG_IsOK(res1)) {
37586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37587 }
37588 arg1 = reinterpret_cast< wxWindow * >(argp1);
37589 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37590 if (!SWIG_IsOK(res2)) {
37591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37592 }
37593 arg2 = reinterpret_cast< wxSizer * >(argp2);
37594 {
37595 PyThreadState* __tstate = wxPyBeginAllowThreads();
37596 (arg1)->SetContainingSizer(arg2);
37597 wxPyEndAllowThreads(__tstate);
37598 if (PyErr_Occurred()) SWIG_fail;
37599 }
37600 resultobj = SWIG_Py_Void();
37601 return resultobj;
37602 fail:
37603 return NULL;
37604 }
37605
37606
37607 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37608 PyObject *resultobj = 0;
37609 wxWindow *arg1 = (wxWindow *) 0 ;
37610 wxSizer *result = 0 ;
37611 void *argp1 = 0 ;
37612 int res1 = 0 ;
37613 PyObject *swig_obj[1] ;
37614
37615 if (!args) SWIG_fail;
37616 swig_obj[0] = args;
37617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37618 if (!SWIG_IsOK(res1)) {
37619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37620 }
37621 arg1 = reinterpret_cast< wxWindow * >(argp1);
37622 {
37623 PyThreadState* __tstate = wxPyBeginAllowThreads();
37624 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37625 wxPyEndAllowThreads(__tstate);
37626 if (PyErr_Occurred()) SWIG_fail;
37627 }
37628 {
37629 resultobj = wxPyMake_wxObject(result, (bool)0);
37630 }
37631 return resultobj;
37632 fail:
37633 return NULL;
37634 }
37635
37636
37637 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37638 PyObject *resultobj = 0;
37639 wxWindow *arg1 = (wxWindow *) 0 ;
37640 void *argp1 = 0 ;
37641 int res1 = 0 ;
37642 PyObject *swig_obj[1] ;
37643
37644 if (!args) SWIG_fail;
37645 swig_obj[0] = args;
37646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37647 if (!SWIG_IsOK(res1)) {
37648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37649 }
37650 arg1 = reinterpret_cast< wxWindow * >(argp1);
37651 {
37652 PyThreadState* __tstate = wxPyBeginAllowThreads();
37653 (arg1)->InheritAttributes();
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 resultobj = SWIG_Py_Void();
37658 return resultobj;
37659 fail:
37660 return NULL;
37661 }
37662
37663
37664 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37665 PyObject *resultobj = 0;
37666 wxWindow *arg1 = (wxWindow *) 0 ;
37667 bool result;
37668 void *argp1 = 0 ;
37669 int res1 = 0 ;
37670 PyObject *swig_obj[1] ;
37671
37672 if (!args) SWIG_fail;
37673 swig_obj[0] = args;
37674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37675 if (!SWIG_IsOK(res1)) {
37676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37677 }
37678 arg1 = reinterpret_cast< wxWindow * >(argp1);
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37682 wxPyEndAllowThreads(__tstate);
37683 if (PyErr_Occurred()) SWIG_fail;
37684 }
37685 {
37686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37687 }
37688 return resultobj;
37689 fail:
37690 return NULL;
37691 }
37692
37693
37694 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37695 PyObject *obj;
37696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37697 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37698 return SWIG_Py_Void();
37699 }
37700
37701 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37702 return SWIG_Python_InitShadowInstance(args);
37703 }
37704
37705 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37706 PyObject *resultobj = 0;
37707 long arg1 ;
37708 wxWindow *arg2 = (wxWindow *) NULL ;
37709 wxWindow *result = 0 ;
37710 long val1 ;
37711 int ecode1 = 0 ;
37712 void *argp2 = 0 ;
37713 int res2 = 0 ;
37714 PyObject * obj0 = 0 ;
37715 PyObject * obj1 = 0 ;
37716 char * kwnames[] = {
37717 (char *) "id",(char *) "parent", NULL
37718 };
37719
37720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37721 ecode1 = SWIG_AsVal_long(obj0, &val1);
37722 if (!SWIG_IsOK(ecode1)) {
37723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37724 }
37725 arg1 = static_cast< long >(val1);
37726 if (obj1) {
37727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37728 if (!SWIG_IsOK(res2)) {
37729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37730 }
37731 arg2 = reinterpret_cast< wxWindow * >(argp2);
37732 }
37733 {
37734 if (!wxPyCheckForApp()) SWIG_fail;
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 {
37741 resultobj = wxPyMake_wxObject(result, 0);
37742 }
37743 return resultobj;
37744 fail:
37745 return NULL;
37746 }
37747
37748
37749 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37750 PyObject *resultobj = 0;
37751 wxString *arg1 = 0 ;
37752 wxWindow *arg2 = (wxWindow *) NULL ;
37753 wxWindow *result = 0 ;
37754 bool temp1 = false ;
37755 void *argp2 = 0 ;
37756 int res2 = 0 ;
37757 PyObject * obj0 = 0 ;
37758 PyObject * obj1 = 0 ;
37759 char * kwnames[] = {
37760 (char *) "name",(char *) "parent", NULL
37761 };
37762
37763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37764 {
37765 arg1 = wxString_in_helper(obj0);
37766 if (arg1 == NULL) SWIG_fail;
37767 temp1 = true;
37768 }
37769 if (obj1) {
37770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37771 if (!SWIG_IsOK(res2)) {
37772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37773 }
37774 arg2 = reinterpret_cast< wxWindow * >(argp2);
37775 }
37776 {
37777 if (!wxPyCheckForApp()) SWIG_fail;
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 {
37784 resultobj = wxPyMake_wxObject(result, 0);
37785 }
37786 {
37787 if (temp1)
37788 delete arg1;
37789 }
37790 return resultobj;
37791 fail:
37792 {
37793 if (temp1)
37794 delete arg1;
37795 }
37796 return NULL;
37797 }
37798
37799
37800 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37801 PyObject *resultobj = 0;
37802 wxString *arg1 = 0 ;
37803 wxWindow *arg2 = (wxWindow *) NULL ;
37804 wxWindow *result = 0 ;
37805 bool temp1 = false ;
37806 void *argp2 = 0 ;
37807 int res2 = 0 ;
37808 PyObject * obj0 = 0 ;
37809 PyObject * obj1 = 0 ;
37810 char * kwnames[] = {
37811 (char *) "label",(char *) "parent", NULL
37812 };
37813
37814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37815 {
37816 arg1 = wxString_in_helper(obj0);
37817 if (arg1 == NULL) SWIG_fail;
37818 temp1 = true;
37819 }
37820 if (obj1) {
37821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37822 if (!SWIG_IsOK(res2)) {
37823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37824 }
37825 arg2 = reinterpret_cast< wxWindow * >(argp2);
37826 }
37827 {
37828 if (!wxPyCheckForApp()) SWIG_fail;
37829 PyThreadState* __tstate = wxPyBeginAllowThreads();
37830 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37831 wxPyEndAllowThreads(__tstate);
37832 if (PyErr_Occurred()) SWIG_fail;
37833 }
37834 {
37835 resultobj = wxPyMake_wxObject(result, 0);
37836 }
37837 {
37838 if (temp1)
37839 delete arg1;
37840 }
37841 return resultobj;
37842 fail:
37843 {
37844 if (temp1)
37845 delete arg1;
37846 }
37847 return NULL;
37848 }
37849
37850
37851 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37852 PyObject *resultobj = 0;
37853 wxWindow *arg1 = (wxWindow *) 0 ;
37854 unsigned long arg2 ;
37855 wxWindow *result = 0 ;
37856 void *argp1 = 0 ;
37857 int res1 = 0 ;
37858 unsigned long val2 ;
37859 int ecode2 = 0 ;
37860 PyObject * obj0 = 0 ;
37861 PyObject * obj1 = 0 ;
37862 char * kwnames[] = {
37863 (char *) "parent",(char *) "_hWnd", NULL
37864 };
37865
37866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37868 if (!SWIG_IsOK(res1)) {
37869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37870 }
37871 arg1 = reinterpret_cast< wxWindow * >(argp1);
37872 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37873 if (!SWIG_IsOK(ecode2)) {
37874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37875 }
37876 arg2 = static_cast< unsigned long >(val2);
37877 {
37878 PyThreadState* __tstate = wxPyBeginAllowThreads();
37879 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37880 wxPyEndAllowThreads(__tstate);
37881 if (PyErr_Occurred()) SWIG_fail;
37882 }
37883 {
37884 resultobj = wxPyMake_wxObject(result, 0);
37885 }
37886 return resultobj;
37887 fail:
37888 return NULL;
37889 }
37890
37891
37892 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37893 PyObject *resultobj = 0;
37894 PyObject *result = 0 ;
37895
37896 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 result = (PyObject *)GetTopLevelWindows();
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 resultobj = result;
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37911 PyObject *resultobj = 0;
37912 wxValidator *result = 0 ;
37913
37914 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37915 {
37916 PyThreadState* __tstate = wxPyBeginAllowThreads();
37917 result = (wxValidator *)new wxValidator();
37918 wxPyEndAllowThreads(__tstate);
37919 if (PyErr_Occurred()) SWIG_fail;
37920 }
37921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37922 return resultobj;
37923 fail:
37924 return NULL;
37925 }
37926
37927
37928 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37929 PyObject *resultobj = 0;
37930 wxValidator *arg1 = (wxValidator *) 0 ;
37931 wxValidator *result = 0 ;
37932 void *argp1 = 0 ;
37933 int res1 = 0 ;
37934 PyObject *swig_obj[1] ;
37935
37936 if (!args) SWIG_fail;
37937 swig_obj[0] = args;
37938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37939 if (!SWIG_IsOK(res1)) {
37940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37941 }
37942 arg1 = reinterpret_cast< wxValidator * >(argp1);
37943 {
37944 PyThreadState* __tstate = wxPyBeginAllowThreads();
37945 result = (wxValidator *)(arg1)->Clone();
37946 wxPyEndAllowThreads(__tstate);
37947 if (PyErr_Occurred()) SWIG_fail;
37948 }
37949 {
37950 resultobj = wxPyMake_wxObject(result, 0);
37951 }
37952 return resultobj;
37953 fail:
37954 return NULL;
37955 }
37956
37957
37958 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37959 PyObject *resultobj = 0;
37960 wxValidator *arg1 = (wxValidator *) 0 ;
37961 wxWindow *arg2 = (wxWindow *) 0 ;
37962 bool result;
37963 void *argp1 = 0 ;
37964 int res1 = 0 ;
37965 void *argp2 = 0 ;
37966 int res2 = 0 ;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 char * kwnames[] = {
37970 (char *) "self",(char *) "parent", NULL
37971 };
37972
37973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37975 if (!SWIG_IsOK(res1)) {
37976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37977 }
37978 arg1 = reinterpret_cast< wxValidator * >(argp1);
37979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37980 if (!SWIG_IsOK(res2)) {
37981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37982 }
37983 arg2 = reinterpret_cast< wxWindow * >(argp2);
37984 {
37985 PyThreadState* __tstate = wxPyBeginAllowThreads();
37986 result = (bool)(arg1)->Validate(arg2);
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 {
37991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37992 }
37993 return resultobj;
37994 fail:
37995 return NULL;
37996 }
37997
37998
37999 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38000 PyObject *resultobj = 0;
38001 wxValidator *arg1 = (wxValidator *) 0 ;
38002 bool result;
38003 void *argp1 = 0 ;
38004 int res1 = 0 ;
38005 PyObject *swig_obj[1] ;
38006
38007 if (!args) SWIG_fail;
38008 swig_obj[0] = args;
38009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38010 if (!SWIG_IsOK(res1)) {
38011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38012 }
38013 arg1 = reinterpret_cast< wxValidator * >(argp1);
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (bool)(arg1)->TransferToWindow();
38017 wxPyEndAllowThreads(__tstate);
38018 if (PyErr_Occurred()) SWIG_fail;
38019 }
38020 {
38021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38022 }
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38030 PyObject *resultobj = 0;
38031 wxValidator *arg1 = (wxValidator *) 0 ;
38032 bool result;
38033 void *argp1 = 0 ;
38034 int res1 = 0 ;
38035 PyObject *swig_obj[1] ;
38036
38037 if (!args) SWIG_fail;
38038 swig_obj[0] = args;
38039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38040 if (!SWIG_IsOK(res1)) {
38041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38042 }
38043 arg1 = reinterpret_cast< wxValidator * >(argp1);
38044 {
38045 PyThreadState* __tstate = wxPyBeginAllowThreads();
38046 result = (bool)(arg1)->TransferFromWindow();
38047 wxPyEndAllowThreads(__tstate);
38048 if (PyErr_Occurred()) SWIG_fail;
38049 }
38050 {
38051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38052 }
38053 return resultobj;
38054 fail:
38055 return NULL;
38056 }
38057
38058
38059 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38060 PyObject *resultobj = 0;
38061 wxValidator *arg1 = (wxValidator *) 0 ;
38062 wxWindow *result = 0 ;
38063 void *argp1 = 0 ;
38064 int res1 = 0 ;
38065 PyObject *swig_obj[1] ;
38066
38067 if (!args) SWIG_fail;
38068 swig_obj[0] = args;
38069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38070 if (!SWIG_IsOK(res1)) {
38071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38072 }
38073 arg1 = reinterpret_cast< wxValidator * >(argp1);
38074 {
38075 PyThreadState* __tstate = wxPyBeginAllowThreads();
38076 result = (wxWindow *)(arg1)->GetWindow();
38077 wxPyEndAllowThreads(__tstate);
38078 if (PyErr_Occurred()) SWIG_fail;
38079 }
38080 {
38081 resultobj = wxPyMake_wxObject(result, 0);
38082 }
38083 return resultobj;
38084 fail:
38085 return NULL;
38086 }
38087
38088
38089 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38090 PyObject *resultobj = 0;
38091 wxValidator *arg1 = (wxValidator *) 0 ;
38092 wxWindow *arg2 = (wxWindow *) 0 ;
38093 void *argp1 = 0 ;
38094 int res1 = 0 ;
38095 void *argp2 = 0 ;
38096 int res2 = 0 ;
38097 PyObject * obj0 = 0 ;
38098 PyObject * obj1 = 0 ;
38099 char * kwnames[] = {
38100 (char *) "self",(char *) "window", NULL
38101 };
38102
38103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38105 if (!SWIG_IsOK(res1)) {
38106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38107 }
38108 arg1 = reinterpret_cast< wxValidator * >(argp1);
38109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res2)) {
38111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38112 }
38113 arg2 = reinterpret_cast< wxWindow * >(argp2);
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 (arg1)->SetWindow(arg2);
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 resultobj = SWIG_Py_Void();
38121 return resultobj;
38122 fail:
38123 return NULL;
38124 }
38125
38126
38127 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38128 PyObject *resultobj = 0;
38129 bool result;
38130
38131 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38132 {
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = (bool)wxValidator::IsSilent();
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 {
38139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38140 }
38141 return resultobj;
38142 fail:
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38148 PyObject *resultobj = 0;
38149 int arg1 = (int) true ;
38150 int val1 ;
38151 int ecode1 = 0 ;
38152 PyObject * obj0 = 0 ;
38153 char * kwnames[] = {
38154 (char *) "doIt", NULL
38155 };
38156
38157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38158 if (obj0) {
38159 ecode1 = SWIG_AsVal_int(obj0, &val1);
38160 if (!SWIG_IsOK(ecode1)) {
38161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38162 }
38163 arg1 = static_cast< int >(val1);
38164 }
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 wxValidator::SetBellOnError(arg1);
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 resultobj = SWIG_Py_Void();
38172 return resultobj;
38173 fail:
38174 return NULL;
38175 }
38176
38177
38178 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38179 PyObject *obj;
38180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38181 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38182 return SWIG_Py_Void();
38183 }
38184
38185 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38186 return SWIG_Python_InitShadowInstance(args);
38187 }
38188
38189 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38190 PyObject *resultobj = 0;
38191 wxPyValidator *result = 0 ;
38192
38193 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38194 {
38195 PyThreadState* __tstate = wxPyBeginAllowThreads();
38196 result = (wxPyValidator *)new wxPyValidator();
38197 wxPyEndAllowThreads(__tstate);
38198 if (PyErr_Occurred()) SWIG_fail;
38199 }
38200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38201 return resultobj;
38202 fail:
38203 return NULL;
38204 }
38205
38206
38207 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38208 PyObject *resultobj = 0;
38209 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38210 PyObject *arg2 = (PyObject *) 0 ;
38211 PyObject *arg3 = (PyObject *) 0 ;
38212 int arg4 = (int) true ;
38213 void *argp1 = 0 ;
38214 int res1 = 0 ;
38215 int val4 ;
38216 int ecode4 = 0 ;
38217 PyObject * obj0 = 0 ;
38218 PyObject * obj1 = 0 ;
38219 PyObject * obj2 = 0 ;
38220 PyObject * obj3 = 0 ;
38221 char * kwnames[] = {
38222 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38223 };
38224
38225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38227 if (!SWIG_IsOK(res1)) {
38228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38229 }
38230 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38231 arg2 = obj1;
38232 arg3 = obj2;
38233 if (obj3) {
38234 ecode4 = SWIG_AsVal_int(obj3, &val4);
38235 if (!SWIG_IsOK(ecode4)) {
38236 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38237 }
38238 arg4 = static_cast< int >(val4);
38239 }
38240 {
38241 PyThreadState* __tstate = wxPyBeginAllowThreads();
38242 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38243 wxPyEndAllowThreads(__tstate);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 }
38246 resultobj = SWIG_Py_Void();
38247 return resultobj;
38248 fail:
38249 return NULL;
38250 }
38251
38252
38253 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38254 PyObject *obj;
38255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38256 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38257 return SWIG_Py_Void();
38258 }
38259
38260 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38261 return SWIG_Python_InitShadowInstance(args);
38262 }
38263
38264 SWIGINTERN int DefaultValidator_set(PyObject *) {
38265 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38266 return 1;
38267 }
38268
38269
38270 SWIGINTERN PyObject *DefaultValidator_get(void) {
38271 PyObject *pyobj = 0;
38272
38273 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38274 return pyobj;
38275 }
38276
38277
38278 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38279 PyObject *resultobj = 0;
38280 wxString const &arg1_defvalue = wxPyEmptyString ;
38281 wxString *arg1 = (wxString *) &arg1_defvalue ;
38282 long arg2 = (long) 0 ;
38283 wxMenu *result = 0 ;
38284 bool temp1 = false ;
38285 long val2 ;
38286 int ecode2 = 0 ;
38287 PyObject * obj0 = 0 ;
38288 PyObject * obj1 = 0 ;
38289 char * kwnames[] = {
38290 (char *) "title",(char *) "style", NULL
38291 };
38292
38293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38294 if (obj0) {
38295 {
38296 arg1 = wxString_in_helper(obj0);
38297 if (arg1 == NULL) SWIG_fail;
38298 temp1 = true;
38299 }
38300 }
38301 if (obj1) {
38302 ecode2 = SWIG_AsVal_long(obj1, &val2);
38303 if (!SWIG_IsOK(ecode2)) {
38304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38305 }
38306 arg2 = static_cast< long >(val2);
38307 }
38308 {
38309 if (!wxPyCheckForApp()) SWIG_fail;
38310 PyThreadState* __tstate = wxPyBeginAllowThreads();
38311 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38312 wxPyEndAllowThreads(__tstate);
38313 if (PyErr_Occurred()) SWIG_fail;
38314 }
38315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38316 {
38317 if (temp1)
38318 delete arg1;
38319 }
38320 return resultobj;
38321 fail:
38322 {
38323 if (temp1)
38324 delete arg1;
38325 }
38326 return NULL;
38327 }
38328
38329
38330 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38331 PyObject *resultobj = 0;
38332 wxMenu *arg1 = (wxMenu *) 0 ;
38333 int arg2 ;
38334 wxString *arg3 = 0 ;
38335 wxString const &arg4_defvalue = wxPyEmptyString ;
38336 wxString *arg4 = (wxString *) &arg4_defvalue ;
38337 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38338 wxMenuItem *result = 0 ;
38339 void *argp1 = 0 ;
38340 int res1 = 0 ;
38341 int val2 ;
38342 int ecode2 = 0 ;
38343 bool temp3 = false ;
38344 bool temp4 = false ;
38345 int val5 ;
38346 int ecode5 = 0 ;
38347 PyObject * obj0 = 0 ;
38348 PyObject * obj1 = 0 ;
38349 PyObject * obj2 = 0 ;
38350 PyObject * obj3 = 0 ;
38351 PyObject * obj4 = 0 ;
38352 char * kwnames[] = {
38353 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38354 };
38355
38356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38358 if (!SWIG_IsOK(res1)) {
38359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38360 }
38361 arg1 = reinterpret_cast< wxMenu * >(argp1);
38362 ecode2 = SWIG_AsVal_int(obj1, &val2);
38363 if (!SWIG_IsOK(ecode2)) {
38364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38365 }
38366 arg2 = static_cast< int >(val2);
38367 {
38368 arg3 = wxString_in_helper(obj2);
38369 if (arg3 == NULL) SWIG_fail;
38370 temp3 = true;
38371 }
38372 if (obj3) {
38373 {
38374 arg4 = wxString_in_helper(obj3);
38375 if (arg4 == NULL) SWIG_fail;
38376 temp4 = true;
38377 }
38378 }
38379 if (obj4) {
38380 ecode5 = SWIG_AsVal_int(obj4, &val5);
38381 if (!SWIG_IsOK(ecode5)) {
38382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38383 }
38384 arg5 = static_cast< wxItemKind >(val5);
38385 }
38386 {
38387 PyThreadState* __tstate = wxPyBeginAllowThreads();
38388 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 {
38393 resultobj = wxPyMake_wxObject(result, (bool)0);
38394 }
38395 {
38396 if (temp3)
38397 delete arg3;
38398 }
38399 {
38400 if (temp4)
38401 delete arg4;
38402 }
38403 return resultobj;
38404 fail:
38405 {
38406 if (temp3)
38407 delete arg3;
38408 }
38409 {
38410 if (temp4)
38411 delete arg4;
38412 }
38413 return NULL;
38414 }
38415
38416
38417 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38418 PyObject *resultobj = 0;
38419 wxMenu *arg1 = (wxMenu *) 0 ;
38420 wxMenuItem *result = 0 ;
38421 void *argp1 = 0 ;
38422 int res1 = 0 ;
38423 PyObject *swig_obj[1] ;
38424
38425 if (!args) SWIG_fail;
38426 swig_obj[0] = args;
38427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38428 if (!SWIG_IsOK(res1)) {
38429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38430 }
38431 arg1 = reinterpret_cast< wxMenu * >(argp1);
38432 {
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (wxMenuItem *)(arg1)->AppendSeparator();
38435 wxPyEndAllowThreads(__tstate);
38436 if (PyErr_Occurred()) SWIG_fail;
38437 }
38438 {
38439 resultobj = wxPyMake_wxObject(result, (bool)0);
38440 }
38441 return resultobj;
38442 fail:
38443 return NULL;
38444 }
38445
38446
38447 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38448 PyObject *resultobj = 0;
38449 wxMenu *arg1 = (wxMenu *) 0 ;
38450 int arg2 ;
38451 wxString *arg3 = 0 ;
38452 wxString const &arg4_defvalue = wxPyEmptyString ;
38453 wxString *arg4 = (wxString *) &arg4_defvalue ;
38454 wxMenuItem *result = 0 ;
38455 void *argp1 = 0 ;
38456 int res1 = 0 ;
38457 int val2 ;
38458 int ecode2 = 0 ;
38459 bool temp3 = false ;
38460 bool temp4 = false ;
38461 PyObject * obj0 = 0 ;
38462 PyObject * obj1 = 0 ;
38463 PyObject * obj2 = 0 ;
38464 PyObject * obj3 = 0 ;
38465 char * kwnames[] = {
38466 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38467 };
38468
38469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38471 if (!SWIG_IsOK(res1)) {
38472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38473 }
38474 arg1 = reinterpret_cast< wxMenu * >(argp1);
38475 ecode2 = SWIG_AsVal_int(obj1, &val2);
38476 if (!SWIG_IsOK(ecode2)) {
38477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38478 }
38479 arg2 = static_cast< int >(val2);
38480 {
38481 arg3 = wxString_in_helper(obj2);
38482 if (arg3 == NULL) SWIG_fail;
38483 temp3 = true;
38484 }
38485 if (obj3) {
38486 {
38487 arg4 = wxString_in_helper(obj3);
38488 if (arg4 == NULL) SWIG_fail;
38489 temp4 = true;
38490 }
38491 }
38492 {
38493 PyThreadState* __tstate = wxPyBeginAllowThreads();
38494 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38495 wxPyEndAllowThreads(__tstate);
38496 if (PyErr_Occurred()) SWIG_fail;
38497 }
38498 {
38499 resultobj = wxPyMake_wxObject(result, (bool)0);
38500 }
38501 {
38502 if (temp3)
38503 delete arg3;
38504 }
38505 {
38506 if (temp4)
38507 delete arg4;
38508 }
38509 return resultobj;
38510 fail:
38511 {
38512 if (temp3)
38513 delete arg3;
38514 }
38515 {
38516 if (temp4)
38517 delete arg4;
38518 }
38519 return NULL;
38520 }
38521
38522
38523 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38524 PyObject *resultobj = 0;
38525 wxMenu *arg1 = (wxMenu *) 0 ;
38526 int arg2 ;
38527 wxString *arg3 = 0 ;
38528 wxString const &arg4_defvalue = wxPyEmptyString ;
38529 wxString *arg4 = (wxString *) &arg4_defvalue ;
38530 wxMenuItem *result = 0 ;
38531 void *argp1 = 0 ;
38532 int res1 = 0 ;
38533 int val2 ;
38534 int ecode2 = 0 ;
38535 bool temp3 = false ;
38536 bool temp4 = false ;
38537 PyObject * obj0 = 0 ;
38538 PyObject * obj1 = 0 ;
38539 PyObject * obj2 = 0 ;
38540 PyObject * obj3 = 0 ;
38541 char * kwnames[] = {
38542 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38543 };
38544
38545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38547 if (!SWIG_IsOK(res1)) {
38548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38549 }
38550 arg1 = reinterpret_cast< wxMenu * >(argp1);
38551 ecode2 = SWIG_AsVal_int(obj1, &val2);
38552 if (!SWIG_IsOK(ecode2)) {
38553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38554 }
38555 arg2 = static_cast< int >(val2);
38556 {
38557 arg3 = wxString_in_helper(obj2);
38558 if (arg3 == NULL) SWIG_fail;
38559 temp3 = true;
38560 }
38561 if (obj3) {
38562 {
38563 arg4 = wxString_in_helper(obj3);
38564 if (arg4 == NULL) SWIG_fail;
38565 temp4 = true;
38566 }
38567 }
38568 {
38569 PyThreadState* __tstate = wxPyBeginAllowThreads();
38570 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38571 wxPyEndAllowThreads(__tstate);
38572 if (PyErr_Occurred()) SWIG_fail;
38573 }
38574 {
38575 resultobj = wxPyMake_wxObject(result, (bool)0);
38576 }
38577 {
38578 if (temp3)
38579 delete arg3;
38580 }
38581 {
38582 if (temp4)
38583 delete arg4;
38584 }
38585 return resultobj;
38586 fail:
38587 {
38588 if (temp3)
38589 delete arg3;
38590 }
38591 {
38592 if (temp4)
38593 delete arg4;
38594 }
38595 return NULL;
38596 }
38597
38598
38599 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38600 PyObject *resultobj = 0;
38601 wxMenu *arg1 = (wxMenu *) 0 ;
38602 int arg2 ;
38603 wxString *arg3 = 0 ;
38604 wxMenu *arg4 = (wxMenu *) 0 ;
38605 wxString const &arg5_defvalue = wxPyEmptyString ;
38606 wxString *arg5 = (wxString *) &arg5_defvalue ;
38607 wxMenuItem *result = 0 ;
38608 void *argp1 = 0 ;
38609 int res1 = 0 ;
38610 int val2 ;
38611 int ecode2 = 0 ;
38612 bool temp3 = false ;
38613 void *argp4 = 0 ;
38614 int res4 = 0 ;
38615 bool temp5 = false ;
38616 PyObject * obj0 = 0 ;
38617 PyObject * obj1 = 0 ;
38618 PyObject * obj2 = 0 ;
38619 PyObject * obj3 = 0 ;
38620 PyObject * obj4 = 0 ;
38621 char * kwnames[] = {
38622 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38623 };
38624
38625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38627 if (!SWIG_IsOK(res1)) {
38628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38629 }
38630 arg1 = reinterpret_cast< wxMenu * >(argp1);
38631 ecode2 = SWIG_AsVal_int(obj1, &val2);
38632 if (!SWIG_IsOK(ecode2)) {
38633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38634 }
38635 arg2 = static_cast< int >(val2);
38636 {
38637 arg3 = wxString_in_helper(obj2);
38638 if (arg3 == NULL) SWIG_fail;
38639 temp3 = true;
38640 }
38641 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38642 if (!SWIG_IsOK(res4)) {
38643 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38644 }
38645 arg4 = reinterpret_cast< wxMenu * >(argp4);
38646 if (obj4) {
38647 {
38648 arg5 = wxString_in_helper(obj4);
38649 if (arg5 == NULL) SWIG_fail;
38650 temp5 = true;
38651 }
38652 }
38653 {
38654 PyThreadState* __tstate = wxPyBeginAllowThreads();
38655 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38656 wxPyEndAllowThreads(__tstate);
38657 if (PyErr_Occurred()) SWIG_fail;
38658 }
38659 {
38660 resultobj = wxPyMake_wxObject(result, (bool)0);
38661 }
38662 {
38663 if (temp3)
38664 delete arg3;
38665 }
38666 {
38667 if (temp5)
38668 delete arg5;
38669 }
38670 return resultobj;
38671 fail:
38672 {
38673 if (temp3)
38674 delete arg3;
38675 }
38676 {
38677 if (temp5)
38678 delete arg5;
38679 }
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = 0;
38686 wxMenu *arg1 = (wxMenu *) 0 ;
38687 wxMenu *arg2 = (wxMenu *) 0 ;
38688 wxString *arg3 = 0 ;
38689 wxString const &arg4_defvalue = wxPyEmptyString ;
38690 wxString *arg4 = (wxString *) &arg4_defvalue ;
38691 wxMenuItem *result = 0 ;
38692 void *argp1 = 0 ;
38693 int res1 = 0 ;
38694 void *argp2 = 0 ;
38695 int res2 = 0 ;
38696 bool temp3 = false ;
38697 bool temp4 = false ;
38698 PyObject * obj0 = 0 ;
38699 PyObject * obj1 = 0 ;
38700 PyObject * obj2 = 0 ;
38701 PyObject * obj3 = 0 ;
38702 char * kwnames[] = {
38703 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38704 };
38705
38706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38708 if (!SWIG_IsOK(res1)) {
38709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38710 }
38711 arg1 = reinterpret_cast< wxMenu * >(argp1);
38712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38713 if (!SWIG_IsOK(res2)) {
38714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38715 }
38716 arg2 = reinterpret_cast< wxMenu * >(argp2);
38717 {
38718 arg3 = wxString_in_helper(obj2);
38719 if (arg3 == NULL) SWIG_fail;
38720 temp3 = true;
38721 }
38722 if (obj3) {
38723 {
38724 arg4 = wxString_in_helper(obj3);
38725 if (arg4 == NULL) SWIG_fail;
38726 temp4 = true;
38727 }
38728 }
38729 {
38730 PyThreadState* __tstate = wxPyBeginAllowThreads();
38731 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 {
38736 resultobj = wxPyMake_wxObject(result, (bool)0);
38737 }
38738 {
38739 if (temp3)
38740 delete arg3;
38741 }
38742 {
38743 if (temp4)
38744 delete arg4;
38745 }
38746 return resultobj;
38747 fail:
38748 {
38749 if (temp3)
38750 delete arg3;
38751 }
38752 {
38753 if (temp4)
38754 delete arg4;
38755 }
38756 return NULL;
38757 }
38758
38759
38760 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38761 PyObject *resultobj = 0;
38762 wxMenu *arg1 = (wxMenu *) 0 ;
38763 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38764 wxMenuItem *result = 0 ;
38765 void *argp1 = 0 ;
38766 int res1 = 0 ;
38767 int res2 = 0 ;
38768 PyObject * obj0 = 0 ;
38769 PyObject * obj1 = 0 ;
38770 char * kwnames[] = {
38771 (char *) "self",(char *) "item", NULL
38772 };
38773
38774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38776 if (!SWIG_IsOK(res1)) {
38777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38778 }
38779 arg1 = reinterpret_cast< wxMenu * >(argp1);
38780 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38781 if (!SWIG_IsOK(res2)) {
38782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38783 }
38784 {
38785 PyThreadState* __tstate = wxPyBeginAllowThreads();
38786 result = (wxMenuItem *)(arg1)->Append(arg2);
38787 wxPyEndAllowThreads(__tstate);
38788 if (PyErr_Occurred()) SWIG_fail;
38789 }
38790 {
38791 resultobj = wxPyMake_wxObject(result, (bool)0);
38792 }
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38800 PyObject *resultobj = 0;
38801 wxMenu *arg1 = (wxMenu *) 0 ;
38802 size_t arg2 ;
38803 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38804 wxMenuItem *result = 0 ;
38805 void *argp1 = 0 ;
38806 int res1 = 0 ;
38807 size_t val2 ;
38808 int ecode2 = 0 ;
38809 int res3 = 0 ;
38810 PyObject * obj0 = 0 ;
38811 PyObject * obj1 = 0 ;
38812 PyObject * obj2 = 0 ;
38813 char * kwnames[] = {
38814 (char *) "self",(char *) "pos",(char *) "item", NULL
38815 };
38816
38817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38819 if (!SWIG_IsOK(res1)) {
38820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38821 }
38822 arg1 = reinterpret_cast< wxMenu * >(argp1);
38823 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38824 if (!SWIG_IsOK(ecode2)) {
38825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38826 }
38827 arg2 = static_cast< size_t >(val2);
38828 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38829 if (!SWIG_IsOK(res3)) {
38830 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38831 }
38832 {
38833 PyThreadState* __tstate = wxPyBeginAllowThreads();
38834 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38835 wxPyEndAllowThreads(__tstate);
38836 if (PyErr_Occurred()) SWIG_fail;
38837 }
38838 {
38839 resultobj = wxPyMake_wxObject(result, (bool)0);
38840 }
38841 return resultobj;
38842 fail:
38843 return NULL;
38844 }
38845
38846
38847 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38848 PyObject *resultobj = 0;
38849 wxMenu *arg1 = (wxMenu *) 0 ;
38850 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38851 wxMenuItem *result = 0 ;
38852 void *argp1 = 0 ;
38853 int res1 = 0 ;
38854 int res2 = 0 ;
38855 PyObject * obj0 = 0 ;
38856 PyObject * obj1 = 0 ;
38857 char * kwnames[] = {
38858 (char *) "self",(char *) "item", NULL
38859 };
38860
38861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38863 if (!SWIG_IsOK(res1)) {
38864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38865 }
38866 arg1 = reinterpret_cast< wxMenu * >(argp1);
38867 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38868 if (!SWIG_IsOK(res2)) {
38869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38870 }
38871 {
38872 PyThreadState* __tstate = wxPyBeginAllowThreads();
38873 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38874 wxPyEndAllowThreads(__tstate);
38875 if (PyErr_Occurred()) SWIG_fail;
38876 }
38877 {
38878 resultobj = wxPyMake_wxObject(result, (bool)0);
38879 }
38880 return resultobj;
38881 fail:
38882 return NULL;
38883 }
38884
38885
38886 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38887 PyObject *resultobj = 0;
38888 wxMenu *arg1 = (wxMenu *) 0 ;
38889 void *argp1 = 0 ;
38890 int res1 = 0 ;
38891 PyObject *swig_obj[1] ;
38892
38893 if (!args) SWIG_fail;
38894 swig_obj[0] = args;
38895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38896 if (!SWIG_IsOK(res1)) {
38897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38898 }
38899 arg1 = reinterpret_cast< wxMenu * >(argp1);
38900 {
38901 PyThreadState* __tstate = wxPyBeginAllowThreads();
38902 (arg1)->Break();
38903 wxPyEndAllowThreads(__tstate);
38904 if (PyErr_Occurred()) SWIG_fail;
38905 }
38906 resultobj = SWIG_Py_Void();
38907 return resultobj;
38908 fail:
38909 return NULL;
38910 }
38911
38912
38913 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38914 PyObject *resultobj = 0;
38915 wxMenu *arg1 = (wxMenu *) 0 ;
38916 size_t arg2 ;
38917 int arg3 ;
38918 wxString *arg4 = 0 ;
38919 wxString const &arg5_defvalue = wxPyEmptyString ;
38920 wxString *arg5 = (wxString *) &arg5_defvalue ;
38921 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38922 wxMenuItem *result = 0 ;
38923 void *argp1 = 0 ;
38924 int res1 = 0 ;
38925 size_t val2 ;
38926 int ecode2 = 0 ;
38927 int val3 ;
38928 int ecode3 = 0 ;
38929 bool temp4 = false ;
38930 bool temp5 = false ;
38931 int val6 ;
38932 int ecode6 = 0 ;
38933 PyObject * obj0 = 0 ;
38934 PyObject * obj1 = 0 ;
38935 PyObject * obj2 = 0 ;
38936 PyObject * obj3 = 0 ;
38937 PyObject * obj4 = 0 ;
38938 PyObject * obj5 = 0 ;
38939 char * kwnames[] = {
38940 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38941 };
38942
38943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38945 if (!SWIG_IsOK(res1)) {
38946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38947 }
38948 arg1 = reinterpret_cast< wxMenu * >(argp1);
38949 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38950 if (!SWIG_IsOK(ecode2)) {
38951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38952 }
38953 arg2 = static_cast< size_t >(val2);
38954 ecode3 = SWIG_AsVal_int(obj2, &val3);
38955 if (!SWIG_IsOK(ecode3)) {
38956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38957 }
38958 arg3 = static_cast< int >(val3);
38959 {
38960 arg4 = wxString_in_helper(obj3);
38961 if (arg4 == NULL) SWIG_fail;
38962 temp4 = true;
38963 }
38964 if (obj4) {
38965 {
38966 arg5 = wxString_in_helper(obj4);
38967 if (arg5 == NULL) SWIG_fail;
38968 temp5 = true;
38969 }
38970 }
38971 if (obj5) {
38972 ecode6 = SWIG_AsVal_int(obj5, &val6);
38973 if (!SWIG_IsOK(ecode6)) {
38974 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38975 }
38976 arg6 = static_cast< wxItemKind >(val6);
38977 }
38978 {
38979 PyThreadState* __tstate = wxPyBeginAllowThreads();
38980 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38981 wxPyEndAllowThreads(__tstate);
38982 if (PyErr_Occurred()) SWIG_fail;
38983 }
38984 {
38985 resultobj = wxPyMake_wxObject(result, (bool)0);
38986 }
38987 {
38988 if (temp4)
38989 delete arg4;
38990 }
38991 {
38992 if (temp5)
38993 delete arg5;
38994 }
38995 return resultobj;
38996 fail:
38997 {
38998 if (temp4)
38999 delete arg4;
39000 }
39001 {
39002 if (temp5)
39003 delete arg5;
39004 }
39005 return NULL;
39006 }
39007
39008
39009 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39010 PyObject *resultobj = 0;
39011 wxMenu *arg1 = (wxMenu *) 0 ;
39012 size_t arg2 ;
39013 wxMenuItem *result = 0 ;
39014 void *argp1 = 0 ;
39015 int res1 = 0 ;
39016 size_t val2 ;
39017 int ecode2 = 0 ;
39018 PyObject * obj0 = 0 ;
39019 PyObject * obj1 = 0 ;
39020 char * kwnames[] = {
39021 (char *) "self",(char *) "pos", NULL
39022 };
39023
39024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39026 if (!SWIG_IsOK(res1)) {
39027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39028 }
39029 arg1 = reinterpret_cast< wxMenu * >(argp1);
39030 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39031 if (!SWIG_IsOK(ecode2)) {
39032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39033 }
39034 arg2 = static_cast< size_t >(val2);
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 {
39042 resultobj = wxPyMake_wxObject(result, (bool)0);
39043 }
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39051 PyObject *resultobj = 0;
39052 wxMenu *arg1 = (wxMenu *) 0 ;
39053 size_t arg2 ;
39054 int arg3 ;
39055 wxString *arg4 = 0 ;
39056 wxString const &arg5_defvalue = wxPyEmptyString ;
39057 wxString *arg5 = (wxString *) &arg5_defvalue ;
39058 wxMenuItem *result = 0 ;
39059 void *argp1 = 0 ;
39060 int res1 = 0 ;
39061 size_t val2 ;
39062 int ecode2 = 0 ;
39063 int val3 ;
39064 int ecode3 = 0 ;
39065 bool temp4 = false ;
39066 bool temp5 = false ;
39067 PyObject * obj0 = 0 ;
39068 PyObject * obj1 = 0 ;
39069 PyObject * obj2 = 0 ;
39070 PyObject * obj3 = 0 ;
39071 PyObject * obj4 = 0 ;
39072 char * kwnames[] = {
39073 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39074 };
39075
39076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39080 }
39081 arg1 = reinterpret_cast< wxMenu * >(argp1);
39082 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39083 if (!SWIG_IsOK(ecode2)) {
39084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39085 }
39086 arg2 = static_cast< size_t >(val2);
39087 ecode3 = SWIG_AsVal_int(obj2, &val3);
39088 if (!SWIG_IsOK(ecode3)) {
39089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39090 }
39091 arg3 = static_cast< int >(val3);
39092 {
39093 arg4 = wxString_in_helper(obj3);
39094 if (arg4 == NULL) SWIG_fail;
39095 temp4 = true;
39096 }
39097 if (obj4) {
39098 {
39099 arg5 = wxString_in_helper(obj4);
39100 if (arg5 == NULL) SWIG_fail;
39101 temp5 = true;
39102 }
39103 }
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 {
39111 resultobj = wxPyMake_wxObject(result, (bool)0);
39112 }
39113 {
39114 if (temp4)
39115 delete arg4;
39116 }
39117 {
39118 if (temp5)
39119 delete arg5;
39120 }
39121 return resultobj;
39122 fail:
39123 {
39124 if (temp4)
39125 delete arg4;
39126 }
39127 {
39128 if (temp5)
39129 delete arg5;
39130 }
39131 return NULL;
39132 }
39133
39134
39135 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj = 0;
39137 wxMenu *arg1 = (wxMenu *) 0 ;
39138 size_t arg2 ;
39139 int arg3 ;
39140 wxString *arg4 = 0 ;
39141 wxString const &arg5_defvalue = wxPyEmptyString ;
39142 wxString *arg5 = (wxString *) &arg5_defvalue ;
39143 wxMenuItem *result = 0 ;
39144 void *argp1 = 0 ;
39145 int res1 = 0 ;
39146 size_t val2 ;
39147 int ecode2 = 0 ;
39148 int val3 ;
39149 int ecode3 = 0 ;
39150 bool temp4 = false ;
39151 bool temp5 = false ;
39152 PyObject * obj0 = 0 ;
39153 PyObject * obj1 = 0 ;
39154 PyObject * obj2 = 0 ;
39155 PyObject * obj3 = 0 ;
39156 PyObject * obj4 = 0 ;
39157 char * kwnames[] = {
39158 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39159 };
39160
39161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39163 if (!SWIG_IsOK(res1)) {
39164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39165 }
39166 arg1 = reinterpret_cast< wxMenu * >(argp1);
39167 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39168 if (!SWIG_IsOK(ecode2)) {
39169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39170 }
39171 arg2 = static_cast< size_t >(val2);
39172 ecode3 = SWIG_AsVal_int(obj2, &val3);
39173 if (!SWIG_IsOK(ecode3)) {
39174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39175 }
39176 arg3 = static_cast< int >(val3);
39177 {
39178 arg4 = wxString_in_helper(obj3);
39179 if (arg4 == NULL) SWIG_fail;
39180 temp4 = true;
39181 }
39182 if (obj4) {
39183 {
39184 arg5 = wxString_in_helper(obj4);
39185 if (arg5 == NULL) SWIG_fail;
39186 temp5 = true;
39187 }
39188 }
39189 {
39190 PyThreadState* __tstate = wxPyBeginAllowThreads();
39191 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39192 wxPyEndAllowThreads(__tstate);
39193 if (PyErr_Occurred()) SWIG_fail;
39194 }
39195 {
39196 resultobj = wxPyMake_wxObject(result, (bool)0);
39197 }
39198 {
39199 if (temp4)
39200 delete arg4;
39201 }
39202 {
39203 if (temp5)
39204 delete arg5;
39205 }
39206 return resultobj;
39207 fail:
39208 {
39209 if (temp4)
39210 delete arg4;
39211 }
39212 {
39213 if (temp5)
39214 delete arg5;
39215 }
39216 return NULL;
39217 }
39218
39219
39220 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39221 PyObject *resultobj = 0;
39222 wxMenu *arg1 = (wxMenu *) 0 ;
39223 size_t arg2 ;
39224 int arg3 ;
39225 wxString *arg4 = 0 ;
39226 wxMenu *arg5 = (wxMenu *) 0 ;
39227 wxString const &arg6_defvalue = wxPyEmptyString ;
39228 wxString *arg6 = (wxString *) &arg6_defvalue ;
39229 wxMenuItem *result = 0 ;
39230 void *argp1 = 0 ;
39231 int res1 = 0 ;
39232 size_t val2 ;
39233 int ecode2 = 0 ;
39234 int val3 ;
39235 int ecode3 = 0 ;
39236 bool temp4 = false ;
39237 void *argp5 = 0 ;
39238 int res5 = 0 ;
39239 bool temp6 = false ;
39240 PyObject * obj0 = 0 ;
39241 PyObject * obj1 = 0 ;
39242 PyObject * obj2 = 0 ;
39243 PyObject * obj3 = 0 ;
39244 PyObject * obj4 = 0 ;
39245 PyObject * obj5 = 0 ;
39246 char * kwnames[] = {
39247 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39248 };
39249
39250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39252 if (!SWIG_IsOK(res1)) {
39253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39254 }
39255 arg1 = reinterpret_cast< wxMenu * >(argp1);
39256 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39257 if (!SWIG_IsOK(ecode2)) {
39258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39259 }
39260 arg2 = static_cast< size_t >(val2);
39261 ecode3 = SWIG_AsVal_int(obj2, &val3);
39262 if (!SWIG_IsOK(ecode3)) {
39263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39264 }
39265 arg3 = static_cast< int >(val3);
39266 {
39267 arg4 = wxString_in_helper(obj3);
39268 if (arg4 == NULL) SWIG_fail;
39269 temp4 = true;
39270 }
39271 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39272 if (!SWIG_IsOK(res5)) {
39273 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39274 }
39275 arg5 = reinterpret_cast< wxMenu * >(argp5);
39276 if (obj5) {
39277 {
39278 arg6 = wxString_in_helper(obj5);
39279 if (arg6 == NULL) SWIG_fail;
39280 temp6 = true;
39281 }
39282 }
39283 {
39284 PyThreadState* __tstate = wxPyBeginAllowThreads();
39285 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39286 wxPyEndAllowThreads(__tstate);
39287 if (PyErr_Occurred()) SWIG_fail;
39288 }
39289 {
39290 resultobj = wxPyMake_wxObject(result, (bool)0);
39291 }
39292 {
39293 if (temp4)
39294 delete arg4;
39295 }
39296 {
39297 if (temp6)
39298 delete arg6;
39299 }
39300 return resultobj;
39301 fail:
39302 {
39303 if (temp4)
39304 delete arg4;
39305 }
39306 {
39307 if (temp6)
39308 delete arg6;
39309 }
39310 return NULL;
39311 }
39312
39313
39314 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39315 PyObject *resultobj = 0;
39316 wxMenu *arg1 = (wxMenu *) 0 ;
39317 int arg2 ;
39318 wxString *arg3 = 0 ;
39319 wxString const &arg4_defvalue = wxPyEmptyString ;
39320 wxString *arg4 = (wxString *) &arg4_defvalue ;
39321 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39322 wxMenuItem *result = 0 ;
39323 void *argp1 = 0 ;
39324 int res1 = 0 ;
39325 int val2 ;
39326 int ecode2 = 0 ;
39327 bool temp3 = false ;
39328 bool temp4 = false ;
39329 int val5 ;
39330 int ecode5 = 0 ;
39331 PyObject * obj0 = 0 ;
39332 PyObject * obj1 = 0 ;
39333 PyObject * obj2 = 0 ;
39334 PyObject * obj3 = 0 ;
39335 PyObject * obj4 = 0 ;
39336 char * kwnames[] = {
39337 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39338 };
39339
39340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39342 if (!SWIG_IsOK(res1)) {
39343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39344 }
39345 arg1 = reinterpret_cast< wxMenu * >(argp1);
39346 ecode2 = SWIG_AsVal_int(obj1, &val2);
39347 if (!SWIG_IsOK(ecode2)) {
39348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39349 }
39350 arg2 = static_cast< int >(val2);
39351 {
39352 arg3 = wxString_in_helper(obj2);
39353 if (arg3 == NULL) SWIG_fail;
39354 temp3 = true;
39355 }
39356 if (obj3) {
39357 {
39358 arg4 = wxString_in_helper(obj3);
39359 if (arg4 == NULL) SWIG_fail;
39360 temp4 = true;
39361 }
39362 }
39363 if (obj4) {
39364 ecode5 = SWIG_AsVal_int(obj4, &val5);
39365 if (!SWIG_IsOK(ecode5)) {
39366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39367 }
39368 arg5 = static_cast< wxItemKind >(val5);
39369 }
39370 {
39371 PyThreadState* __tstate = wxPyBeginAllowThreads();
39372 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39373 wxPyEndAllowThreads(__tstate);
39374 if (PyErr_Occurred()) SWIG_fail;
39375 }
39376 {
39377 resultobj = wxPyMake_wxObject(result, (bool)0);
39378 }
39379 {
39380 if (temp3)
39381 delete arg3;
39382 }
39383 {
39384 if (temp4)
39385 delete arg4;
39386 }
39387 return resultobj;
39388 fail:
39389 {
39390 if (temp3)
39391 delete arg3;
39392 }
39393 {
39394 if (temp4)
39395 delete arg4;
39396 }
39397 return NULL;
39398 }
39399
39400
39401 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39402 PyObject *resultobj = 0;
39403 wxMenu *arg1 = (wxMenu *) 0 ;
39404 wxMenuItem *result = 0 ;
39405 void *argp1 = 0 ;
39406 int res1 = 0 ;
39407 PyObject *swig_obj[1] ;
39408
39409 if (!args) SWIG_fail;
39410 swig_obj[0] = args;
39411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39412 if (!SWIG_IsOK(res1)) {
39413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39414 }
39415 arg1 = reinterpret_cast< wxMenu * >(argp1);
39416 {
39417 PyThreadState* __tstate = wxPyBeginAllowThreads();
39418 result = (wxMenuItem *)(arg1)->PrependSeparator();
39419 wxPyEndAllowThreads(__tstate);
39420 if (PyErr_Occurred()) SWIG_fail;
39421 }
39422 {
39423 resultobj = wxPyMake_wxObject(result, (bool)0);
39424 }
39425 return resultobj;
39426 fail:
39427 return NULL;
39428 }
39429
39430
39431 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39432 PyObject *resultobj = 0;
39433 wxMenu *arg1 = (wxMenu *) 0 ;
39434 int arg2 ;
39435 wxString *arg3 = 0 ;
39436 wxString const &arg4_defvalue = wxPyEmptyString ;
39437 wxString *arg4 = (wxString *) &arg4_defvalue ;
39438 wxMenuItem *result = 0 ;
39439 void *argp1 = 0 ;
39440 int res1 = 0 ;
39441 int val2 ;
39442 int ecode2 = 0 ;
39443 bool temp3 = false ;
39444 bool temp4 = false ;
39445 PyObject * obj0 = 0 ;
39446 PyObject * obj1 = 0 ;
39447 PyObject * obj2 = 0 ;
39448 PyObject * obj3 = 0 ;
39449 char * kwnames[] = {
39450 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39451 };
39452
39453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39455 if (!SWIG_IsOK(res1)) {
39456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39457 }
39458 arg1 = reinterpret_cast< wxMenu * >(argp1);
39459 ecode2 = SWIG_AsVal_int(obj1, &val2);
39460 if (!SWIG_IsOK(ecode2)) {
39461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39462 }
39463 arg2 = static_cast< int >(val2);
39464 {
39465 arg3 = wxString_in_helper(obj2);
39466 if (arg3 == NULL) SWIG_fail;
39467 temp3 = true;
39468 }
39469 if (obj3) {
39470 {
39471 arg4 = wxString_in_helper(obj3);
39472 if (arg4 == NULL) SWIG_fail;
39473 temp4 = true;
39474 }
39475 }
39476 {
39477 PyThreadState* __tstate = wxPyBeginAllowThreads();
39478 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39479 wxPyEndAllowThreads(__tstate);
39480 if (PyErr_Occurred()) SWIG_fail;
39481 }
39482 {
39483 resultobj = wxPyMake_wxObject(result, (bool)0);
39484 }
39485 {
39486 if (temp3)
39487 delete arg3;
39488 }
39489 {
39490 if (temp4)
39491 delete arg4;
39492 }
39493 return resultobj;
39494 fail:
39495 {
39496 if (temp3)
39497 delete arg3;
39498 }
39499 {
39500 if (temp4)
39501 delete arg4;
39502 }
39503 return NULL;
39504 }
39505
39506
39507 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39508 PyObject *resultobj = 0;
39509 wxMenu *arg1 = (wxMenu *) 0 ;
39510 int arg2 ;
39511 wxString *arg3 = 0 ;
39512 wxString const &arg4_defvalue = wxPyEmptyString ;
39513 wxString *arg4 = (wxString *) &arg4_defvalue ;
39514 wxMenuItem *result = 0 ;
39515 void *argp1 = 0 ;
39516 int res1 = 0 ;
39517 int val2 ;
39518 int ecode2 = 0 ;
39519 bool temp3 = false ;
39520 bool temp4 = false ;
39521 PyObject * obj0 = 0 ;
39522 PyObject * obj1 = 0 ;
39523 PyObject * obj2 = 0 ;
39524 PyObject * obj3 = 0 ;
39525 char * kwnames[] = {
39526 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39527 };
39528
39529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39531 if (!SWIG_IsOK(res1)) {
39532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39533 }
39534 arg1 = reinterpret_cast< wxMenu * >(argp1);
39535 ecode2 = SWIG_AsVal_int(obj1, &val2);
39536 if (!SWIG_IsOK(ecode2)) {
39537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39538 }
39539 arg2 = static_cast< int >(val2);
39540 {
39541 arg3 = wxString_in_helper(obj2);
39542 if (arg3 == NULL) SWIG_fail;
39543 temp3 = true;
39544 }
39545 if (obj3) {
39546 {
39547 arg4 = wxString_in_helper(obj3);
39548 if (arg4 == NULL) SWIG_fail;
39549 temp4 = true;
39550 }
39551 }
39552 {
39553 PyThreadState* __tstate = wxPyBeginAllowThreads();
39554 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39555 wxPyEndAllowThreads(__tstate);
39556 if (PyErr_Occurred()) SWIG_fail;
39557 }
39558 {
39559 resultobj = wxPyMake_wxObject(result, (bool)0);
39560 }
39561 {
39562 if (temp3)
39563 delete arg3;
39564 }
39565 {
39566 if (temp4)
39567 delete arg4;
39568 }
39569 return resultobj;
39570 fail:
39571 {
39572 if (temp3)
39573 delete arg3;
39574 }
39575 {
39576 if (temp4)
39577 delete arg4;
39578 }
39579 return NULL;
39580 }
39581
39582
39583 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39584 PyObject *resultobj = 0;
39585 wxMenu *arg1 = (wxMenu *) 0 ;
39586 int arg2 ;
39587 wxString *arg3 = 0 ;
39588 wxMenu *arg4 = (wxMenu *) 0 ;
39589 wxString const &arg5_defvalue = wxPyEmptyString ;
39590 wxString *arg5 = (wxString *) &arg5_defvalue ;
39591 wxMenuItem *result = 0 ;
39592 void *argp1 = 0 ;
39593 int res1 = 0 ;
39594 int val2 ;
39595 int ecode2 = 0 ;
39596 bool temp3 = false ;
39597 void *argp4 = 0 ;
39598 int res4 = 0 ;
39599 bool temp5 = false ;
39600 PyObject * obj0 = 0 ;
39601 PyObject * obj1 = 0 ;
39602 PyObject * obj2 = 0 ;
39603 PyObject * obj3 = 0 ;
39604 PyObject * obj4 = 0 ;
39605 char * kwnames[] = {
39606 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39607 };
39608
39609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39611 if (!SWIG_IsOK(res1)) {
39612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39613 }
39614 arg1 = reinterpret_cast< wxMenu * >(argp1);
39615 ecode2 = SWIG_AsVal_int(obj1, &val2);
39616 if (!SWIG_IsOK(ecode2)) {
39617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39618 }
39619 arg2 = static_cast< int >(val2);
39620 {
39621 arg3 = wxString_in_helper(obj2);
39622 if (arg3 == NULL) SWIG_fail;
39623 temp3 = true;
39624 }
39625 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39626 if (!SWIG_IsOK(res4)) {
39627 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39628 }
39629 arg4 = reinterpret_cast< wxMenu * >(argp4);
39630 if (obj4) {
39631 {
39632 arg5 = wxString_in_helper(obj4);
39633 if (arg5 == NULL) SWIG_fail;
39634 temp5 = true;
39635 }
39636 }
39637 {
39638 PyThreadState* __tstate = wxPyBeginAllowThreads();
39639 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39640 wxPyEndAllowThreads(__tstate);
39641 if (PyErr_Occurred()) SWIG_fail;
39642 }
39643 {
39644 resultobj = wxPyMake_wxObject(result, (bool)0);
39645 }
39646 {
39647 if (temp3)
39648 delete arg3;
39649 }
39650 {
39651 if (temp5)
39652 delete arg5;
39653 }
39654 return resultobj;
39655 fail:
39656 {
39657 if (temp3)
39658 delete arg3;
39659 }
39660 {
39661 if (temp5)
39662 delete arg5;
39663 }
39664 return NULL;
39665 }
39666
39667
39668 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39669 PyObject *resultobj = 0;
39670 wxMenu *arg1 = (wxMenu *) 0 ;
39671 int arg2 ;
39672 wxMenuItem *result = 0 ;
39673 void *argp1 = 0 ;
39674 int res1 = 0 ;
39675 int val2 ;
39676 int ecode2 = 0 ;
39677 PyObject * obj0 = 0 ;
39678 PyObject * obj1 = 0 ;
39679 char * kwnames[] = {
39680 (char *) "self",(char *) "id", NULL
39681 };
39682
39683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39685 if (!SWIG_IsOK(res1)) {
39686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39687 }
39688 arg1 = reinterpret_cast< wxMenu * >(argp1);
39689 ecode2 = SWIG_AsVal_int(obj1, &val2);
39690 if (!SWIG_IsOK(ecode2)) {
39691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39692 }
39693 arg2 = static_cast< int >(val2);
39694 {
39695 PyThreadState* __tstate = wxPyBeginAllowThreads();
39696 result = (wxMenuItem *)(arg1)->Remove(arg2);
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 {
39701 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39702 }
39703 return resultobj;
39704 fail:
39705 return NULL;
39706 }
39707
39708
39709 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39710 PyObject *resultobj = 0;
39711 wxMenu *arg1 = (wxMenu *) 0 ;
39712 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39713 wxMenuItem *result = 0 ;
39714 void *argp1 = 0 ;
39715 int res1 = 0 ;
39716 void *argp2 = 0 ;
39717 int res2 = 0 ;
39718 PyObject * obj0 = 0 ;
39719 PyObject * obj1 = 0 ;
39720 char * kwnames[] = {
39721 (char *) "self",(char *) "item", NULL
39722 };
39723
39724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39726 if (!SWIG_IsOK(res1)) {
39727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39728 }
39729 arg1 = reinterpret_cast< wxMenu * >(argp1);
39730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39731 if (!SWIG_IsOK(res2)) {
39732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39733 }
39734 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39735 {
39736 PyThreadState* __tstate = wxPyBeginAllowThreads();
39737 result = (wxMenuItem *)(arg1)->Remove(arg2);
39738 wxPyEndAllowThreads(__tstate);
39739 if (PyErr_Occurred()) SWIG_fail;
39740 }
39741 {
39742 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39743 }
39744 return resultobj;
39745 fail:
39746 return NULL;
39747 }
39748
39749
39750 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39751 PyObject *resultobj = 0;
39752 wxMenu *arg1 = (wxMenu *) 0 ;
39753 int arg2 ;
39754 bool result;
39755 void *argp1 = 0 ;
39756 int res1 = 0 ;
39757 int val2 ;
39758 int ecode2 = 0 ;
39759 PyObject * obj0 = 0 ;
39760 PyObject * obj1 = 0 ;
39761 char * kwnames[] = {
39762 (char *) "self",(char *) "id", NULL
39763 };
39764
39765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39767 if (!SWIG_IsOK(res1)) {
39768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39769 }
39770 arg1 = reinterpret_cast< wxMenu * >(argp1);
39771 ecode2 = SWIG_AsVal_int(obj1, &val2);
39772 if (!SWIG_IsOK(ecode2)) {
39773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39774 }
39775 arg2 = static_cast< int >(val2);
39776 {
39777 PyThreadState* __tstate = wxPyBeginAllowThreads();
39778 result = (bool)(arg1)->Delete(arg2);
39779 wxPyEndAllowThreads(__tstate);
39780 if (PyErr_Occurred()) SWIG_fail;
39781 }
39782 {
39783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39784 }
39785 return resultobj;
39786 fail:
39787 return NULL;
39788 }
39789
39790
39791 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39792 PyObject *resultobj = 0;
39793 wxMenu *arg1 = (wxMenu *) 0 ;
39794 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39795 bool result;
39796 void *argp1 = 0 ;
39797 int res1 = 0 ;
39798 void *argp2 = 0 ;
39799 int res2 = 0 ;
39800 PyObject * obj0 = 0 ;
39801 PyObject * obj1 = 0 ;
39802 char * kwnames[] = {
39803 (char *) "self",(char *) "item", NULL
39804 };
39805
39806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39808 if (!SWIG_IsOK(res1)) {
39809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39810 }
39811 arg1 = reinterpret_cast< wxMenu * >(argp1);
39812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39813 if (!SWIG_IsOK(res2)) {
39814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39815 }
39816 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39817 {
39818 PyThreadState* __tstate = wxPyBeginAllowThreads();
39819 result = (bool)(arg1)->Delete(arg2);
39820 wxPyEndAllowThreads(__tstate);
39821 if (PyErr_Occurred()) SWIG_fail;
39822 }
39823 {
39824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39825 }
39826 return resultobj;
39827 fail:
39828 return NULL;
39829 }
39830
39831
39832 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39833 PyObject *resultobj = 0;
39834 wxMenu *arg1 = (wxMenu *) 0 ;
39835 void *argp1 = 0 ;
39836 int res1 = 0 ;
39837 PyObject *swig_obj[1] ;
39838
39839 if (!args) SWIG_fail;
39840 swig_obj[0] = args;
39841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39842 if (!SWIG_IsOK(res1)) {
39843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39844 }
39845 arg1 = reinterpret_cast< wxMenu * >(argp1);
39846 {
39847 PyThreadState* __tstate = wxPyBeginAllowThreads();
39848 wxMenu_Destroy(arg1);
39849 wxPyEndAllowThreads(__tstate);
39850 if (PyErr_Occurred()) SWIG_fail;
39851 }
39852 resultobj = SWIG_Py_Void();
39853 return resultobj;
39854 fail:
39855 return NULL;
39856 }
39857
39858
39859 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39860 PyObject *resultobj = 0;
39861 wxMenu *arg1 = (wxMenu *) 0 ;
39862 int arg2 ;
39863 bool result;
39864 void *argp1 = 0 ;
39865 int res1 = 0 ;
39866 int val2 ;
39867 int ecode2 = 0 ;
39868 PyObject * obj0 = 0 ;
39869 PyObject * obj1 = 0 ;
39870 char * kwnames[] = {
39871 (char *) "self",(char *) "id", NULL
39872 };
39873
39874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39876 if (!SWIG_IsOK(res1)) {
39877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39878 }
39879 arg1 = reinterpret_cast< wxMenu * >(argp1);
39880 ecode2 = SWIG_AsVal_int(obj1, &val2);
39881 if (!SWIG_IsOK(ecode2)) {
39882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39883 }
39884 arg2 = static_cast< int >(val2);
39885 {
39886 PyThreadState* __tstate = wxPyBeginAllowThreads();
39887 result = (bool)(arg1)->Destroy(arg2);
39888 wxPyEndAllowThreads(__tstate);
39889 if (PyErr_Occurred()) SWIG_fail;
39890 }
39891 {
39892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39893 }
39894 return resultobj;
39895 fail:
39896 return NULL;
39897 }
39898
39899
39900 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39901 PyObject *resultobj = 0;
39902 wxMenu *arg1 = (wxMenu *) 0 ;
39903 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39904 bool result;
39905 void *argp1 = 0 ;
39906 int res1 = 0 ;
39907 void *argp2 = 0 ;
39908 int res2 = 0 ;
39909 PyObject * obj0 = 0 ;
39910 PyObject * obj1 = 0 ;
39911 char * kwnames[] = {
39912 (char *) "self",(char *) "item", NULL
39913 };
39914
39915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39917 if (!SWIG_IsOK(res1)) {
39918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39919 }
39920 arg1 = reinterpret_cast< wxMenu * >(argp1);
39921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39922 if (!SWIG_IsOK(res2)) {
39923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39924 }
39925 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39926 {
39927 PyThreadState* __tstate = wxPyBeginAllowThreads();
39928 result = (bool)(arg1)->Destroy(arg2);
39929 wxPyEndAllowThreads(__tstate);
39930 if (PyErr_Occurred()) SWIG_fail;
39931 }
39932 {
39933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39934 }
39935 return resultobj;
39936 fail:
39937 return NULL;
39938 }
39939
39940
39941 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39942 PyObject *resultobj = 0;
39943 wxMenu *arg1 = (wxMenu *) 0 ;
39944 size_t result;
39945 void *argp1 = 0 ;
39946 int res1 = 0 ;
39947 PyObject *swig_obj[1] ;
39948
39949 if (!args) SWIG_fail;
39950 swig_obj[0] = args;
39951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39952 if (!SWIG_IsOK(res1)) {
39953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39954 }
39955 arg1 = reinterpret_cast< wxMenu * >(argp1);
39956 {
39957 PyThreadState* __tstate = wxPyBeginAllowThreads();
39958 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39959 wxPyEndAllowThreads(__tstate);
39960 if (PyErr_Occurred()) SWIG_fail;
39961 }
39962 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39963 return resultobj;
39964 fail:
39965 return NULL;
39966 }
39967
39968
39969 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39970 PyObject *resultobj = 0;
39971 wxMenu *arg1 = (wxMenu *) 0 ;
39972 PyObject *result = 0 ;
39973 void *argp1 = 0 ;
39974 int res1 = 0 ;
39975 PyObject *swig_obj[1] ;
39976
39977 if (!args) SWIG_fail;
39978 swig_obj[0] = args;
39979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39980 if (!SWIG_IsOK(res1)) {
39981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39982 }
39983 arg1 = reinterpret_cast< wxMenu * >(argp1);
39984 {
39985 PyThreadState* __tstate = wxPyBeginAllowThreads();
39986 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 resultobj = result;
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39998 PyObject *resultobj = 0;
39999 wxMenu *arg1 = (wxMenu *) 0 ;
40000 wxString *arg2 = 0 ;
40001 int result;
40002 void *argp1 = 0 ;
40003 int res1 = 0 ;
40004 bool temp2 = false ;
40005 PyObject * obj0 = 0 ;
40006 PyObject * obj1 = 0 ;
40007 char * kwnames[] = {
40008 (char *) "self",(char *) "item", NULL
40009 };
40010
40011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40013 if (!SWIG_IsOK(res1)) {
40014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40015 }
40016 arg1 = reinterpret_cast< wxMenu * >(argp1);
40017 {
40018 arg2 = wxString_in_helper(obj1);
40019 if (arg2 == NULL) SWIG_fail;
40020 temp2 = true;
40021 }
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40025 wxPyEndAllowThreads(__tstate);
40026 if (PyErr_Occurred()) SWIG_fail;
40027 }
40028 resultobj = SWIG_From_int(static_cast< int >(result));
40029 {
40030 if (temp2)
40031 delete arg2;
40032 }
40033 return resultobj;
40034 fail:
40035 {
40036 if (temp2)
40037 delete arg2;
40038 }
40039 return NULL;
40040 }
40041
40042
40043 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj = 0;
40045 wxMenu *arg1 = (wxMenu *) 0 ;
40046 int arg2 ;
40047 wxMenuItem *result = 0 ;
40048 void *argp1 = 0 ;
40049 int res1 = 0 ;
40050 int val2 ;
40051 int ecode2 = 0 ;
40052 PyObject * obj0 = 0 ;
40053 PyObject * obj1 = 0 ;
40054 char * kwnames[] = {
40055 (char *) "self",(char *) "id", NULL
40056 };
40057
40058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40060 if (!SWIG_IsOK(res1)) {
40061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40062 }
40063 arg1 = reinterpret_cast< wxMenu * >(argp1);
40064 ecode2 = SWIG_AsVal_int(obj1, &val2);
40065 if (!SWIG_IsOK(ecode2)) {
40066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40067 }
40068 arg2 = static_cast< int >(val2);
40069 {
40070 PyThreadState* __tstate = wxPyBeginAllowThreads();
40071 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40072 wxPyEndAllowThreads(__tstate);
40073 if (PyErr_Occurred()) SWIG_fail;
40074 }
40075 {
40076 resultobj = wxPyMake_wxObject(result, (bool)0);
40077 }
40078 return resultobj;
40079 fail:
40080 return NULL;
40081 }
40082
40083
40084 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40085 PyObject *resultobj = 0;
40086 wxMenu *arg1 = (wxMenu *) 0 ;
40087 size_t arg2 ;
40088 wxMenuItem *result = 0 ;
40089 void *argp1 = 0 ;
40090 int res1 = 0 ;
40091 size_t val2 ;
40092 int ecode2 = 0 ;
40093 PyObject * obj0 = 0 ;
40094 PyObject * obj1 = 0 ;
40095 char * kwnames[] = {
40096 (char *) "self",(char *) "position", NULL
40097 };
40098
40099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40101 if (!SWIG_IsOK(res1)) {
40102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40103 }
40104 arg1 = reinterpret_cast< wxMenu * >(argp1);
40105 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40106 if (!SWIG_IsOK(ecode2)) {
40107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40108 }
40109 arg2 = static_cast< size_t >(val2);
40110 {
40111 PyThreadState* __tstate = wxPyBeginAllowThreads();
40112 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40113 wxPyEndAllowThreads(__tstate);
40114 if (PyErr_Occurred()) SWIG_fail;
40115 }
40116 {
40117 resultobj = wxPyMake_wxObject(result, (bool)0);
40118 }
40119 return resultobj;
40120 fail:
40121 return NULL;
40122 }
40123
40124
40125 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40126 PyObject *resultobj = 0;
40127 wxMenu *arg1 = (wxMenu *) 0 ;
40128 int arg2 ;
40129 bool arg3 ;
40130 void *argp1 = 0 ;
40131 int res1 = 0 ;
40132 int val2 ;
40133 int ecode2 = 0 ;
40134 bool val3 ;
40135 int ecode3 = 0 ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 PyObject * obj2 = 0 ;
40139 char * kwnames[] = {
40140 (char *) "self",(char *) "id",(char *) "enable", NULL
40141 };
40142
40143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40147 }
40148 arg1 = reinterpret_cast< wxMenu * >(argp1);
40149 ecode2 = SWIG_AsVal_int(obj1, &val2);
40150 if (!SWIG_IsOK(ecode2)) {
40151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40152 }
40153 arg2 = static_cast< int >(val2);
40154 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40155 if (!SWIG_IsOK(ecode3)) {
40156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40157 }
40158 arg3 = static_cast< bool >(val3);
40159 {
40160 PyThreadState* __tstate = wxPyBeginAllowThreads();
40161 (arg1)->Enable(arg2,arg3);
40162 wxPyEndAllowThreads(__tstate);
40163 if (PyErr_Occurred()) SWIG_fail;
40164 }
40165 resultobj = SWIG_Py_Void();
40166 return resultobj;
40167 fail:
40168 return NULL;
40169 }
40170
40171
40172 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40173 PyObject *resultobj = 0;
40174 wxMenu *arg1 = (wxMenu *) 0 ;
40175 int arg2 ;
40176 bool result;
40177 void *argp1 = 0 ;
40178 int res1 = 0 ;
40179 int val2 ;
40180 int ecode2 = 0 ;
40181 PyObject * obj0 = 0 ;
40182 PyObject * obj1 = 0 ;
40183 char * kwnames[] = {
40184 (char *) "self",(char *) "id", NULL
40185 };
40186
40187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40189 if (!SWIG_IsOK(res1)) {
40190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40191 }
40192 arg1 = reinterpret_cast< wxMenu * >(argp1);
40193 ecode2 = SWIG_AsVal_int(obj1, &val2);
40194 if (!SWIG_IsOK(ecode2)) {
40195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40196 }
40197 arg2 = static_cast< int >(val2);
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40201 wxPyEndAllowThreads(__tstate);
40202 if (PyErr_Occurred()) SWIG_fail;
40203 }
40204 {
40205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40206 }
40207 return resultobj;
40208 fail:
40209 return NULL;
40210 }
40211
40212
40213 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40214 PyObject *resultobj = 0;
40215 wxMenu *arg1 = (wxMenu *) 0 ;
40216 int arg2 ;
40217 bool arg3 ;
40218 void *argp1 = 0 ;
40219 int res1 = 0 ;
40220 int val2 ;
40221 int ecode2 = 0 ;
40222 bool val3 ;
40223 int ecode3 = 0 ;
40224 PyObject * obj0 = 0 ;
40225 PyObject * obj1 = 0 ;
40226 PyObject * obj2 = 0 ;
40227 char * kwnames[] = {
40228 (char *) "self",(char *) "id",(char *) "check", NULL
40229 };
40230
40231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40233 if (!SWIG_IsOK(res1)) {
40234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40235 }
40236 arg1 = reinterpret_cast< wxMenu * >(argp1);
40237 ecode2 = SWIG_AsVal_int(obj1, &val2);
40238 if (!SWIG_IsOK(ecode2)) {
40239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40240 }
40241 arg2 = static_cast< int >(val2);
40242 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40243 if (!SWIG_IsOK(ecode3)) {
40244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40245 }
40246 arg3 = static_cast< bool >(val3);
40247 {
40248 PyThreadState* __tstate = wxPyBeginAllowThreads();
40249 (arg1)->Check(arg2,arg3);
40250 wxPyEndAllowThreads(__tstate);
40251 if (PyErr_Occurred()) SWIG_fail;
40252 }
40253 resultobj = SWIG_Py_Void();
40254 return resultobj;
40255 fail:
40256 return NULL;
40257 }
40258
40259
40260 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40261 PyObject *resultobj = 0;
40262 wxMenu *arg1 = (wxMenu *) 0 ;
40263 int arg2 ;
40264 bool result;
40265 void *argp1 = 0 ;
40266 int res1 = 0 ;
40267 int val2 ;
40268 int ecode2 = 0 ;
40269 PyObject * obj0 = 0 ;
40270 PyObject * obj1 = 0 ;
40271 char * kwnames[] = {
40272 (char *) "self",(char *) "id", NULL
40273 };
40274
40275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40277 if (!SWIG_IsOK(res1)) {
40278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40279 }
40280 arg1 = reinterpret_cast< wxMenu * >(argp1);
40281 ecode2 = SWIG_AsVal_int(obj1, &val2);
40282 if (!SWIG_IsOK(ecode2)) {
40283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40284 }
40285 arg2 = static_cast< int >(val2);
40286 {
40287 PyThreadState* __tstate = wxPyBeginAllowThreads();
40288 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40289 wxPyEndAllowThreads(__tstate);
40290 if (PyErr_Occurred()) SWIG_fail;
40291 }
40292 {
40293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40294 }
40295 return resultobj;
40296 fail:
40297 return NULL;
40298 }
40299
40300
40301 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40302 PyObject *resultobj = 0;
40303 wxMenu *arg1 = (wxMenu *) 0 ;
40304 int arg2 ;
40305 wxString *arg3 = 0 ;
40306 void *argp1 = 0 ;
40307 int res1 = 0 ;
40308 int val2 ;
40309 int ecode2 = 0 ;
40310 bool temp3 = false ;
40311 PyObject * obj0 = 0 ;
40312 PyObject * obj1 = 0 ;
40313 PyObject * obj2 = 0 ;
40314 char * kwnames[] = {
40315 (char *) "self",(char *) "id",(char *) "label", NULL
40316 };
40317
40318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40320 if (!SWIG_IsOK(res1)) {
40321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40322 }
40323 arg1 = reinterpret_cast< wxMenu * >(argp1);
40324 ecode2 = SWIG_AsVal_int(obj1, &val2);
40325 if (!SWIG_IsOK(ecode2)) {
40326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40327 }
40328 arg2 = static_cast< int >(val2);
40329 {
40330 arg3 = wxString_in_helper(obj2);
40331 if (arg3 == NULL) SWIG_fail;
40332 temp3 = true;
40333 }
40334 {
40335 PyThreadState* __tstate = wxPyBeginAllowThreads();
40336 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40337 wxPyEndAllowThreads(__tstate);
40338 if (PyErr_Occurred()) SWIG_fail;
40339 }
40340 resultobj = SWIG_Py_Void();
40341 {
40342 if (temp3)
40343 delete arg3;
40344 }
40345 return resultobj;
40346 fail:
40347 {
40348 if (temp3)
40349 delete arg3;
40350 }
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxMenu *arg1 = (wxMenu *) 0 ;
40358 int arg2 ;
40359 wxString result;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 int val2 ;
40363 int ecode2 = 0 ;
40364 PyObject * obj0 = 0 ;
40365 PyObject * obj1 = 0 ;
40366 char * kwnames[] = {
40367 (char *) "self",(char *) "id", NULL
40368 };
40369
40370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40372 if (!SWIG_IsOK(res1)) {
40373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40374 }
40375 arg1 = reinterpret_cast< wxMenu * >(argp1);
40376 ecode2 = SWIG_AsVal_int(obj1, &val2);
40377 if (!SWIG_IsOK(ecode2)) {
40378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40379 }
40380 arg2 = static_cast< int >(val2);
40381 {
40382 PyThreadState* __tstate = wxPyBeginAllowThreads();
40383 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40384 wxPyEndAllowThreads(__tstate);
40385 if (PyErr_Occurred()) SWIG_fail;
40386 }
40387 {
40388 #if wxUSE_UNICODE
40389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40390 #else
40391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40392 #endif
40393 }
40394 return resultobj;
40395 fail:
40396 return NULL;
40397 }
40398
40399
40400 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj = 0;
40402 wxMenu *arg1 = (wxMenu *) 0 ;
40403 int arg2 ;
40404 wxString *arg3 = 0 ;
40405 void *argp1 = 0 ;
40406 int res1 = 0 ;
40407 int val2 ;
40408 int ecode2 = 0 ;
40409 bool temp3 = false ;
40410 PyObject * obj0 = 0 ;
40411 PyObject * obj1 = 0 ;
40412 PyObject * obj2 = 0 ;
40413 char * kwnames[] = {
40414 (char *) "self",(char *) "id",(char *) "helpString", NULL
40415 };
40416
40417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40419 if (!SWIG_IsOK(res1)) {
40420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40421 }
40422 arg1 = reinterpret_cast< wxMenu * >(argp1);
40423 ecode2 = SWIG_AsVal_int(obj1, &val2);
40424 if (!SWIG_IsOK(ecode2)) {
40425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40426 }
40427 arg2 = static_cast< int >(val2);
40428 {
40429 arg3 = wxString_in_helper(obj2);
40430 if (arg3 == NULL) SWIG_fail;
40431 temp3 = true;
40432 }
40433 {
40434 PyThreadState* __tstate = wxPyBeginAllowThreads();
40435 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40436 wxPyEndAllowThreads(__tstate);
40437 if (PyErr_Occurred()) SWIG_fail;
40438 }
40439 resultobj = SWIG_Py_Void();
40440 {
40441 if (temp3)
40442 delete arg3;
40443 }
40444 return resultobj;
40445 fail:
40446 {
40447 if (temp3)
40448 delete arg3;
40449 }
40450 return NULL;
40451 }
40452
40453
40454 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40455 PyObject *resultobj = 0;
40456 wxMenu *arg1 = (wxMenu *) 0 ;
40457 int arg2 ;
40458 wxString result;
40459 void *argp1 = 0 ;
40460 int res1 = 0 ;
40461 int val2 ;
40462 int ecode2 = 0 ;
40463 PyObject * obj0 = 0 ;
40464 PyObject * obj1 = 0 ;
40465 char * kwnames[] = {
40466 (char *) "self",(char *) "id", NULL
40467 };
40468
40469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40471 if (!SWIG_IsOK(res1)) {
40472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40473 }
40474 arg1 = reinterpret_cast< wxMenu * >(argp1);
40475 ecode2 = SWIG_AsVal_int(obj1, &val2);
40476 if (!SWIG_IsOK(ecode2)) {
40477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40478 }
40479 arg2 = static_cast< int >(val2);
40480 {
40481 PyThreadState* __tstate = wxPyBeginAllowThreads();
40482 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 #if wxUSE_UNICODE
40488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40489 #else
40490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40491 #endif
40492 }
40493 return resultobj;
40494 fail:
40495 return NULL;
40496 }
40497
40498
40499 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40500 PyObject *resultobj = 0;
40501 wxMenu *arg1 = (wxMenu *) 0 ;
40502 wxString *arg2 = 0 ;
40503 void *argp1 = 0 ;
40504 int res1 = 0 ;
40505 bool temp2 = false ;
40506 PyObject * obj0 = 0 ;
40507 PyObject * obj1 = 0 ;
40508 char * kwnames[] = {
40509 (char *) "self",(char *) "title", NULL
40510 };
40511
40512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40514 if (!SWIG_IsOK(res1)) {
40515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40516 }
40517 arg1 = reinterpret_cast< wxMenu * >(argp1);
40518 {
40519 arg2 = wxString_in_helper(obj1);
40520 if (arg2 == NULL) SWIG_fail;
40521 temp2 = true;
40522 }
40523 {
40524 PyThreadState* __tstate = wxPyBeginAllowThreads();
40525 (arg1)->SetTitle((wxString const &)*arg2);
40526 wxPyEndAllowThreads(__tstate);
40527 if (PyErr_Occurred()) SWIG_fail;
40528 }
40529 resultobj = SWIG_Py_Void();
40530 {
40531 if (temp2)
40532 delete arg2;
40533 }
40534 return resultobj;
40535 fail:
40536 {
40537 if (temp2)
40538 delete arg2;
40539 }
40540 return NULL;
40541 }
40542
40543
40544 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40545 PyObject *resultobj = 0;
40546 wxMenu *arg1 = (wxMenu *) 0 ;
40547 wxString result;
40548 void *argp1 = 0 ;
40549 int res1 = 0 ;
40550 PyObject *swig_obj[1] ;
40551
40552 if (!args) SWIG_fail;
40553 swig_obj[0] = args;
40554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40555 if (!SWIG_IsOK(res1)) {
40556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40557 }
40558 arg1 = reinterpret_cast< wxMenu * >(argp1);
40559 {
40560 PyThreadState* __tstate = wxPyBeginAllowThreads();
40561 result = ((wxMenu const *)arg1)->GetTitle();
40562 wxPyEndAllowThreads(__tstate);
40563 if (PyErr_Occurred()) SWIG_fail;
40564 }
40565 {
40566 #if wxUSE_UNICODE
40567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40568 #else
40569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40570 #endif
40571 }
40572 return resultobj;
40573 fail:
40574 return NULL;
40575 }
40576
40577
40578 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40579 PyObject *resultobj = 0;
40580 wxMenu *arg1 = (wxMenu *) 0 ;
40581 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40582 void *argp1 = 0 ;
40583 int res1 = 0 ;
40584 void *argp2 = 0 ;
40585 int res2 = 0 ;
40586 PyObject * obj0 = 0 ;
40587 PyObject * obj1 = 0 ;
40588 char * kwnames[] = {
40589 (char *) "self",(char *) "handler", NULL
40590 };
40591
40592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40594 if (!SWIG_IsOK(res1)) {
40595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40596 }
40597 arg1 = reinterpret_cast< wxMenu * >(argp1);
40598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40599 if (!SWIG_IsOK(res2)) {
40600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40601 }
40602 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40603 {
40604 PyThreadState* __tstate = wxPyBeginAllowThreads();
40605 (arg1)->SetEventHandler(arg2);
40606 wxPyEndAllowThreads(__tstate);
40607 if (PyErr_Occurred()) SWIG_fail;
40608 }
40609 resultobj = SWIG_Py_Void();
40610 return resultobj;
40611 fail:
40612 return NULL;
40613 }
40614
40615
40616 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40617 PyObject *resultobj = 0;
40618 wxMenu *arg1 = (wxMenu *) 0 ;
40619 wxEvtHandler *result = 0 ;
40620 void *argp1 = 0 ;
40621 int res1 = 0 ;
40622 PyObject *swig_obj[1] ;
40623
40624 if (!args) SWIG_fail;
40625 swig_obj[0] = args;
40626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40627 if (!SWIG_IsOK(res1)) {
40628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40629 }
40630 arg1 = reinterpret_cast< wxMenu * >(argp1);
40631 {
40632 PyThreadState* __tstate = wxPyBeginAllowThreads();
40633 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40634 wxPyEndAllowThreads(__tstate);
40635 if (PyErr_Occurred()) SWIG_fail;
40636 }
40637 {
40638 resultobj = wxPyMake_wxObject(result, 0);
40639 }
40640 return resultobj;
40641 fail:
40642 return NULL;
40643 }
40644
40645
40646 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40647 PyObject *resultobj = 0;
40648 wxMenu *arg1 = (wxMenu *) 0 ;
40649 wxWindow *arg2 = (wxWindow *) 0 ;
40650 void *argp1 = 0 ;
40651 int res1 = 0 ;
40652 void *argp2 = 0 ;
40653 int res2 = 0 ;
40654 PyObject * obj0 = 0 ;
40655 PyObject * obj1 = 0 ;
40656 char * kwnames[] = {
40657 (char *) "self",(char *) "win", NULL
40658 };
40659
40660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40662 if (!SWIG_IsOK(res1)) {
40663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40664 }
40665 arg1 = reinterpret_cast< wxMenu * >(argp1);
40666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40667 if (!SWIG_IsOK(res2)) {
40668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40669 }
40670 arg2 = reinterpret_cast< wxWindow * >(argp2);
40671 {
40672 PyThreadState* __tstate = wxPyBeginAllowThreads();
40673 (arg1)->SetInvokingWindow(arg2);
40674 wxPyEndAllowThreads(__tstate);
40675 if (PyErr_Occurred()) SWIG_fail;
40676 }
40677 resultobj = SWIG_Py_Void();
40678 return resultobj;
40679 fail:
40680 return NULL;
40681 }
40682
40683
40684 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40685 PyObject *resultobj = 0;
40686 wxMenu *arg1 = (wxMenu *) 0 ;
40687 wxWindow *result = 0 ;
40688 void *argp1 = 0 ;
40689 int res1 = 0 ;
40690 PyObject *swig_obj[1] ;
40691
40692 if (!args) SWIG_fail;
40693 swig_obj[0] = args;
40694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40695 if (!SWIG_IsOK(res1)) {
40696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40697 }
40698 arg1 = reinterpret_cast< wxMenu * >(argp1);
40699 {
40700 PyThreadState* __tstate = wxPyBeginAllowThreads();
40701 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 {
40706 resultobj = wxPyMake_wxObject(result, 0);
40707 }
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40715 PyObject *resultobj = 0;
40716 wxMenu *arg1 = (wxMenu *) 0 ;
40717 long result;
40718 void *argp1 = 0 ;
40719 int res1 = 0 ;
40720 PyObject *swig_obj[1] ;
40721
40722 if (!args) SWIG_fail;
40723 swig_obj[0] = args;
40724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40725 if (!SWIG_IsOK(res1)) {
40726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40727 }
40728 arg1 = reinterpret_cast< wxMenu * >(argp1);
40729 {
40730 PyThreadState* __tstate = wxPyBeginAllowThreads();
40731 result = (long)((wxMenu const *)arg1)->GetStyle();
40732 wxPyEndAllowThreads(__tstate);
40733 if (PyErr_Occurred()) SWIG_fail;
40734 }
40735 resultobj = SWIG_From_long(static_cast< long >(result));
40736 return resultobj;
40737 fail:
40738 return NULL;
40739 }
40740
40741
40742 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40743 PyObject *resultobj = 0;
40744 wxMenu *arg1 = (wxMenu *) 0 ;
40745 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40746 void *argp1 = 0 ;
40747 int res1 = 0 ;
40748 void *argp2 = 0 ;
40749 int res2 = 0 ;
40750 PyObject * obj0 = 0 ;
40751 PyObject * obj1 = 0 ;
40752 char * kwnames[] = {
40753 (char *) "self",(char *) "source", NULL
40754 };
40755
40756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40758 if (!SWIG_IsOK(res1)) {
40759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40760 }
40761 arg1 = reinterpret_cast< wxMenu * >(argp1);
40762 if (obj1) {
40763 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40764 if (!SWIG_IsOK(res2)) {
40765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40766 }
40767 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40768 }
40769 {
40770 PyThreadState* __tstate = wxPyBeginAllowThreads();
40771 (arg1)->UpdateUI(arg2);
40772 wxPyEndAllowThreads(__tstate);
40773 if (PyErr_Occurred()) SWIG_fail;
40774 }
40775 resultobj = SWIG_Py_Void();
40776 return resultobj;
40777 fail:
40778 return NULL;
40779 }
40780
40781
40782 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40783 PyObject *resultobj = 0;
40784 wxMenu *arg1 = (wxMenu *) 0 ;
40785 wxMenuBar *result = 0 ;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 PyObject *swig_obj[1] ;
40789
40790 if (!args) SWIG_fail;
40791 swig_obj[0] = args;
40792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40793 if (!SWIG_IsOK(res1)) {
40794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40795 }
40796 arg1 = reinterpret_cast< wxMenu * >(argp1);
40797 {
40798 PyThreadState* __tstate = wxPyBeginAllowThreads();
40799 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40800 wxPyEndAllowThreads(__tstate);
40801 if (PyErr_Occurred()) SWIG_fail;
40802 }
40803 {
40804 resultobj = wxPyMake_wxObject(result, (bool)0);
40805 }
40806 return resultobj;
40807 fail:
40808 return NULL;
40809 }
40810
40811
40812 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40813 PyObject *resultobj = 0;
40814 wxMenu *arg1 = (wxMenu *) 0 ;
40815 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40816 void *argp1 = 0 ;
40817 int res1 = 0 ;
40818 void *argp2 = 0 ;
40819 int res2 = 0 ;
40820 PyObject * obj0 = 0 ;
40821 PyObject * obj1 = 0 ;
40822 char * kwnames[] = {
40823 (char *) "self",(char *) "menubar", NULL
40824 };
40825
40826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40828 if (!SWIG_IsOK(res1)) {
40829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40830 }
40831 arg1 = reinterpret_cast< wxMenu * >(argp1);
40832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40833 if (!SWIG_IsOK(res2)) {
40834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40835 }
40836 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 (arg1)->Attach(arg2);
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 resultobj = SWIG_Py_Void();
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40851 PyObject *resultobj = 0;
40852 wxMenu *arg1 = (wxMenu *) 0 ;
40853 void *argp1 = 0 ;
40854 int res1 = 0 ;
40855 PyObject *swig_obj[1] ;
40856
40857 if (!args) SWIG_fail;
40858 swig_obj[0] = args;
40859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40860 if (!SWIG_IsOK(res1)) {
40861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40862 }
40863 arg1 = reinterpret_cast< wxMenu * >(argp1);
40864 {
40865 PyThreadState* __tstate = wxPyBeginAllowThreads();
40866 (arg1)->Detach();
40867 wxPyEndAllowThreads(__tstate);
40868 if (PyErr_Occurred()) SWIG_fail;
40869 }
40870 resultobj = SWIG_Py_Void();
40871 return resultobj;
40872 fail:
40873 return NULL;
40874 }
40875
40876
40877 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40878 PyObject *resultobj = 0;
40879 wxMenu *arg1 = (wxMenu *) 0 ;
40880 bool result;
40881 void *argp1 = 0 ;
40882 int res1 = 0 ;
40883 PyObject *swig_obj[1] ;
40884
40885 if (!args) SWIG_fail;
40886 swig_obj[0] = args;
40887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40888 if (!SWIG_IsOK(res1)) {
40889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40890 }
40891 arg1 = reinterpret_cast< wxMenu * >(argp1);
40892 {
40893 PyThreadState* __tstate = wxPyBeginAllowThreads();
40894 result = (bool)((wxMenu const *)arg1)->IsAttached();
40895 wxPyEndAllowThreads(__tstate);
40896 if (PyErr_Occurred()) SWIG_fail;
40897 }
40898 {
40899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40900 }
40901 return resultobj;
40902 fail:
40903 return NULL;
40904 }
40905
40906
40907 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40908 PyObject *resultobj = 0;
40909 wxMenu *arg1 = (wxMenu *) 0 ;
40910 wxMenu *arg2 = (wxMenu *) 0 ;
40911 void *argp1 = 0 ;
40912 int res1 = 0 ;
40913 void *argp2 = 0 ;
40914 int res2 = 0 ;
40915 PyObject * obj0 = 0 ;
40916 PyObject * obj1 = 0 ;
40917 char * kwnames[] = {
40918 (char *) "self",(char *) "parent", NULL
40919 };
40920
40921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40923 if (!SWIG_IsOK(res1)) {
40924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40925 }
40926 arg1 = reinterpret_cast< wxMenu * >(argp1);
40927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40928 if (!SWIG_IsOK(res2)) {
40929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40930 }
40931 arg2 = reinterpret_cast< wxMenu * >(argp2);
40932 {
40933 PyThreadState* __tstate = wxPyBeginAllowThreads();
40934 (arg1)->SetParent(arg2);
40935 wxPyEndAllowThreads(__tstate);
40936 if (PyErr_Occurred()) SWIG_fail;
40937 }
40938 resultobj = SWIG_Py_Void();
40939 return resultobj;
40940 fail:
40941 return NULL;
40942 }
40943
40944
40945 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40946 PyObject *resultobj = 0;
40947 wxMenu *arg1 = (wxMenu *) 0 ;
40948 wxMenu *result = 0 ;
40949 void *argp1 = 0 ;
40950 int res1 = 0 ;
40951 PyObject *swig_obj[1] ;
40952
40953 if (!args) SWIG_fail;
40954 swig_obj[0] = args;
40955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40956 if (!SWIG_IsOK(res1)) {
40957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40958 }
40959 arg1 = reinterpret_cast< wxMenu * >(argp1);
40960 {
40961 PyThreadState* __tstate = wxPyBeginAllowThreads();
40962 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40963 wxPyEndAllowThreads(__tstate);
40964 if (PyErr_Occurred()) SWIG_fail;
40965 }
40966 {
40967 resultobj = wxPyMake_wxObject(result, 0);
40968 }
40969 return resultobj;
40970 fail:
40971 return NULL;
40972 }
40973
40974
40975 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40976 PyObject *obj;
40977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40978 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40979 return SWIG_Py_Void();
40980 }
40981
40982 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40983 return SWIG_Python_InitShadowInstance(args);
40984 }
40985
40986 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40987 PyObject *resultobj = 0;
40988 long arg1 = (long) 0 ;
40989 wxMenuBar *result = 0 ;
40990 long val1 ;
40991 int ecode1 = 0 ;
40992 PyObject * obj0 = 0 ;
40993 char * kwnames[] = {
40994 (char *) "style", NULL
40995 };
40996
40997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40998 if (obj0) {
40999 ecode1 = SWIG_AsVal_long(obj0, &val1);
41000 if (!SWIG_IsOK(ecode1)) {
41001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41002 }
41003 arg1 = static_cast< long >(val1);
41004 }
41005 {
41006 if (!wxPyCheckForApp()) SWIG_fail;
41007 PyThreadState* __tstate = wxPyBeginAllowThreads();
41008 result = (wxMenuBar *)new wxMenuBar(arg1);
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj = 0;
41021 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41022 wxMenu *arg2 = (wxMenu *) 0 ;
41023 wxString *arg3 = 0 ;
41024 bool result;
41025 void *argp1 = 0 ;
41026 int res1 = 0 ;
41027 void *argp2 = 0 ;
41028 int res2 = 0 ;
41029 bool temp3 = false ;
41030 PyObject * obj0 = 0 ;
41031 PyObject * obj1 = 0 ;
41032 PyObject * obj2 = 0 ;
41033 char * kwnames[] = {
41034 (char *) "self",(char *) "menu",(char *) "title", NULL
41035 };
41036
41037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41039 if (!SWIG_IsOK(res1)) {
41040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41041 }
41042 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41044 if (!SWIG_IsOK(res2)) {
41045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41046 }
41047 arg2 = reinterpret_cast< wxMenu * >(argp2);
41048 {
41049 arg3 = wxString_in_helper(obj2);
41050 if (arg3 == NULL) SWIG_fail;
41051 temp3 = true;
41052 }
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41056 wxPyEndAllowThreads(__tstate);
41057 if (PyErr_Occurred()) SWIG_fail;
41058 }
41059 {
41060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41061 }
41062 {
41063 if (temp3)
41064 delete arg3;
41065 }
41066 return resultobj;
41067 fail:
41068 {
41069 if (temp3)
41070 delete arg3;
41071 }
41072 return NULL;
41073 }
41074
41075
41076 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41077 PyObject *resultobj = 0;
41078 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41079 size_t arg2 ;
41080 wxMenu *arg3 = (wxMenu *) 0 ;
41081 wxString *arg4 = 0 ;
41082 bool result;
41083 void *argp1 = 0 ;
41084 int res1 = 0 ;
41085 size_t val2 ;
41086 int ecode2 = 0 ;
41087 void *argp3 = 0 ;
41088 int res3 = 0 ;
41089 bool temp4 = false ;
41090 PyObject * obj0 = 0 ;
41091 PyObject * obj1 = 0 ;
41092 PyObject * obj2 = 0 ;
41093 PyObject * obj3 = 0 ;
41094 char * kwnames[] = {
41095 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41096 };
41097
41098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41100 if (!SWIG_IsOK(res1)) {
41101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41102 }
41103 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41104 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41105 if (!SWIG_IsOK(ecode2)) {
41106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41107 }
41108 arg2 = static_cast< size_t >(val2);
41109 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41110 if (!SWIG_IsOK(res3)) {
41111 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41112 }
41113 arg3 = reinterpret_cast< wxMenu * >(argp3);
41114 {
41115 arg4 = wxString_in_helper(obj3);
41116 if (arg4 == NULL) SWIG_fail;
41117 temp4 = true;
41118 }
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 {
41126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41127 }
41128 {
41129 if (temp4)
41130 delete arg4;
41131 }
41132 return resultobj;
41133 fail:
41134 {
41135 if (temp4)
41136 delete arg4;
41137 }
41138 return NULL;
41139 }
41140
41141
41142 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41143 PyObject *resultobj = 0;
41144 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41145 size_t result;
41146 void *argp1 = 0 ;
41147 int res1 = 0 ;
41148 PyObject *swig_obj[1] ;
41149
41150 if (!args) SWIG_fail;
41151 swig_obj[0] = args;
41152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41153 if (!SWIG_IsOK(res1)) {
41154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41155 }
41156 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41157 {
41158 PyThreadState* __tstate = wxPyBeginAllowThreads();
41159 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41160 wxPyEndAllowThreads(__tstate);
41161 if (PyErr_Occurred()) SWIG_fail;
41162 }
41163 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41164 return resultobj;
41165 fail:
41166 return NULL;
41167 }
41168
41169
41170 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41171 PyObject *resultobj = 0;
41172 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41173 size_t arg2 ;
41174 wxMenu *result = 0 ;
41175 void *argp1 = 0 ;
41176 int res1 = 0 ;
41177 size_t val2 ;
41178 int ecode2 = 0 ;
41179 PyObject * obj0 = 0 ;
41180 PyObject * obj1 = 0 ;
41181 char * kwnames[] = {
41182 (char *) "self",(char *) "pos", NULL
41183 };
41184
41185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41187 if (!SWIG_IsOK(res1)) {
41188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41189 }
41190 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41191 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41192 if (!SWIG_IsOK(ecode2)) {
41193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41194 }
41195 arg2 = static_cast< size_t >(val2);
41196 {
41197 PyThreadState* __tstate = wxPyBeginAllowThreads();
41198 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41199 wxPyEndAllowThreads(__tstate);
41200 if (PyErr_Occurred()) SWIG_fail;
41201 }
41202 {
41203 resultobj = wxPyMake_wxObject(result, 0);
41204 }
41205 return resultobj;
41206 fail:
41207 return NULL;
41208 }
41209
41210
41211 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41212 PyObject *resultobj = 0;
41213 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41214 size_t arg2 ;
41215 wxMenu *arg3 = (wxMenu *) 0 ;
41216 wxString *arg4 = 0 ;
41217 wxMenu *result = 0 ;
41218 void *argp1 = 0 ;
41219 int res1 = 0 ;
41220 size_t val2 ;
41221 int ecode2 = 0 ;
41222 void *argp3 = 0 ;
41223 int res3 = 0 ;
41224 bool temp4 = false ;
41225 PyObject * obj0 = 0 ;
41226 PyObject * obj1 = 0 ;
41227 PyObject * obj2 = 0 ;
41228 PyObject * obj3 = 0 ;
41229 char * kwnames[] = {
41230 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41231 };
41232
41233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41235 if (!SWIG_IsOK(res1)) {
41236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41237 }
41238 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41239 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41240 if (!SWIG_IsOK(ecode2)) {
41241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41242 }
41243 arg2 = static_cast< size_t >(val2);
41244 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41245 if (!SWIG_IsOK(res3)) {
41246 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41247 }
41248 arg3 = reinterpret_cast< wxMenu * >(argp3);
41249 {
41250 arg4 = wxString_in_helper(obj3);
41251 if (arg4 == NULL) SWIG_fail;
41252 temp4 = true;
41253 }
41254 {
41255 PyThreadState* __tstate = wxPyBeginAllowThreads();
41256 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41257 wxPyEndAllowThreads(__tstate);
41258 if (PyErr_Occurred()) SWIG_fail;
41259 }
41260 {
41261 resultobj = wxPyMake_wxObject(result, 0);
41262 }
41263 {
41264 if (temp4)
41265 delete arg4;
41266 }
41267 return resultobj;
41268 fail:
41269 {
41270 if (temp4)
41271 delete arg4;
41272 }
41273 return NULL;
41274 }
41275
41276
41277 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41278 PyObject *resultobj = 0;
41279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41280 size_t arg2 ;
41281 wxMenu *result = 0 ;
41282 void *argp1 = 0 ;
41283 int res1 = 0 ;
41284 size_t val2 ;
41285 int ecode2 = 0 ;
41286 PyObject * obj0 = 0 ;
41287 PyObject * obj1 = 0 ;
41288 char * kwnames[] = {
41289 (char *) "self",(char *) "pos", NULL
41290 };
41291
41292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41294 if (!SWIG_IsOK(res1)) {
41295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41296 }
41297 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41298 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41299 if (!SWIG_IsOK(ecode2)) {
41300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41301 }
41302 arg2 = static_cast< size_t >(val2);
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 result = (wxMenu *)(arg1)->Remove(arg2);
41306 wxPyEndAllowThreads(__tstate);
41307 if (PyErr_Occurred()) SWIG_fail;
41308 }
41309 {
41310 resultobj = wxPyMake_wxObject(result, 0);
41311 }
41312 return resultobj;
41313 fail:
41314 return NULL;
41315 }
41316
41317
41318 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41319 PyObject *resultobj = 0;
41320 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41321 size_t arg2 ;
41322 bool arg3 ;
41323 void *argp1 = 0 ;
41324 int res1 = 0 ;
41325 size_t val2 ;
41326 int ecode2 = 0 ;
41327 bool val3 ;
41328 int ecode3 = 0 ;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 PyObject * obj2 = 0 ;
41332 char * kwnames[] = {
41333 (char *) "self",(char *) "pos",(char *) "enable", NULL
41334 };
41335
41336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41338 if (!SWIG_IsOK(res1)) {
41339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41340 }
41341 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41342 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41343 if (!SWIG_IsOK(ecode2)) {
41344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41345 }
41346 arg2 = static_cast< size_t >(val2);
41347 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41348 if (!SWIG_IsOK(ecode3)) {
41349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41350 }
41351 arg3 = static_cast< bool >(val3);
41352 {
41353 PyThreadState* __tstate = wxPyBeginAllowThreads();
41354 (arg1)->EnableTop(arg2,arg3);
41355 wxPyEndAllowThreads(__tstate);
41356 if (PyErr_Occurred()) SWIG_fail;
41357 }
41358 resultobj = SWIG_Py_Void();
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41366 PyObject *resultobj = 0;
41367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41368 size_t arg2 ;
41369 bool result;
41370 void *argp1 = 0 ;
41371 int res1 = 0 ;
41372 size_t val2 ;
41373 int ecode2 = 0 ;
41374 PyObject * obj0 = 0 ;
41375 PyObject * obj1 = 0 ;
41376 char * kwnames[] = {
41377 (char *) "self",(char *) "pos", NULL
41378 };
41379
41380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41382 if (!SWIG_IsOK(res1)) {
41383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41384 }
41385 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41386 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41387 if (!SWIG_IsOK(ecode2)) {
41388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41389 }
41390 arg2 = static_cast< size_t >(val2);
41391 {
41392 PyThreadState* __tstate = wxPyBeginAllowThreads();
41393 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41394 wxPyEndAllowThreads(__tstate);
41395 if (PyErr_Occurred()) SWIG_fail;
41396 }
41397 {
41398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41399 }
41400 return resultobj;
41401 fail:
41402 return NULL;
41403 }
41404
41405
41406 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41407 PyObject *resultobj = 0;
41408 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41409 size_t arg2 ;
41410 wxString *arg3 = 0 ;
41411 void *argp1 = 0 ;
41412 int res1 = 0 ;
41413 size_t val2 ;
41414 int ecode2 = 0 ;
41415 bool temp3 = false ;
41416 PyObject * obj0 = 0 ;
41417 PyObject * obj1 = 0 ;
41418 PyObject * obj2 = 0 ;
41419 char * kwnames[] = {
41420 (char *) "self",(char *) "pos",(char *) "label", NULL
41421 };
41422
41423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41425 if (!SWIG_IsOK(res1)) {
41426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41427 }
41428 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41429 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41430 if (!SWIG_IsOK(ecode2)) {
41431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41432 }
41433 arg2 = static_cast< size_t >(val2);
41434 {
41435 arg3 = wxString_in_helper(obj2);
41436 if (arg3 == NULL) SWIG_fail;
41437 temp3 = true;
41438 }
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41442 wxPyEndAllowThreads(__tstate);
41443 if (PyErr_Occurred()) SWIG_fail;
41444 }
41445 resultobj = SWIG_Py_Void();
41446 {
41447 if (temp3)
41448 delete arg3;
41449 }
41450 return resultobj;
41451 fail:
41452 {
41453 if (temp3)
41454 delete arg3;
41455 }
41456 return NULL;
41457 }
41458
41459
41460 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41461 PyObject *resultobj = 0;
41462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41463 size_t arg2 ;
41464 wxString result;
41465 void *argp1 = 0 ;
41466 int res1 = 0 ;
41467 size_t val2 ;
41468 int ecode2 = 0 ;
41469 PyObject * obj0 = 0 ;
41470 PyObject * obj1 = 0 ;
41471 char * kwnames[] = {
41472 (char *) "self",(char *) "pos", NULL
41473 };
41474
41475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41477 if (!SWIG_IsOK(res1)) {
41478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41479 }
41480 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41481 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41482 if (!SWIG_IsOK(ecode2)) {
41483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41484 }
41485 arg2 = static_cast< size_t >(val2);
41486 {
41487 PyThreadState* __tstate = wxPyBeginAllowThreads();
41488 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41489 wxPyEndAllowThreads(__tstate);
41490 if (PyErr_Occurred()) SWIG_fail;
41491 }
41492 {
41493 #if wxUSE_UNICODE
41494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41495 #else
41496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41497 #endif
41498 }
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41506 PyObject *resultobj = 0;
41507 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41508 wxString *arg2 = 0 ;
41509 wxString *arg3 = 0 ;
41510 int result;
41511 void *argp1 = 0 ;
41512 int res1 = 0 ;
41513 bool temp2 = false ;
41514 bool temp3 = false ;
41515 PyObject * obj0 = 0 ;
41516 PyObject * obj1 = 0 ;
41517 PyObject * obj2 = 0 ;
41518 char * kwnames[] = {
41519 (char *) "self",(char *) "menu",(char *) "item", NULL
41520 };
41521
41522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41524 if (!SWIG_IsOK(res1)) {
41525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41526 }
41527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41528 {
41529 arg2 = wxString_in_helper(obj1);
41530 if (arg2 == NULL) SWIG_fail;
41531 temp2 = true;
41532 }
41533 {
41534 arg3 = wxString_in_helper(obj2);
41535 if (arg3 == NULL) SWIG_fail;
41536 temp3 = true;
41537 }
41538 {
41539 PyThreadState* __tstate = wxPyBeginAllowThreads();
41540 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41541 wxPyEndAllowThreads(__tstate);
41542 if (PyErr_Occurred()) SWIG_fail;
41543 }
41544 resultobj = SWIG_From_int(static_cast< int >(result));
41545 {
41546 if (temp2)
41547 delete arg2;
41548 }
41549 {
41550 if (temp3)
41551 delete arg3;
41552 }
41553 return resultobj;
41554 fail:
41555 {
41556 if (temp2)
41557 delete arg2;
41558 }
41559 {
41560 if (temp3)
41561 delete arg3;
41562 }
41563 return NULL;
41564 }
41565
41566
41567 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41568 PyObject *resultobj = 0;
41569 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41570 int arg2 ;
41571 wxMenuItem *result = 0 ;
41572 void *argp1 = 0 ;
41573 int res1 = 0 ;
41574 int val2 ;
41575 int ecode2 = 0 ;
41576 PyObject * obj0 = 0 ;
41577 PyObject * obj1 = 0 ;
41578 char * kwnames[] = {
41579 (char *) "self",(char *) "id", NULL
41580 };
41581
41582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41584 if (!SWIG_IsOK(res1)) {
41585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41586 }
41587 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41588 ecode2 = SWIG_AsVal_int(obj1, &val2);
41589 if (!SWIG_IsOK(ecode2)) {
41590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41591 }
41592 arg2 = static_cast< int >(val2);
41593 {
41594 PyThreadState* __tstate = wxPyBeginAllowThreads();
41595 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41596 wxPyEndAllowThreads(__tstate);
41597 if (PyErr_Occurred()) SWIG_fail;
41598 }
41599 {
41600 resultobj = wxPyMake_wxObject(result, (bool)0);
41601 }
41602 return resultobj;
41603 fail:
41604 return NULL;
41605 }
41606
41607
41608 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41609 PyObject *resultobj = 0;
41610 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41611 wxString *arg2 = 0 ;
41612 int result;
41613 void *argp1 = 0 ;
41614 int res1 = 0 ;
41615 bool temp2 = false ;
41616 PyObject * obj0 = 0 ;
41617 PyObject * obj1 = 0 ;
41618 char * kwnames[] = {
41619 (char *) "self",(char *) "title", NULL
41620 };
41621
41622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41624 if (!SWIG_IsOK(res1)) {
41625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41626 }
41627 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41628 {
41629 arg2 = wxString_in_helper(obj1);
41630 if (arg2 == NULL) SWIG_fail;
41631 temp2 = true;
41632 }
41633 {
41634 PyThreadState* __tstate = wxPyBeginAllowThreads();
41635 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41636 wxPyEndAllowThreads(__tstate);
41637 if (PyErr_Occurred()) SWIG_fail;
41638 }
41639 resultobj = SWIG_From_int(static_cast< int >(result));
41640 {
41641 if (temp2)
41642 delete arg2;
41643 }
41644 return resultobj;
41645 fail:
41646 {
41647 if (temp2)
41648 delete arg2;
41649 }
41650 return NULL;
41651 }
41652
41653
41654 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41655 PyObject *resultobj = 0;
41656 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41657 int arg2 ;
41658 bool arg3 ;
41659 void *argp1 = 0 ;
41660 int res1 = 0 ;
41661 int val2 ;
41662 int ecode2 = 0 ;
41663 bool val3 ;
41664 int ecode3 = 0 ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 PyObject * obj2 = 0 ;
41668 char * kwnames[] = {
41669 (char *) "self",(char *) "id",(char *) "enable", NULL
41670 };
41671
41672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41674 if (!SWIG_IsOK(res1)) {
41675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41676 }
41677 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41678 ecode2 = SWIG_AsVal_int(obj1, &val2);
41679 if (!SWIG_IsOK(ecode2)) {
41680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41681 }
41682 arg2 = static_cast< int >(val2);
41683 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41684 if (!SWIG_IsOK(ecode3)) {
41685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41686 }
41687 arg3 = static_cast< bool >(val3);
41688 {
41689 PyThreadState* __tstate = wxPyBeginAllowThreads();
41690 (arg1)->Enable(arg2,arg3);
41691 wxPyEndAllowThreads(__tstate);
41692 if (PyErr_Occurred()) SWIG_fail;
41693 }
41694 resultobj = SWIG_Py_Void();
41695 return resultobj;
41696 fail:
41697 return NULL;
41698 }
41699
41700
41701 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41702 PyObject *resultobj = 0;
41703 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41704 int arg2 ;
41705 bool arg3 ;
41706 void *argp1 = 0 ;
41707 int res1 = 0 ;
41708 int val2 ;
41709 int ecode2 = 0 ;
41710 bool val3 ;
41711 int ecode3 = 0 ;
41712 PyObject * obj0 = 0 ;
41713 PyObject * obj1 = 0 ;
41714 PyObject * obj2 = 0 ;
41715 char * kwnames[] = {
41716 (char *) "self",(char *) "id",(char *) "check", NULL
41717 };
41718
41719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41721 if (!SWIG_IsOK(res1)) {
41722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41723 }
41724 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41725 ecode2 = SWIG_AsVal_int(obj1, &val2);
41726 if (!SWIG_IsOK(ecode2)) {
41727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41728 }
41729 arg2 = static_cast< int >(val2);
41730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41731 if (!SWIG_IsOK(ecode3)) {
41732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41733 }
41734 arg3 = static_cast< bool >(val3);
41735 {
41736 PyThreadState* __tstate = wxPyBeginAllowThreads();
41737 (arg1)->Check(arg2,arg3);
41738 wxPyEndAllowThreads(__tstate);
41739 if (PyErr_Occurred()) SWIG_fail;
41740 }
41741 resultobj = SWIG_Py_Void();
41742 return resultobj;
41743 fail:
41744 return NULL;
41745 }
41746
41747
41748 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41749 PyObject *resultobj = 0;
41750 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41751 int arg2 ;
41752 bool result;
41753 void *argp1 = 0 ;
41754 int res1 = 0 ;
41755 int val2 ;
41756 int ecode2 = 0 ;
41757 PyObject * obj0 = 0 ;
41758 PyObject * obj1 = 0 ;
41759 char * kwnames[] = {
41760 (char *) "self",(char *) "id", NULL
41761 };
41762
41763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41765 if (!SWIG_IsOK(res1)) {
41766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41767 }
41768 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41769 ecode2 = SWIG_AsVal_int(obj1, &val2);
41770 if (!SWIG_IsOK(ecode2)) {
41771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41772 }
41773 arg2 = static_cast< int >(val2);
41774 {
41775 PyThreadState* __tstate = wxPyBeginAllowThreads();
41776 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41777 wxPyEndAllowThreads(__tstate);
41778 if (PyErr_Occurred()) SWIG_fail;
41779 }
41780 {
41781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41782 }
41783 return resultobj;
41784 fail:
41785 return NULL;
41786 }
41787
41788
41789 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41790 PyObject *resultobj = 0;
41791 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41792 int arg2 ;
41793 bool result;
41794 void *argp1 = 0 ;
41795 int res1 = 0 ;
41796 int val2 ;
41797 int ecode2 = 0 ;
41798 PyObject * obj0 = 0 ;
41799 PyObject * obj1 = 0 ;
41800 char * kwnames[] = {
41801 (char *) "self",(char *) "id", NULL
41802 };
41803
41804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41806 if (!SWIG_IsOK(res1)) {
41807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41808 }
41809 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41810 ecode2 = SWIG_AsVal_int(obj1, &val2);
41811 if (!SWIG_IsOK(ecode2)) {
41812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41813 }
41814 arg2 = static_cast< int >(val2);
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41818 wxPyEndAllowThreads(__tstate);
41819 if (PyErr_Occurred()) SWIG_fail;
41820 }
41821 {
41822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41823 }
41824 return resultobj;
41825 fail:
41826 return NULL;
41827 }
41828
41829
41830 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41831 PyObject *resultobj = 0;
41832 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41833 int arg2 ;
41834 wxString *arg3 = 0 ;
41835 void *argp1 = 0 ;
41836 int res1 = 0 ;
41837 int val2 ;
41838 int ecode2 = 0 ;
41839 bool temp3 = false ;
41840 PyObject * obj0 = 0 ;
41841 PyObject * obj1 = 0 ;
41842 PyObject * obj2 = 0 ;
41843 char * kwnames[] = {
41844 (char *) "self",(char *) "id",(char *) "label", NULL
41845 };
41846
41847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41849 if (!SWIG_IsOK(res1)) {
41850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41851 }
41852 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41853 ecode2 = SWIG_AsVal_int(obj1, &val2);
41854 if (!SWIG_IsOK(ecode2)) {
41855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41856 }
41857 arg2 = static_cast< int >(val2);
41858 {
41859 arg3 = wxString_in_helper(obj2);
41860 if (arg3 == NULL) SWIG_fail;
41861 temp3 = true;
41862 }
41863 {
41864 PyThreadState* __tstate = wxPyBeginAllowThreads();
41865 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41866 wxPyEndAllowThreads(__tstate);
41867 if (PyErr_Occurred()) SWIG_fail;
41868 }
41869 resultobj = SWIG_Py_Void();
41870 {
41871 if (temp3)
41872 delete arg3;
41873 }
41874 return resultobj;
41875 fail:
41876 {
41877 if (temp3)
41878 delete arg3;
41879 }
41880 return NULL;
41881 }
41882
41883
41884 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41885 PyObject *resultobj = 0;
41886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41887 int arg2 ;
41888 wxString result;
41889 void *argp1 = 0 ;
41890 int res1 = 0 ;
41891 int val2 ;
41892 int ecode2 = 0 ;
41893 PyObject * obj0 = 0 ;
41894 PyObject * obj1 = 0 ;
41895 char * kwnames[] = {
41896 (char *) "self",(char *) "id", NULL
41897 };
41898
41899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41901 if (!SWIG_IsOK(res1)) {
41902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41903 }
41904 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41905 ecode2 = SWIG_AsVal_int(obj1, &val2);
41906 if (!SWIG_IsOK(ecode2)) {
41907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41908 }
41909 arg2 = static_cast< int >(val2);
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 {
41917 #if wxUSE_UNICODE
41918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41919 #else
41920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41921 #endif
41922 }
41923 return resultobj;
41924 fail:
41925 return NULL;
41926 }
41927
41928
41929 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41930 PyObject *resultobj = 0;
41931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41932 int arg2 ;
41933 wxString *arg3 = 0 ;
41934 void *argp1 = 0 ;
41935 int res1 = 0 ;
41936 int val2 ;
41937 int ecode2 = 0 ;
41938 bool temp3 = false ;
41939 PyObject * obj0 = 0 ;
41940 PyObject * obj1 = 0 ;
41941 PyObject * obj2 = 0 ;
41942 char * kwnames[] = {
41943 (char *) "self",(char *) "id",(char *) "helpString", NULL
41944 };
41945
41946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41948 if (!SWIG_IsOK(res1)) {
41949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41950 }
41951 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41952 ecode2 = SWIG_AsVal_int(obj1, &val2);
41953 if (!SWIG_IsOK(ecode2)) {
41954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41955 }
41956 arg2 = static_cast< int >(val2);
41957 {
41958 arg3 = wxString_in_helper(obj2);
41959 if (arg3 == NULL) SWIG_fail;
41960 temp3 = true;
41961 }
41962 {
41963 PyThreadState* __tstate = wxPyBeginAllowThreads();
41964 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41965 wxPyEndAllowThreads(__tstate);
41966 if (PyErr_Occurred()) SWIG_fail;
41967 }
41968 resultobj = SWIG_Py_Void();
41969 {
41970 if (temp3)
41971 delete arg3;
41972 }
41973 return resultobj;
41974 fail:
41975 {
41976 if (temp3)
41977 delete arg3;
41978 }
41979 return NULL;
41980 }
41981
41982
41983 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41984 PyObject *resultobj = 0;
41985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41986 int arg2 ;
41987 wxString result;
41988 void *argp1 = 0 ;
41989 int res1 = 0 ;
41990 int val2 ;
41991 int ecode2 = 0 ;
41992 PyObject * obj0 = 0 ;
41993 PyObject * obj1 = 0 ;
41994 char * kwnames[] = {
41995 (char *) "self",(char *) "id", NULL
41996 };
41997
41998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42000 if (!SWIG_IsOK(res1)) {
42001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42002 }
42003 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42004 ecode2 = SWIG_AsVal_int(obj1, &val2);
42005 if (!SWIG_IsOK(ecode2)) {
42006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42007 }
42008 arg2 = static_cast< int >(val2);
42009 {
42010 PyThreadState* __tstate = wxPyBeginAllowThreads();
42011 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42012 wxPyEndAllowThreads(__tstate);
42013 if (PyErr_Occurred()) SWIG_fail;
42014 }
42015 {
42016 #if wxUSE_UNICODE
42017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42018 #else
42019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42020 #endif
42021 }
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42029 PyObject *resultobj = 0;
42030 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42031 wxFrame *result = 0 ;
42032 void *argp1 = 0 ;
42033 int res1 = 0 ;
42034 PyObject *swig_obj[1] ;
42035
42036 if (!args) SWIG_fail;
42037 swig_obj[0] = args;
42038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42039 if (!SWIG_IsOK(res1)) {
42040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42041 }
42042 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42043 {
42044 PyThreadState* __tstate = wxPyBeginAllowThreads();
42045 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42046 wxPyEndAllowThreads(__tstate);
42047 if (PyErr_Occurred()) SWIG_fail;
42048 }
42049 {
42050 resultobj = wxPyMake_wxObject(result, (bool)0);
42051 }
42052 return resultobj;
42053 fail:
42054 return NULL;
42055 }
42056
42057
42058 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42059 PyObject *resultobj = 0;
42060 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42061 bool result;
42062 void *argp1 = 0 ;
42063 int res1 = 0 ;
42064 PyObject *swig_obj[1] ;
42065
42066 if (!args) SWIG_fail;
42067 swig_obj[0] = args;
42068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42069 if (!SWIG_IsOK(res1)) {
42070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42071 }
42072 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42073 {
42074 PyThreadState* __tstate = wxPyBeginAllowThreads();
42075 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42076 wxPyEndAllowThreads(__tstate);
42077 if (PyErr_Occurred()) SWIG_fail;
42078 }
42079 {
42080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42081 }
42082 return resultobj;
42083 fail:
42084 return NULL;
42085 }
42086
42087
42088 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42089 PyObject *resultobj = 0;
42090 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42091 wxFrame *arg2 = (wxFrame *) 0 ;
42092 void *argp1 = 0 ;
42093 int res1 = 0 ;
42094 void *argp2 = 0 ;
42095 int res2 = 0 ;
42096 PyObject * obj0 = 0 ;
42097 PyObject * obj1 = 0 ;
42098 char * kwnames[] = {
42099 (char *) "self",(char *) "frame", NULL
42100 };
42101
42102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42104 if (!SWIG_IsOK(res1)) {
42105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42106 }
42107 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42109 if (!SWIG_IsOK(res2)) {
42110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42111 }
42112 arg2 = reinterpret_cast< wxFrame * >(argp2);
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 (arg1)->Attach(arg2);
42116 wxPyEndAllowThreads(__tstate);
42117 if (PyErr_Occurred()) SWIG_fail;
42118 }
42119 resultobj = SWIG_Py_Void();
42120 return resultobj;
42121 fail:
42122 return NULL;
42123 }
42124
42125
42126 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42127 PyObject *resultobj = 0;
42128 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42129 void *argp1 = 0 ;
42130 int res1 = 0 ;
42131 PyObject *swig_obj[1] ;
42132
42133 if (!args) SWIG_fail;
42134 swig_obj[0] = args;
42135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42136 if (!SWIG_IsOK(res1)) {
42137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42138 }
42139 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42140 {
42141 PyThreadState* __tstate = wxPyBeginAllowThreads();
42142 (arg1)->Detach();
42143 wxPyEndAllowThreads(__tstate);
42144 if (PyErr_Occurred()) SWIG_fail;
42145 }
42146 resultobj = SWIG_Py_Void();
42147 return resultobj;
42148 fail:
42149 return NULL;
42150 }
42151
42152
42153 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42154 PyObject *resultobj = 0;
42155 bool arg1 ;
42156 bool val1 ;
42157 int ecode1 = 0 ;
42158 PyObject * obj0 = 0 ;
42159 char * kwnames[] = {
42160 (char *) "enable", NULL
42161 };
42162
42163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42164 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42165 if (!SWIG_IsOK(ecode1)) {
42166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42167 }
42168 arg1 = static_cast< bool >(val1);
42169 {
42170 PyThreadState* __tstate = wxPyBeginAllowThreads();
42171 wxMenuBar_SetAutoWindowMenu(arg1);
42172 wxPyEndAllowThreads(__tstate);
42173 if (PyErr_Occurred()) SWIG_fail;
42174 }
42175 resultobj = SWIG_Py_Void();
42176 return resultobj;
42177 fail:
42178 return NULL;
42179 }
42180
42181
42182 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42183 PyObject *resultobj = 0;
42184 bool result;
42185
42186 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42187 {
42188 PyThreadState* __tstate = wxPyBeginAllowThreads();
42189 result = (bool)wxMenuBar_GetAutoWindowMenu();
42190 wxPyEndAllowThreads(__tstate);
42191 if (PyErr_Occurred()) SWIG_fail;
42192 }
42193 {
42194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42195 }
42196 return resultobj;
42197 fail:
42198 return NULL;
42199 }
42200
42201
42202 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42203 PyObject *obj;
42204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42205 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42206 return SWIG_Py_Void();
42207 }
42208
42209 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42210 return SWIG_Python_InitShadowInstance(args);
42211 }
42212
42213 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42214 PyObject *resultobj = 0;
42215 wxMenu *arg1 = (wxMenu *) NULL ;
42216 int arg2 = (int) wxID_ANY ;
42217 wxString const &arg3_defvalue = wxPyEmptyString ;
42218 wxString *arg3 = (wxString *) &arg3_defvalue ;
42219 wxString const &arg4_defvalue = wxPyEmptyString ;
42220 wxString *arg4 = (wxString *) &arg4_defvalue ;
42221 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42222 wxMenu *arg6 = (wxMenu *) NULL ;
42223 wxMenuItem *result = 0 ;
42224 void *argp1 = 0 ;
42225 int res1 = 0 ;
42226 int val2 ;
42227 int ecode2 = 0 ;
42228 bool temp3 = false ;
42229 bool temp4 = false ;
42230 int val5 ;
42231 int ecode5 = 0 ;
42232 void *argp6 = 0 ;
42233 int res6 = 0 ;
42234 PyObject * obj0 = 0 ;
42235 PyObject * obj1 = 0 ;
42236 PyObject * obj2 = 0 ;
42237 PyObject * obj3 = 0 ;
42238 PyObject * obj4 = 0 ;
42239 PyObject * obj5 = 0 ;
42240 char * kwnames[] = {
42241 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42242 };
42243
42244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42245 if (obj0) {
42246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42247 if (!SWIG_IsOK(res1)) {
42248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42249 }
42250 arg1 = reinterpret_cast< wxMenu * >(argp1);
42251 }
42252 if (obj1) {
42253 ecode2 = SWIG_AsVal_int(obj1, &val2);
42254 if (!SWIG_IsOK(ecode2)) {
42255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42256 }
42257 arg2 = static_cast< int >(val2);
42258 }
42259 if (obj2) {
42260 {
42261 arg3 = wxString_in_helper(obj2);
42262 if (arg3 == NULL) SWIG_fail;
42263 temp3 = true;
42264 }
42265 }
42266 if (obj3) {
42267 {
42268 arg4 = wxString_in_helper(obj3);
42269 if (arg4 == NULL) SWIG_fail;
42270 temp4 = true;
42271 }
42272 }
42273 if (obj4) {
42274 ecode5 = SWIG_AsVal_int(obj4, &val5);
42275 if (!SWIG_IsOK(ecode5)) {
42276 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42277 }
42278 arg5 = static_cast< wxItemKind >(val5);
42279 }
42280 if (obj5) {
42281 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42282 if (!SWIG_IsOK(res6)) {
42283 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42284 }
42285 arg6 = reinterpret_cast< wxMenu * >(argp6);
42286 }
42287 {
42288 PyThreadState* __tstate = wxPyBeginAllowThreads();
42289 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42290 wxPyEndAllowThreads(__tstate);
42291 if (PyErr_Occurred()) SWIG_fail;
42292 }
42293 {
42294 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42295 }
42296 {
42297 if (temp3)
42298 delete arg3;
42299 }
42300 {
42301 if (temp4)
42302 delete arg4;
42303 }
42304 return resultobj;
42305 fail:
42306 {
42307 if (temp3)
42308 delete arg3;
42309 }
42310 {
42311 if (temp4)
42312 delete arg4;
42313 }
42314 return NULL;
42315 }
42316
42317
42318 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42319 PyObject *resultobj = 0;
42320 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42321 void *argp1 = 0 ;
42322 int res1 = 0 ;
42323 PyObject *swig_obj[1] ;
42324
42325 if (!args) SWIG_fail;
42326 swig_obj[0] = args;
42327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42328 if (!SWIG_IsOK(res1)) {
42329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42330 }
42331 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42332 {
42333 PyThreadState* __tstate = wxPyBeginAllowThreads();
42334 delete arg1;
42335
42336 wxPyEndAllowThreads(__tstate);
42337 if (PyErr_Occurred()) SWIG_fail;
42338 }
42339 resultobj = SWIG_Py_Void();
42340 return resultobj;
42341 fail:
42342 return NULL;
42343 }
42344
42345
42346 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42347 PyObject *resultobj = 0;
42348 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42349 wxMenu *result = 0 ;
42350 void *argp1 = 0 ;
42351 int res1 = 0 ;
42352 PyObject *swig_obj[1] ;
42353
42354 if (!args) SWIG_fail;
42355 swig_obj[0] = args;
42356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42357 if (!SWIG_IsOK(res1)) {
42358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42359 }
42360 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42361 {
42362 PyThreadState* __tstate = wxPyBeginAllowThreads();
42363 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42364 wxPyEndAllowThreads(__tstate);
42365 if (PyErr_Occurred()) SWIG_fail;
42366 }
42367 {
42368 resultobj = wxPyMake_wxObject(result, 0);
42369 }
42370 return resultobj;
42371 fail:
42372 return NULL;
42373 }
42374
42375
42376 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42377 PyObject *resultobj = 0;
42378 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42379 wxMenu *arg2 = (wxMenu *) 0 ;
42380 void *argp1 = 0 ;
42381 int res1 = 0 ;
42382 void *argp2 = 0 ;
42383 int res2 = 0 ;
42384 PyObject * obj0 = 0 ;
42385 PyObject * obj1 = 0 ;
42386 char * kwnames[] = {
42387 (char *) "self",(char *) "menu", NULL
42388 };
42389
42390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42392 if (!SWIG_IsOK(res1)) {
42393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42394 }
42395 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42397 if (!SWIG_IsOK(res2)) {
42398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42399 }
42400 arg2 = reinterpret_cast< wxMenu * >(argp2);
42401 {
42402 PyThreadState* __tstate = wxPyBeginAllowThreads();
42403 (arg1)->SetMenu(arg2);
42404 wxPyEndAllowThreads(__tstate);
42405 if (PyErr_Occurred()) SWIG_fail;
42406 }
42407 resultobj = SWIG_Py_Void();
42408 return resultobj;
42409 fail:
42410 return NULL;
42411 }
42412
42413
42414 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42415 PyObject *resultobj = 0;
42416 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42417 int arg2 ;
42418 void *argp1 = 0 ;
42419 int res1 = 0 ;
42420 int val2 ;
42421 int ecode2 = 0 ;
42422 PyObject * obj0 = 0 ;
42423 PyObject * obj1 = 0 ;
42424 char * kwnames[] = {
42425 (char *) "self",(char *) "id", NULL
42426 };
42427
42428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42430 if (!SWIG_IsOK(res1)) {
42431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42432 }
42433 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42434 ecode2 = SWIG_AsVal_int(obj1, &val2);
42435 if (!SWIG_IsOK(ecode2)) {
42436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42437 }
42438 arg2 = static_cast< int >(val2);
42439 {
42440 PyThreadState* __tstate = wxPyBeginAllowThreads();
42441 (arg1)->SetId(arg2);
42442 wxPyEndAllowThreads(__tstate);
42443 if (PyErr_Occurred()) SWIG_fail;
42444 }
42445 resultobj = SWIG_Py_Void();
42446 return resultobj;
42447 fail:
42448 return NULL;
42449 }
42450
42451
42452 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42453 PyObject *resultobj = 0;
42454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42455 int result;
42456 void *argp1 = 0 ;
42457 int res1 = 0 ;
42458 PyObject *swig_obj[1] ;
42459
42460 if (!args) SWIG_fail;
42461 swig_obj[0] = args;
42462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42463 if (!SWIG_IsOK(res1)) {
42464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42465 }
42466 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42467 {
42468 PyThreadState* __tstate = wxPyBeginAllowThreads();
42469 result = (int)((wxMenuItem const *)arg1)->GetId();
42470 wxPyEndAllowThreads(__tstate);
42471 if (PyErr_Occurred()) SWIG_fail;
42472 }
42473 resultobj = SWIG_From_int(static_cast< int >(result));
42474 return resultobj;
42475 fail:
42476 return NULL;
42477 }
42478
42479
42480 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42481 PyObject *resultobj = 0;
42482 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42483 bool result;
42484 void *argp1 = 0 ;
42485 int res1 = 0 ;
42486 PyObject *swig_obj[1] ;
42487
42488 if (!args) SWIG_fail;
42489 swig_obj[0] = args;
42490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42491 if (!SWIG_IsOK(res1)) {
42492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42493 }
42494 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42495 {
42496 PyThreadState* __tstate = wxPyBeginAllowThreads();
42497 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42498 wxPyEndAllowThreads(__tstate);
42499 if (PyErr_Occurred()) SWIG_fail;
42500 }
42501 {
42502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42503 }
42504 return resultobj;
42505 fail:
42506 return NULL;
42507 }
42508
42509
42510 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42511 PyObject *resultobj = 0;
42512 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42513 wxString *arg2 = 0 ;
42514 void *argp1 = 0 ;
42515 int res1 = 0 ;
42516 bool temp2 = false ;
42517 PyObject * obj0 = 0 ;
42518 PyObject * obj1 = 0 ;
42519 char * kwnames[] = {
42520 (char *) "self",(char *) "str", NULL
42521 };
42522
42523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42525 if (!SWIG_IsOK(res1)) {
42526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42527 }
42528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42529 {
42530 arg2 = wxString_in_helper(obj1);
42531 if (arg2 == NULL) SWIG_fail;
42532 temp2 = true;
42533 }
42534 {
42535 PyThreadState* __tstate = wxPyBeginAllowThreads();
42536 (arg1)->SetText((wxString const &)*arg2);
42537 wxPyEndAllowThreads(__tstate);
42538 if (PyErr_Occurred()) SWIG_fail;
42539 }
42540 resultobj = SWIG_Py_Void();
42541 {
42542 if (temp2)
42543 delete arg2;
42544 }
42545 return resultobj;
42546 fail:
42547 {
42548 if (temp2)
42549 delete arg2;
42550 }
42551 return NULL;
42552 }
42553
42554
42555 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42556 PyObject *resultobj = 0;
42557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42558 wxString result;
42559 void *argp1 = 0 ;
42560 int res1 = 0 ;
42561 PyObject *swig_obj[1] ;
42562
42563 if (!args) SWIG_fail;
42564 swig_obj[0] = args;
42565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42566 if (!SWIG_IsOK(res1)) {
42567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42568 }
42569 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42570 {
42571 PyThreadState* __tstate = wxPyBeginAllowThreads();
42572 result = ((wxMenuItem const *)arg1)->GetLabel();
42573 wxPyEndAllowThreads(__tstate);
42574 if (PyErr_Occurred()) SWIG_fail;
42575 }
42576 {
42577 #if wxUSE_UNICODE
42578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42579 #else
42580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42581 #endif
42582 }
42583 return resultobj;
42584 fail:
42585 return NULL;
42586 }
42587
42588
42589 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42590 PyObject *resultobj = 0;
42591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42592 wxString *result = 0 ;
42593 void *argp1 = 0 ;
42594 int res1 = 0 ;
42595 PyObject *swig_obj[1] ;
42596
42597 if (!args) SWIG_fail;
42598 swig_obj[0] = args;
42599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42600 if (!SWIG_IsOK(res1)) {
42601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42602 }
42603 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42604 {
42605 PyThreadState* __tstate = wxPyBeginAllowThreads();
42606 {
42607 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42608 result = (wxString *) &_result_ref;
42609 }
42610 wxPyEndAllowThreads(__tstate);
42611 if (PyErr_Occurred()) SWIG_fail;
42612 }
42613 {
42614 #if wxUSE_UNICODE
42615 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42616 #else
42617 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42618 #endif
42619 }
42620 return resultobj;
42621 fail:
42622 return NULL;
42623 }
42624
42625
42626 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42627 PyObject *resultobj = 0;
42628 wxString *arg1 = 0 ;
42629 wxString result;
42630 bool temp1 = false ;
42631 PyObject * obj0 = 0 ;
42632 char * kwnames[] = {
42633 (char *) "text", NULL
42634 };
42635
42636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42637 {
42638 arg1 = wxString_in_helper(obj0);
42639 if (arg1 == NULL) SWIG_fail;
42640 temp1 = true;
42641 }
42642 {
42643 PyThreadState* __tstate = wxPyBeginAllowThreads();
42644 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42645 wxPyEndAllowThreads(__tstate);
42646 if (PyErr_Occurred()) SWIG_fail;
42647 }
42648 {
42649 #if wxUSE_UNICODE
42650 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42651 #else
42652 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42653 #endif
42654 }
42655 {
42656 if (temp1)
42657 delete arg1;
42658 }
42659 return resultobj;
42660 fail:
42661 {
42662 if (temp1)
42663 delete arg1;
42664 }
42665 return NULL;
42666 }
42667
42668
42669 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42670 PyObject *resultobj = 0;
42671 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42672 wxItemKind result;
42673 void *argp1 = 0 ;
42674 int res1 = 0 ;
42675 PyObject *swig_obj[1] ;
42676
42677 if (!args) SWIG_fail;
42678 swig_obj[0] = args;
42679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42680 if (!SWIG_IsOK(res1)) {
42681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42682 }
42683 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42684 {
42685 PyThreadState* __tstate = wxPyBeginAllowThreads();
42686 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42687 wxPyEndAllowThreads(__tstate);
42688 if (PyErr_Occurred()) SWIG_fail;
42689 }
42690 resultobj = SWIG_From_int(static_cast< int >(result));
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42698 PyObject *resultobj = 0;
42699 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42700 wxItemKind arg2 ;
42701 void *argp1 = 0 ;
42702 int res1 = 0 ;
42703 int val2 ;
42704 int ecode2 = 0 ;
42705 PyObject * obj0 = 0 ;
42706 PyObject * obj1 = 0 ;
42707 char * kwnames[] = {
42708 (char *) "self",(char *) "kind", NULL
42709 };
42710
42711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42713 if (!SWIG_IsOK(res1)) {
42714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42715 }
42716 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42717 ecode2 = SWIG_AsVal_int(obj1, &val2);
42718 if (!SWIG_IsOK(ecode2)) {
42719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42720 }
42721 arg2 = static_cast< wxItemKind >(val2);
42722 {
42723 PyThreadState* __tstate = wxPyBeginAllowThreads();
42724 (arg1)->SetKind(arg2);
42725 wxPyEndAllowThreads(__tstate);
42726 if (PyErr_Occurred()) SWIG_fail;
42727 }
42728 resultobj = SWIG_Py_Void();
42729 return resultobj;
42730 fail:
42731 return NULL;
42732 }
42733
42734
42735 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42736 PyObject *resultobj = 0;
42737 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42738 bool arg2 ;
42739 void *argp1 = 0 ;
42740 int res1 = 0 ;
42741 bool val2 ;
42742 int ecode2 = 0 ;
42743 PyObject * obj0 = 0 ;
42744 PyObject * obj1 = 0 ;
42745 char * kwnames[] = {
42746 (char *) "self",(char *) "checkable", NULL
42747 };
42748
42749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42751 if (!SWIG_IsOK(res1)) {
42752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42753 }
42754 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42756 if (!SWIG_IsOK(ecode2)) {
42757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42758 }
42759 arg2 = static_cast< bool >(val2);
42760 {
42761 PyThreadState* __tstate = wxPyBeginAllowThreads();
42762 (arg1)->SetCheckable(arg2);
42763 wxPyEndAllowThreads(__tstate);
42764 if (PyErr_Occurred()) SWIG_fail;
42765 }
42766 resultobj = SWIG_Py_Void();
42767 return resultobj;
42768 fail:
42769 return NULL;
42770 }
42771
42772
42773 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42774 PyObject *resultobj = 0;
42775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42776 bool result;
42777 void *argp1 = 0 ;
42778 int res1 = 0 ;
42779 PyObject *swig_obj[1] ;
42780
42781 if (!args) SWIG_fail;
42782 swig_obj[0] = args;
42783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42784 if (!SWIG_IsOK(res1)) {
42785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42786 }
42787 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42788 {
42789 PyThreadState* __tstate = wxPyBeginAllowThreads();
42790 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42791 wxPyEndAllowThreads(__tstate);
42792 if (PyErr_Occurred()) SWIG_fail;
42793 }
42794 {
42795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42796 }
42797 return resultobj;
42798 fail:
42799 return NULL;
42800 }
42801
42802
42803 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42804 PyObject *resultobj = 0;
42805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42806 bool result;
42807 void *argp1 = 0 ;
42808 int res1 = 0 ;
42809 PyObject *swig_obj[1] ;
42810
42811 if (!args) SWIG_fail;
42812 swig_obj[0] = args;
42813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42814 if (!SWIG_IsOK(res1)) {
42815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42816 }
42817 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42818 {
42819 PyThreadState* __tstate = wxPyBeginAllowThreads();
42820 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42821 wxPyEndAllowThreads(__tstate);
42822 if (PyErr_Occurred()) SWIG_fail;
42823 }
42824 {
42825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42826 }
42827 return resultobj;
42828 fail:
42829 return NULL;
42830 }
42831
42832
42833 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42834 PyObject *resultobj = 0;
42835 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42836 wxMenu *arg2 = (wxMenu *) 0 ;
42837 void *argp1 = 0 ;
42838 int res1 = 0 ;
42839 void *argp2 = 0 ;
42840 int res2 = 0 ;
42841 PyObject * obj0 = 0 ;
42842 PyObject * obj1 = 0 ;
42843 char * kwnames[] = {
42844 (char *) "self",(char *) "menu", NULL
42845 };
42846
42847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42849 if (!SWIG_IsOK(res1)) {
42850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42851 }
42852 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42854 if (!SWIG_IsOK(res2)) {
42855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42856 }
42857 arg2 = reinterpret_cast< wxMenu * >(argp2);
42858 {
42859 PyThreadState* __tstate = wxPyBeginAllowThreads();
42860 (arg1)->SetSubMenu(arg2);
42861 wxPyEndAllowThreads(__tstate);
42862 if (PyErr_Occurred()) SWIG_fail;
42863 }
42864 resultobj = SWIG_Py_Void();
42865 return resultobj;
42866 fail:
42867 return NULL;
42868 }
42869
42870
42871 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42872 PyObject *resultobj = 0;
42873 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42874 wxMenu *result = 0 ;
42875 void *argp1 = 0 ;
42876 int res1 = 0 ;
42877 PyObject *swig_obj[1] ;
42878
42879 if (!args) SWIG_fail;
42880 swig_obj[0] = args;
42881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42882 if (!SWIG_IsOK(res1)) {
42883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42884 }
42885 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42889 wxPyEndAllowThreads(__tstate);
42890 if (PyErr_Occurred()) SWIG_fail;
42891 }
42892 {
42893 resultobj = wxPyMake_wxObject(result, 0);
42894 }
42895 return resultobj;
42896 fail:
42897 return NULL;
42898 }
42899
42900
42901 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42902 PyObject *resultobj = 0;
42903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42904 bool arg2 = (bool) true ;
42905 void *argp1 = 0 ;
42906 int res1 = 0 ;
42907 bool val2 ;
42908 int ecode2 = 0 ;
42909 PyObject * obj0 = 0 ;
42910 PyObject * obj1 = 0 ;
42911 char * kwnames[] = {
42912 (char *) "self",(char *) "enable", NULL
42913 };
42914
42915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42917 if (!SWIG_IsOK(res1)) {
42918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42919 }
42920 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42921 if (obj1) {
42922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42923 if (!SWIG_IsOK(ecode2)) {
42924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42925 }
42926 arg2 = static_cast< bool >(val2);
42927 }
42928 {
42929 PyThreadState* __tstate = wxPyBeginAllowThreads();
42930 (arg1)->Enable(arg2);
42931 wxPyEndAllowThreads(__tstate);
42932 if (PyErr_Occurred()) SWIG_fail;
42933 }
42934 resultobj = SWIG_Py_Void();
42935 return resultobj;
42936 fail:
42937 return NULL;
42938 }
42939
42940
42941 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42942 PyObject *resultobj = 0;
42943 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42944 bool result;
42945 void *argp1 = 0 ;
42946 int res1 = 0 ;
42947 PyObject *swig_obj[1] ;
42948
42949 if (!args) SWIG_fail;
42950 swig_obj[0] = args;
42951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42952 if (!SWIG_IsOK(res1)) {
42953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42954 }
42955 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42956 {
42957 PyThreadState* __tstate = wxPyBeginAllowThreads();
42958 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42959 wxPyEndAllowThreads(__tstate);
42960 if (PyErr_Occurred()) SWIG_fail;
42961 }
42962 {
42963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42964 }
42965 return resultobj;
42966 fail:
42967 return NULL;
42968 }
42969
42970
42971 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42972 PyObject *resultobj = 0;
42973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42974 bool arg2 = (bool) true ;
42975 void *argp1 = 0 ;
42976 int res1 = 0 ;
42977 bool val2 ;
42978 int ecode2 = 0 ;
42979 PyObject * obj0 = 0 ;
42980 PyObject * obj1 = 0 ;
42981 char * kwnames[] = {
42982 (char *) "self",(char *) "check", NULL
42983 };
42984
42985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42987 if (!SWIG_IsOK(res1)) {
42988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42989 }
42990 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42991 if (obj1) {
42992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42993 if (!SWIG_IsOK(ecode2)) {
42994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42995 }
42996 arg2 = static_cast< bool >(val2);
42997 }
42998 {
42999 PyThreadState* __tstate = wxPyBeginAllowThreads();
43000 (arg1)->Check(arg2);
43001 wxPyEndAllowThreads(__tstate);
43002 if (PyErr_Occurred()) SWIG_fail;
43003 }
43004 resultobj = SWIG_Py_Void();
43005 return resultobj;
43006 fail:
43007 return NULL;
43008 }
43009
43010
43011 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43012 PyObject *resultobj = 0;
43013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43014 bool result;
43015 void *argp1 = 0 ;
43016 int res1 = 0 ;
43017 PyObject *swig_obj[1] ;
43018
43019 if (!args) SWIG_fail;
43020 swig_obj[0] = args;
43021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43022 if (!SWIG_IsOK(res1)) {
43023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43024 }
43025 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43026 {
43027 PyThreadState* __tstate = wxPyBeginAllowThreads();
43028 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43029 wxPyEndAllowThreads(__tstate);
43030 if (PyErr_Occurred()) SWIG_fail;
43031 }
43032 {
43033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43034 }
43035 return resultobj;
43036 fail:
43037 return NULL;
43038 }
43039
43040
43041 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43042 PyObject *resultobj = 0;
43043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43044 void *argp1 = 0 ;
43045 int res1 = 0 ;
43046 PyObject *swig_obj[1] ;
43047
43048 if (!args) SWIG_fail;
43049 swig_obj[0] = args;
43050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43051 if (!SWIG_IsOK(res1)) {
43052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43053 }
43054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43055 {
43056 PyThreadState* __tstate = wxPyBeginAllowThreads();
43057 (arg1)->Toggle();
43058 wxPyEndAllowThreads(__tstate);
43059 if (PyErr_Occurred()) SWIG_fail;
43060 }
43061 resultobj = SWIG_Py_Void();
43062 return resultobj;
43063 fail:
43064 return NULL;
43065 }
43066
43067
43068 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43069 PyObject *resultobj = 0;
43070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43071 wxString *arg2 = 0 ;
43072 void *argp1 = 0 ;
43073 int res1 = 0 ;
43074 bool temp2 = false ;
43075 PyObject * obj0 = 0 ;
43076 PyObject * obj1 = 0 ;
43077 char * kwnames[] = {
43078 (char *) "self",(char *) "str", NULL
43079 };
43080
43081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43083 if (!SWIG_IsOK(res1)) {
43084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43085 }
43086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43087 {
43088 arg2 = wxString_in_helper(obj1);
43089 if (arg2 == NULL) SWIG_fail;
43090 temp2 = true;
43091 }
43092 {
43093 PyThreadState* __tstate = wxPyBeginAllowThreads();
43094 (arg1)->SetHelp((wxString const &)*arg2);
43095 wxPyEndAllowThreads(__tstate);
43096 if (PyErr_Occurred()) SWIG_fail;
43097 }
43098 resultobj = SWIG_Py_Void();
43099 {
43100 if (temp2)
43101 delete arg2;
43102 }
43103 return resultobj;
43104 fail:
43105 {
43106 if (temp2)
43107 delete arg2;
43108 }
43109 return NULL;
43110 }
43111
43112
43113 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43114 PyObject *resultobj = 0;
43115 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43116 wxString *result = 0 ;
43117 void *argp1 = 0 ;
43118 int res1 = 0 ;
43119 PyObject *swig_obj[1] ;
43120
43121 if (!args) SWIG_fail;
43122 swig_obj[0] = args;
43123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43124 if (!SWIG_IsOK(res1)) {
43125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43126 }
43127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43128 {
43129 PyThreadState* __tstate = wxPyBeginAllowThreads();
43130 {
43131 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43132 result = (wxString *) &_result_ref;
43133 }
43134 wxPyEndAllowThreads(__tstate);
43135 if (PyErr_Occurred()) SWIG_fail;
43136 }
43137 {
43138 #if wxUSE_UNICODE
43139 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43140 #else
43141 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43142 #endif
43143 }
43144 return resultobj;
43145 fail:
43146 return NULL;
43147 }
43148
43149
43150 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43151 PyObject *resultobj = 0;
43152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43153 wxAcceleratorEntry *result = 0 ;
43154 void *argp1 = 0 ;
43155 int res1 = 0 ;
43156 PyObject *swig_obj[1] ;
43157
43158 if (!args) SWIG_fail;
43159 swig_obj[0] = args;
43160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43161 if (!SWIG_IsOK(res1)) {
43162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43163 }
43164 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43165 {
43166 PyThreadState* __tstate = wxPyBeginAllowThreads();
43167 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43172 return resultobj;
43173 fail:
43174 return NULL;
43175 }
43176
43177
43178 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43179 PyObject *resultobj = 0;
43180 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43181 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43182 void *argp1 = 0 ;
43183 int res1 = 0 ;
43184 void *argp2 = 0 ;
43185 int res2 = 0 ;
43186 PyObject * obj0 = 0 ;
43187 PyObject * obj1 = 0 ;
43188 char * kwnames[] = {
43189 (char *) "self",(char *) "accel", NULL
43190 };
43191
43192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43194 if (!SWIG_IsOK(res1)) {
43195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43196 }
43197 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43198 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43199 if (!SWIG_IsOK(res2)) {
43200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43201 }
43202 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43203 {
43204 PyThreadState* __tstate = wxPyBeginAllowThreads();
43205 (arg1)->SetAccel(arg2);
43206 wxPyEndAllowThreads(__tstate);
43207 if (PyErr_Occurred()) SWIG_fail;
43208 }
43209 resultobj = SWIG_Py_Void();
43210 return resultobj;
43211 fail:
43212 return NULL;
43213 }
43214
43215
43216 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43217 PyObject *resultobj = 0;
43218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43219 wxBitmap *arg2 = 0 ;
43220 void *argp1 = 0 ;
43221 int res1 = 0 ;
43222 void *argp2 = 0 ;
43223 int res2 = 0 ;
43224 PyObject * obj0 = 0 ;
43225 PyObject * obj1 = 0 ;
43226 char * kwnames[] = {
43227 (char *) "self",(char *) "bitmap", NULL
43228 };
43229
43230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43232 if (!SWIG_IsOK(res1)) {
43233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43234 }
43235 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43237 if (!SWIG_IsOK(res2)) {
43238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43239 }
43240 if (!argp2) {
43241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43242 }
43243 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43244 {
43245 PyThreadState* __tstate = wxPyBeginAllowThreads();
43246 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43247 wxPyEndAllowThreads(__tstate);
43248 if (PyErr_Occurred()) SWIG_fail;
43249 }
43250 resultobj = SWIG_Py_Void();
43251 return resultobj;
43252 fail:
43253 return NULL;
43254 }
43255
43256
43257 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43258 PyObject *resultobj = 0;
43259 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43260 wxBitmap *result = 0 ;
43261 void *argp1 = 0 ;
43262 int res1 = 0 ;
43263 PyObject *swig_obj[1] ;
43264
43265 if (!args) SWIG_fail;
43266 swig_obj[0] = args;
43267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43268 if (!SWIG_IsOK(res1)) {
43269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43270 }
43271 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43272 {
43273 PyThreadState* __tstate = wxPyBeginAllowThreads();
43274 {
43275 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43276 result = (wxBitmap *) &_result_ref;
43277 }
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 {
43282 wxBitmap* resultptr = new wxBitmap(*result);
43283 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43284 }
43285 return resultobj;
43286 fail:
43287 return NULL;
43288 }
43289
43290
43291 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43292 PyObject *resultobj = 0;
43293 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43294 wxFont *arg2 = 0 ;
43295 void *argp1 = 0 ;
43296 int res1 = 0 ;
43297 void *argp2 = 0 ;
43298 int res2 = 0 ;
43299 PyObject * obj0 = 0 ;
43300 PyObject * obj1 = 0 ;
43301 char * kwnames[] = {
43302 (char *) "self",(char *) "font", NULL
43303 };
43304
43305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43307 if (!SWIG_IsOK(res1)) {
43308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43309 }
43310 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43311 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43312 if (!SWIG_IsOK(res2)) {
43313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43314 }
43315 if (!argp2) {
43316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43317 }
43318 arg2 = reinterpret_cast< wxFont * >(argp2);
43319 {
43320 PyThreadState* __tstate = wxPyBeginAllowThreads();
43321 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43322 wxPyEndAllowThreads(__tstate);
43323 if (PyErr_Occurred()) SWIG_fail;
43324 }
43325 resultobj = SWIG_Py_Void();
43326 return resultobj;
43327 fail:
43328 return NULL;
43329 }
43330
43331
43332 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43333 PyObject *resultobj = 0;
43334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43335 wxFont result;
43336 void *argp1 = 0 ;
43337 int res1 = 0 ;
43338 PyObject *swig_obj[1] ;
43339
43340 if (!args) SWIG_fail;
43341 swig_obj[0] = args;
43342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43343 if (!SWIG_IsOK(res1)) {
43344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43345 }
43346 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43347 {
43348 PyThreadState* __tstate = wxPyBeginAllowThreads();
43349 result = wxMenuItem_GetFont(arg1);
43350 wxPyEndAllowThreads(__tstate);
43351 if (PyErr_Occurred()) SWIG_fail;
43352 }
43353 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43354 return resultobj;
43355 fail:
43356 return NULL;
43357 }
43358
43359
43360 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43361 PyObject *resultobj = 0;
43362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43363 wxColour *arg2 = 0 ;
43364 void *argp1 = 0 ;
43365 int res1 = 0 ;
43366 wxColour temp2 ;
43367 PyObject * obj0 = 0 ;
43368 PyObject * obj1 = 0 ;
43369 char * kwnames[] = {
43370 (char *) "self",(char *) "colText", NULL
43371 };
43372
43373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43375 if (!SWIG_IsOK(res1)) {
43376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43377 }
43378 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43379 {
43380 arg2 = &temp2;
43381 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43382 }
43383 {
43384 PyThreadState* __tstate = wxPyBeginAllowThreads();
43385 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43386 wxPyEndAllowThreads(__tstate);
43387 if (PyErr_Occurred()) SWIG_fail;
43388 }
43389 resultobj = SWIG_Py_Void();
43390 return resultobj;
43391 fail:
43392 return NULL;
43393 }
43394
43395
43396 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43397 PyObject *resultobj = 0;
43398 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43399 wxColour result;
43400 void *argp1 = 0 ;
43401 int res1 = 0 ;
43402 PyObject *swig_obj[1] ;
43403
43404 if (!args) SWIG_fail;
43405 swig_obj[0] = args;
43406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43407 if (!SWIG_IsOK(res1)) {
43408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43409 }
43410 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43411 {
43412 PyThreadState* __tstate = wxPyBeginAllowThreads();
43413 result = wxMenuItem_GetTextColour(arg1);
43414 wxPyEndAllowThreads(__tstate);
43415 if (PyErr_Occurred()) SWIG_fail;
43416 }
43417 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43418 return resultobj;
43419 fail:
43420 return NULL;
43421 }
43422
43423
43424 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43425 PyObject *resultobj = 0;
43426 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43427 wxColour *arg2 = 0 ;
43428 void *argp1 = 0 ;
43429 int res1 = 0 ;
43430 wxColour temp2 ;
43431 PyObject * obj0 = 0 ;
43432 PyObject * obj1 = 0 ;
43433 char * kwnames[] = {
43434 (char *) "self",(char *) "colBack", NULL
43435 };
43436
43437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43439 if (!SWIG_IsOK(res1)) {
43440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43441 }
43442 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43443 {
43444 arg2 = &temp2;
43445 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43446 }
43447 {
43448 PyThreadState* __tstate = wxPyBeginAllowThreads();
43449 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43450 wxPyEndAllowThreads(__tstate);
43451 if (PyErr_Occurred()) SWIG_fail;
43452 }
43453 resultobj = SWIG_Py_Void();
43454 return resultobj;
43455 fail:
43456 return NULL;
43457 }
43458
43459
43460 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43461 PyObject *resultobj = 0;
43462 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43463 wxColour result;
43464 void *argp1 = 0 ;
43465 int res1 = 0 ;
43466 PyObject *swig_obj[1] ;
43467
43468 if (!args) SWIG_fail;
43469 swig_obj[0] = args;
43470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43471 if (!SWIG_IsOK(res1)) {
43472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43473 }
43474 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43475 {
43476 PyThreadState* __tstate = wxPyBeginAllowThreads();
43477 result = wxMenuItem_GetBackgroundColour(arg1);
43478 wxPyEndAllowThreads(__tstate);
43479 if (PyErr_Occurred()) SWIG_fail;
43480 }
43481 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43482 return resultobj;
43483 fail:
43484 return NULL;
43485 }
43486
43487
43488 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43489 PyObject *resultobj = 0;
43490 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43491 wxBitmap *arg2 = 0 ;
43492 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43493 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43494 void *argp1 = 0 ;
43495 int res1 = 0 ;
43496 void *argp2 = 0 ;
43497 int res2 = 0 ;
43498 void *argp3 = 0 ;
43499 int res3 = 0 ;
43500 PyObject * obj0 = 0 ;
43501 PyObject * obj1 = 0 ;
43502 PyObject * obj2 = 0 ;
43503 char * kwnames[] = {
43504 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43505 };
43506
43507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43509 if (!SWIG_IsOK(res1)) {
43510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43511 }
43512 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43513 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43514 if (!SWIG_IsOK(res2)) {
43515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43516 }
43517 if (!argp2) {
43518 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43519 }
43520 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43521 if (obj2) {
43522 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43523 if (!SWIG_IsOK(res3)) {
43524 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43525 }
43526 if (!argp3) {
43527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43528 }
43529 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43530 }
43531 {
43532 PyThreadState* __tstate = wxPyBeginAllowThreads();
43533 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 resultobj = SWIG_Py_Void();
43538 return resultobj;
43539 fail:
43540 return NULL;
43541 }
43542
43543
43544 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43545 PyObject *resultobj = 0;
43546 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43547 wxBitmap *arg2 = 0 ;
43548 void *argp1 = 0 ;
43549 int res1 = 0 ;
43550 void *argp2 = 0 ;
43551 int res2 = 0 ;
43552 PyObject * obj0 = 0 ;
43553 PyObject * obj1 = 0 ;
43554 char * kwnames[] = {
43555 (char *) "self",(char *) "bmpDisabled", NULL
43556 };
43557
43558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43560 if (!SWIG_IsOK(res1)) {
43561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43562 }
43563 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43565 if (!SWIG_IsOK(res2)) {
43566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43567 }
43568 if (!argp2) {
43569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43570 }
43571 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43572 {
43573 PyThreadState* __tstate = wxPyBeginAllowThreads();
43574 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43575 wxPyEndAllowThreads(__tstate);
43576 if (PyErr_Occurred()) SWIG_fail;
43577 }
43578 resultobj = SWIG_Py_Void();
43579 return resultobj;
43580 fail:
43581 return NULL;
43582 }
43583
43584
43585 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43586 PyObject *resultobj = 0;
43587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43588 wxBitmap *result = 0 ;
43589 void *argp1 = 0 ;
43590 int res1 = 0 ;
43591 PyObject *swig_obj[1] ;
43592
43593 if (!args) SWIG_fail;
43594 swig_obj[0] = args;
43595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43596 if (!SWIG_IsOK(res1)) {
43597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43598 }
43599 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43600 {
43601 PyThreadState* __tstate = wxPyBeginAllowThreads();
43602 {
43603 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43604 result = (wxBitmap *) &_result_ref;
43605 }
43606 wxPyEndAllowThreads(__tstate);
43607 if (PyErr_Occurred()) SWIG_fail;
43608 }
43609 {
43610 wxBitmap* resultptr = new wxBitmap(*result);
43611 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43612 }
43613 return resultobj;
43614 fail:
43615 return NULL;
43616 }
43617
43618
43619 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43620 PyObject *resultobj = 0;
43621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43622 int arg2 ;
43623 void *argp1 = 0 ;
43624 int res1 = 0 ;
43625 int val2 ;
43626 int ecode2 = 0 ;
43627 PyObject * obj0 = 0 ;
43628 PyObject * obj1 = 0 ;
43629 char * kwnames[] = {
43630 (char *) "self",(char *) "nWidth", NULL
43631 };
43632
43633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43635 if (!SWIG_IsOK(res1)) {
43636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43637 }
43638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43639 ecode2 = SWIG_AsVal_int(obj1, &val2);
43640 if (!SWIG_IsOK(ecode2)) {
43641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43642 }
43643 arg2 = static_cast< int >(val2);
43644 {
43645 PyThreadState* __tstate = wxPyBeginAllowThreads();
43646 wxMenuItem_SetMarginWidth(arg1,arg2);
43647 wxPyEndAllowThreads(__tstate);
43648 if (PyErr_Occurred()) SWIG_fail;
43649 }
43650 resultobj = SWIG_Py_Void();
43651 return resultobj;
43652 fail:
43653 return NULL;
43654 }
43655
43656
43657 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43658 PyObject *resultobj = 0;
43659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43660 int result;
43661 void *argp1 = 0 ;
43662 int res1 = 0 ;
43663 PyObject *swig_obj[1] ;
43664
43665 if (!args) SWIG_fail;
43666 swig_obj[0] = args;
43667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43668 if (!SWIG_IsOK(res1)) {
43669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43670 }
43671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43672 {
43673 PyThreadState* __tstate = wxPyBeginAllowThreads();
43674 result = (int)wxMenuItem_GetMarginWidth(arg1);
43675 wxPyEndAllowThreads(__tstate);
43676 if (PyErr_Occurred()) SWIG_fail;
43677 }
43678 resultobj = SWIG_From_int(static_cast< int >(result));
43679 return resultobj;
43680 fail:
43681 return NULL;
43682 }
43683
43684
43685 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43686 PyObject *resultobj = 0;
43687 int result;
43688
43689 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43690 {
43691 PyThreadState* __tstate = wxPyBeginAllowThreads();
43692 result = (int)wxMenuItem_GetDefaultMarginWidth();
43693 wxPyEndAllowThreads(__tstate);
43694 if (PyErr_Occurred()) SWIG_fail;
43695 }
43696 resultobj = SWIG_From_int(static_cast< int >(result));
43697 return resultobj;
43698 fail:
43699 return NULL;
43700 }
43701
43702
43703 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43704 PyObject *resultobj = 0;
43705 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43706 bool result;
43707 void *argp1 = 0 ;
43708 int res1 = 0 ;
43709 PyObject *swig_obj[1] ;
43710
43711 if (!args) SWIG_fail;
43712 swig_obj[0] = args;
43713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43714 if (!SWIG_IsOK(res1)) {
43715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43716 }
43717 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43718 {
43719 PyThreadState* __tstate = wxPyBeginAllowThreads();
43720 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43721 wxPyEndAllowThreads(__tstate);
43722 if (PyErr_Occurred()) SWIG_fail;
43723 }
43724 {
43725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43726 }
43727 return resultobj;
43728 fail:
43729 return NULL;
43730 }
43731
43732
43733 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43734 PyObject *resultobj = 0;
43735 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43736 bool arg2 = (bool) true ;
43737 void *argp1 = 0 ;
43738 int res1 = 0 ;
43739 bool val2 ;
43740 int ecode2 = 0 ;
43741 PyObject * obj0 = 0 ;
43742 PyObject * obj1 = 0 ;
43743 char * kwnames[] = {
43744 (char *) "self",(char *) "ownerDrawn", NULL
43745 };
43746
43747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43749 if (!SWIG_IsOK(res1)) {
43750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43751 }
43752 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43753 if (obj1) {
43754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43755 if (!SWIG_IsOK(ecode2)) {
43756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43757 }
43758 arg2 = static_cast< bool >(val2);
43759 }
43760 {
43761 PyThreadState* __tstate = wxPyBeginAllowThreads();
43762 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43763 wxPyEndAllowThreads(__tstate);
43764 if (PyErr_Occurred()) SWIG_fail;
43765 }
43766 resultobj = SWIG_Py_Void();
43767 return resultobj;
43768 fail:
43769 return NULL;
43770 }
43771
43772
43773 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43774 PyObject *resultobj = 0;
43775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43776 void *argp1 = 0 ;
43777 int res1 = 0 ;
43778 PyObject *swig_obj[1] ;
43779
43780 if (!args) SWIG_fail;
43781 swig_obj[0] = args;
43782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43783 if (!SWIG_IsOK(res1)) {
43784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43785 }
43786 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43787 {
43788 PyThreadState* __tstate = wxPyBeginAllowThreads();
43789 wxMenuItem_ResetOwnerDrawn(arg1);
43790 wxPyEndAllowThreads(__tstate);
43791 if (PyErr_Occurred()) SWIG_fail;
43792 }
43793 resultobj = SWIG_Py_Void();
43794 return resultobj;
43795 fail:
43796 return NULL;
43797 }
43798
43799
43800 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43801 PyObject *obj;
43802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43803 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43804 return SWIG_Py_Void();
43805 }
43806
43807 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43808 return SWIG_Python_InitShadowInstance(args);
43809 }
43810
43811 SWIGINTERN int ControlNameStr_set(PyObject *) {
43812 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43813 return 1;
43814 }
43815
43816
43817 SWIGINTERN PyObject *ControlNameStr_get(void) {
43818 PyObject *pyobj = 0;
43819
43820 {
43821 #if wxUSE_UNICODE
43822 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43823 #else
43824 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43825 #endif
43826 }
43827 return pyobj;
43828 }
43829
43830
43831 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43832 PyObject *resultobj = 0;
43833 wxWindow *arg1 = (wxWindow *) 0 ;
43834 int arg2 = (int) -1 ;
43835 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43836 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43837 wxSize const &arg4_defvalue = wxDefaultSize ;
43838 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43839 long arg5 = (long) 0 ;
43840 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43841 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43842 wxString const &arg7_defvalue = wxPyControlNameStr ;
43843 wxString *arg7 = (wxString *) &arg7_defvalue ;
43844 wxControl *result = 0 ;
43845 void *argp1 = 0 ;
43846 int res1 = 0 ;
43847 int val2 ;
43848 int ecode2 = 0 ;
43849 wxPoint temp3 ;
43850 wxSize temp4 ;
43851 long val5 ;
43852 int ecode5 = 0 ;
43853 void *argp6 = 0 ;
43854 int res6 = 0 ;
43855 bool temp7 = false ;
43856 PyObject * obj0 = 0 ;
43857 PyObject * obj1 = 0 ;
43858 PyObject * obj2 = 0 ;
43859 PyObject * obj3 = 0 ;
43860 PyObject * obj4 = 0 ;
43861 PyObject * obj5 = 0 ;
43862 PyObject * obj6 = 0 ;
43863 char * kwnames[] = {
43864 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43865 };
43866
43867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43869 if (!SWIG_IsOK(res1)) {
43870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43871 }
43872 arg1 = reinterpret_cast< wxWindow * >(argp1);
43873 if (obj1) {
43874 ecode2 = SWIG_AsVal_int(obj1, &val2);
43875 if (!SWIG_IsOK(ecode2)) {
43876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43877 }
43878 arg2 = static_cast< int >(val2);
43879 }
43880 if (obj2) {
43881 {
43882 arg3 = &temp3;
43883 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43884 }
43885 }
43886 if (obj3) {
43887 {
43888 arg4 = &temp4;
43889 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43890 }
43891 }
43892 if (obj4) {
43893 ecode5 = SWIG_AsVal_long(obj4, &val5);
43894 if (!SWIG_IsOK(ecode5)) {
43895 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43896 }
43897 arg5 = static_cast< long >(val5);
43898 }
43899 if (obj5) {
43900 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43901 if (!SWIG_IsOK(res6)) {
43902 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43903 }
43904 if (!argp6) {
43905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43906 }
43907 arg6 = reinterpret_cast< wxValidator * >(argp6);
43908 }
43909 if (obj6) {
43910 {
43911 arg7 = wxString_in_helper(obj6);
43912 if (arg7 == NULL) SWIG_fail;
43913 temp7 = true;
43914 }
43915 }
43916 {
43917 if (!wxPyCheckForApp()) SWIG_fail;
43918 PyThreadState* __tstate = wxPyBeginAllowThreads();
43919 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43920 wxPyEndAllowThreads(__tstate);
43921 if (PyErr_Occurred()) SWIG_fail;
43922 }
43923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43924 {
43925 if (temp7)
43926 delete arg7;
43927 }
43928 return resultobj;
43929 fail:
43930 {
43931 if (temp7)
43932 delete arg7;
43933 }
43934 return NULL;
43935 }
43936
43937
43938 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43939 PyObject *resultobj = 0;
43940 wxControl *result = 0 ;
43941
43942 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43943 {
43944 if (!wxPyCheckForApp()) SWIG_fail;
43945 PyThreadState* __tstate = wxPyBeginAllowThreads();
43946 result = (wxControl *)new wxControl();
43947 wxPyEndAllowThreads(__tstate);
43948 if (PyErr_Occurred()) SWIG_fail;
43949 }
43950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43951 return resultobj;
43952 fail:
43953 return NULL;
43954 }
43955
43956
43957 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43958 PyObject *resultobj = 0;
43959 wxControl *arg1 = (wxControl *) 0 ;
43960 wxWindow *arg2 = (wxWindow *) 0 ;
43961 int arg3 = (int) -1 ;
43962 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43963 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43964 wxSize const &arg5_defvalue = wxDefaultSize ;
43965 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43966 long arg6 = (long) 0 ;
43967 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43968 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43969 wxString const &arg8_defvalue = wxPyControlNameStr ;
43970 wxString *arg8 = (wxString *) &arg8_defvalue ;
43971 bool result;
43972 void *argp1 = 0 ;
43973 int res1 = 0 ;
43974 void *argp2 = 0 ;
43975 int res2 = 0 ;
43976 int val3 ;
43977 int ecode3 = 0 ;
43978 wxPoint temp4 ;
43979 wxSize temp5 ;
43980 long val6 ;
43981 int ecode6 = 0 ;
43982 void *argp7 = 0 ;
43983 int res7 = 0 ;
43984 bool temp8 = false ;
43985 PyObject * obj0 = 0 ;
43986 PyObject * obj1 = 0 ;
43987 PyObject * obj2 = 0 ;
43988 PyObject * obj3 = 0 ;
43989 PyObject * obj4 = 0 ;
43990 PyObject * obj5 = 0 ;
43991 PyObject * obj6 = 0 ;
43992 PyObject * obj7 = 0 ;
43993 char * kwnames[] = {
43994 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43995 };
43996
43997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43999 if (!SWIG_IsOK(res1)) {
44000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44001 }
44002 arg1 = reinterpret_cast< wxControl * >(argp1);
44003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44004 if (!SWIG_IsOK(res2)) {
44005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44006 }
44007 arg2 = reinterpret_cast< wxWindow * >(argp2);
44008 if (obj2) {
44009 ecode3 = SWIG_AsVal_int(obj2, &val3);
44010 if (!SWIG_IsOK(ecode3)) {
44011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44012 }
44013 arg3 = static_cast< int >(val3);
44014 }
44015 if (obj3) {
44016 {
44017 arg4 = &temp4;
44018 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44019 }
44020 }
44021 if (obj4) {
44022 {
44023 arg5 = &temp5;
44024 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44025 }
44026 }
44027 if (obj5) {
44028 ecode6 = SWIG_AsVal_long(obj5, &val6);
44029 if (!SWIG_IsOK(ecode6)) {
44030 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44031 }
44032 arg6 = static_cast< long >(val6);
44033 }
44034 if (obj6) {
44035 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44036 if (!SWIG_IsOK(res7)) {
44037 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44038 }
44039 if (!argp7) {
44040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44041 }
44042 arg7 = reinterpret_cast< wxValidator * >(argp7);
44043 }
44044 if (obj7) {
44045 {
44046 arg8 = wxString_in_helper(obj7);
44047 if (arg8 == NULL) SWIG_fail;
44048 temp8 = true;
44049 }
44050 }
44051 {
44052 PyThreadState* __tstate = wxPyBeginAllowThreads();
44053 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44054 wxPyEndAllowThreads(__tstate);
44055 if (PyErr_Occurred()) SWIG_fail;
44056 }
44057 {
44058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44059 }
44060 {
44061 if (temp8)
44062 delete arg8;
44063 }
44064 return resultobj;
44065 fail:
44066 {
44067 if (temp8)
44068 delete arg8;
44069 }
44070 return NULL;
44071 }
44072
44073
44074 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44075 PyObject *resultobj = 0;
44076 wxControl *arg1 = (wxControl *) 0 ;
44077 int result;
44078 void *argp1 = 0 ;
44079 int res1 = 0 ;
44080 PyObject *swig_obj[1] ;
44081
44082 if (!args) SWIG_fail;
44083 swig_obj[0] = args;
44084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44085 if (!SWIG_IsOK(res1)) {
44086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44087 }
44088 arg1 = reinterpret_cast< wxControl * >(argp1);
44089 {
44090 PyThreadState* __tstate = wxPyBeginAllowThreads();
44091 result = (int)((wxControl const *)arg1)->GetAlignment();
44092 wxPyEndAllowThreads(__tstate);
44093 if (PyErr_Occurred()) SWIG_fail;
44094 }
44095 resultobj = SWIG_From_int(static_cast< int >(result));
44096 return resultobj;
44097 fail:
44098 return NULL;
44099 }
44100
44101
44102 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44103 PyObject *resultobj = 0;
44104 wxControl *arg1 = (wxControl *) 0 ;
44105 wxString result;
44106 void *argp1 = 0 ;
44107 int res1 = 0 ;
44108 PyObject *swig_obj[1] ;
44109
44110 if (!args) SWIG_fail;
44111 swig_obj[0] = args;
44112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44113 if (!SWIG_IsOK(res1)) {
44114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44115 }
44116 arg1 = reinterpret_cast< wxControl * >(argp1);
44117 {
44118 PyThreadState* __tstate = wxPyBeginAllowThreads();
44119 result = ((wxControl const *)arg1)->GetLabelText();
44120 wxPyEndAllowThreads(__tstate);
44121 if (PyErr_Occurred()) SWIG_fail;
44122 }
44123 {
44124 #if wxUSE_UNICODE
44125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44126 #else
44127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44128 #endif
44129 }
44130 return resultobj;
44131 fail:
44132 return NULL;
44133 }
44134
44135
44136 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44137 PyObject *resultobj = 0;
44138 wxControl *arg1 = (wxControl *) 0 ;
44139 wxCommandEvent *arg2 = 0 ;
44140 void *argp1 = 0 ;
44141 int res1 = 0 ;
44142 void *argp2 = 0 ;
44143 int res2 = 0 ;
44144 PyObject * obj0 = 0 ;
44145 PyObject * obj1 = 0 ;
44146 char * kwnames[] = {
44147 (char *) "self",(char *) "event", NULL
44148 };
44149
44150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44152 if (!SWIG_IsOK(res1)) {
44153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44154 }
44155 arg1 = reinterpret_cast< wxControl * >(argp1);
44156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44157 if (!SWIG_IsOK(res2)) {
44158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44159 }
44160 if (!argp2) {
44161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44162 }
44163 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44164 {
44165 PyThreadState* __tstate = wxPyBeginAllowThreads();
44166 (arg1)->Command(*arg2);
44167 wxPyEndAllowThreads(__tstate);
44168 if (PyErr_Occurred()) SWIG_fail;
44169 }
44170 resultobj = SWIG_Py_Void();
44171 return resultobj;
44172 fail:
44173 return NULL;
44174 }
44175
44176
44177 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44178 PyObject *resultobj = 0;
44179 wxControl *arg1 = (wxControl *) 0 ;
44180 wxString result;
44181 void *argp1 = 0 ;
44182 int res1 = 0 ;
44183 PyObject *swig_obj[1] ;
44184
44185 if (!args) SWIG_fail;
44186 swig_obj[0] = args;
44187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44188 if (!SWIG_IsOK(res1)) {
44189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44190 }
44191 arg1 = reinterpret_cast< wxControl * >(argp1);
44192 {
44193 PyThreadState* __tstate = wxPyBeginAllowThreads();
44194 result = (arg1)->GetLabel();
44195 wxPyEndAllowThreads(__tstate);
44196 if (PyErr_Occurred()) SWIG_fail;
44197 }
44198 {
44199 #if wxUSE_UNICODE
44200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44201 #else
44202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44203 #endif
44204 }
44205 return resultobj;
44206 fail:
44207 return NULL;
44208 }
44209
44210
44211 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44212 PyObject *resultobj = 0;
44213 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44214 SwigValueWrapper<wxVisualAttributes > result;
44215 int val1 ;
44216 int ecode1 = 0 ;
44217 PyObject * obj0 = 0 ;
44218 char * kwnames[] = {
44219 (char *) "variant", NULL
44220 };
44221
44222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44223 if (obj0) {
44224 ecode1 = SWIG_AsVal_int(obj0, &val1);
44225 if (!SWIG_IsOK(ecode1)) {
44226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44227 }
44228 arg1 = static_cast< wxWindowVariant >(val1);
44229 }
44230 {
44231 if (!wxPyCheckForApp()) SWIG_fail;
44232 PyThreadState* __tstate = wxPyBeginAllowThreads();
44233 result = wxControl::GetClassDefaultAttributes(arg1);
44234 wxPyEndAllowThreads(__tstate);
44235 if (PyErr_Occurred()) SWIG_fail;
44236 }
44237 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44238 return resultobj;
44239 fail:
44240 return NULL;
44241 }
44242
44243
44244 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44245 PyObject *obj;
44246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44247 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44248 return SWIG_Py_Void();
44249 }
44250
44251 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44252 return SWIG_Python_InitShadowInstance(args);
44253 }
44254
44255 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44256 PyObject *resultobj = 0;
44257 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44258 wxString *arg2 = 0 ;
44259 PyObject *arg3 = (PyObject *) NULL ;
44260 int result;
44261 void *argp1 = 0 ;
44262 int res1 = 0 ;
44263 bool temp2 = false ;
44264 PyObject * obj0 = 0 ;
44265 PyObject * obj1 = 0 ;
44266 PyObject * obj2 = 0 ;
44267 char * kwnames[] = {
44268 (char *) "self",(char *) "item",(char *) "clientData", NULL
44269 };
44270
44271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44273 if (!SWIG_IsOK(res1)) {
44274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44275 }
44276 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44277 {
44278 arg2 = wxString_in_helper(obj1);
44279 if (arg2 == NULL) SWIG_fail;
44280 temp2 = true;
44281 }
44282 if (obj2) {
44283 arg3 = obj2;
44284 }
44285 {
44286 PyThreadState* __tstate = wxPyBeginAllowThreads();
44287 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44288 wxPyEndAllowThreads(__tstate);
44289 if (PyErr_Occurred()) SWIG_fail;
44290 }
44291 resultobj = SWIG_From_int(static_cast< int >(result));
44292 {
44293 if (temp2)
44294 delete arg2;
44295 }
44296 return resultobj;
44297 fail:
44298 {
44299 if (temp2)
44300 delete arg2;
44301 }
44302 return NULL;
44303 }
44304
44305
44306 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44307 PyObject *resultobj = 0;
44308 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44309 wxArrayString *arg2 = 0 ;
44310 void *argp1 = 0 ;
44311 int res1 = 0 ;
44312 bool temp2 = false ;
44313 PyObject * obj0 = 0 ;
44314 PyObject * obj1 = 0 ;
44315 char * kwnames[] = {
44316 (char *) "self",(char *) "strings", NULL
44317 };
44318
44319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44321 if (!SWIG_IsOK(res1)) {
44322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44323 }
44324 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44325 {
44326 if (! PySequence_Check(obj1)) {
44327 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44328 SWIG_fail;
44329 }
44330 arg2 = new wxArrayString;
44331 temp2 = true;
44332 int i, len=PySequence_Length(obj1);
44333 for (i=0; i<len; i++) {
44334 PyObject* item = PySequence_GetItem(obj1, i);
44335 wxString* s = wxString_in_helper(item);
44336 if (PyErr_Occurred()) SWIG_fail;
44337 arg2->Add(*s);
44338 delete s;
44339 Py_DECREF(item);
44340 }
44341 }
44342 {
44343 PyThreadState* __tstate = wxPyBeginAllowThreads();
44344 (arg1)->Append((wxArrayString const &)*arg2);
44345 wxPyEndAllowThreads(__tstate);
44346 if (PyErr_Occurred()) SWIG_fail;
44347 }
44348 resultobj = SWIG_Py_Void();
44349 {
44350 if (temp2) delete arg2;
44351 }
44352 return resultobj;
44353 fail:
44354 {
44355 if (temp2) delete arg2;
44356 }
44357 return NULL;
44358 }
44359
44360
44361 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44362 PyObject *resultobj = 0;
44363 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44364 wxString *arg2 = 0 ;
44365 unsigned int arg3 ;
44366 PyObject *arg4 = (PyObject *) NULL ;
44367 int result;
44368 void *argp1 = 0 ;
44369 int res1 = 0 ;
44370 bool temp2 = false ;
44371 unsigned int val3 ;
44372 int ecode3 = 0 ;
44373 PyObject * obj0 = 0 ;
44374 PyObject * obj1 = 0 ;
44375 PyObject * obj2 = 0 ;
44376 PyObject * obj3 = 0 ;
44377 char * kwnames[] = {
44378 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44379 };
44380
44381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44383 if (!SWIG_IsOK(res1)) {
44384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44385 }
44386 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44387 {
44388 arg2 = wxString_in_helper(obj1);
44389 if (arg2 == NULL) SWIG_fail;
44390 temp2 = true;
44391 }
44392 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44393 if (!SWIG_IsOK(ecode3)) {
44394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44395 }
44396 arg3 = static_cast< unsigned int >(val3);
44397 if (obj3) {
44398 arg4 = obj3;
44399 }
44400 {
44401 PyThreadState* __tstate = wxPyBeginAllowThreads();
44402 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44403 wxPyEndAllowThreads(__tstate);
44404 if (PyErr_Occurred()) SWIG_fail;
44405 }
44406 resultobj = SWIG_From_int(static_cast< int >(result));
44407 {
44408 if (temp2)
44409 delete arg2;
44410 }
44411 return resultobj;
44412 fail:
44413 {
44414 if (temp2)
44415 delete arg2;
44416 }
44417 return NULL;
44418 }
44419
44420
44421 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44422 PyObject *resultobj = 0;
44423 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44424 void *argp1 = 0 ;
44425 int res1 = 0 ;
44426 PyObject *swig_obj[1] ;
44427
44428 if (!args) SWIG_fail;
44429 swig_obj[0] = args;
44430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44431 if (!SWIG_IsOK(res1)) {
44432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44433 }
44434 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44435 {
44436 PyThreadState* __tstate = wxPyBeginAllowThreads();
44437 (arg1)->Clear();
44438 wxPyEndAllowThreads(__tstate);
44439 if (PyErr_Occurred()) SWIG_fail;
44440 }
44441 resultobj = SWIG_Py_Void();
44442 return resultobj;
44443 fail:
44444 return NULL;
44445 }
44446
44447
44448 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44449 PyObject *resultobj = 0;
44450 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44451 unsigned int arg2 ;
44452 void *argp1 = 0 ;
44453 int res1 = 0 ;
44454 unsigned int val2 ;
44455 int ecode2 = 0 ;
44456 PyObject * obj0 = 0 ;
44457 PyObject * obj1 = 0 ;
44458 char * kwnames[] = {
44459 (char *) "self",(char *) "n", NULL
44460 };
44461
44462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44464 if (!SWIG_IsOK(res1)) {
44465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44466 }
44467 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44468 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44469 if (!SWIG_IsOK(ecode2)) {
44470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44471 }
44472 arg2 = static_cast< unsigned int >(val2);
44473 {
44474 PyThreadState* __tstate = wxPyBeginAllowThreads();
44475 (arg1)->Delete(arg2);
44476 wxPyEndAllowThreads(__tstate);
44477 if (PyErr_Occurred()) SWIG_fail;
44478 }
44479 resultobj = SWIG_Py_Void();
44480 return resultobj;
44481 fail:
44482 return NULL;
44483 }
44484
44485
44486 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44487 PyObject *resultobj = 0;
44488 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44489 unsigned int arg2 ;
44490 PyObject *result = 0 ;
44491 void *argp1 = 0 ;
44492 int res1 = 0 ;
44493 unsigned int val2 ;
44494 int ecode2 = 0 ;
44495 PyObject * obj0 = 0 ;
44496 PyObject * obj1 = 0 ;
44497 char * kwnames[] = {
44498 (char *) "self",(char *) "n", NULL
44499 };
44500
44501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44503 if (!SWIG_IsOK(res1)) {
44504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44505 }
44506 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44507 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44508 if (!SWIG_IsOK(ecode2)) {
44509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44510 }
44511 arg2 = static_cast< unsigned int >(val2);
44512 {
44513 PyThreadState* __tstate = wxPyBeginAllowThreads();
44514 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44515 wxPyEndAllowThreads(__tstate);
44516 if (PyErr_Occurred()) SWIG_fail;
44517 }
44518 resultobj = result;
44519 return resultobj;
44520 fail:
44521 return NULL;
44522 }
44523
44524
44525 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44526 PyObject *resultobj = 0;
44527 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44528 unsigned int arg2 ;
44529 PyObject *arg3 = (PyObject *) 0 ;
44530 void *argp1 = 0 ;
44531 int res1 = 0 ;
44532 unsigned int val2 ;
44533 int ecode2 = 0 ;
44534 PyObject * obj0 = 0 ;
44535 PyObject * obj1 = 0 ;
44536 PyObject * obj2 = 0 ;
44537 char * kwnames[] = {
44538 (char *) "self",(char *) "n",(char *) "clientData", NULL
44539 };
44540
44541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44543 if (!SWIG_IsOK(res1)) {
44544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44545 }
44546 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44547 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44548 if (!SWIG_IsOK(ecode2)) {
44549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44550 }
44551 arg2 = static_cast< unsigned int >(val2);
44552 arg3 = obj2;
44553 {
44554 PyThreadState* __tstate = wxPyBeginAllowThreads();
44555 wxItemContainer_SetClientData(arg1,arg2,arg3);
44556 wxPyEndAllowThreads(__tstate);
44557 if (PyErr_Occurred()) SWIG_fail;
44558 }
44559 resultobj = SWIG_Py_Void();
44560 return resultobj;
44561 fail:
44562 return NULL;
44563 }
44564
44565
44566 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44567 PyObject *resultobj = 0;
44568 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44569 unsigned int result;
44570 void *argp1 = 0 ;
44571 int res1 = 0 ;
44572 PyObject *swig_obj[1] ;
44573
44574 if (!args) SWIG_fail;
44575 swig_obj[0] = args;
44576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44577 if (!SWIG_IsOK(res1)) {
44578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44579 }
44580 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44581 {
44582 PyThreadState* __tstate = wxPyBeginAllowThreads();
44583 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44584 wxPyEndAllowThreads(__tstate);
44585 if (PyErr_Occurred()) SWIG_fail;
44586 }
44587 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44588 return resultobj;
44589 fail:
44590 return NULL;
44591 }
44592
44593
44594 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44595 PyObject *resultobj = 0;
44596 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44597 bool result;
44598 void *argp1 = 0 ;
44599 int res1 = 0 ;
44600 PyObject *swig_obj[1] ;
44601
44602 if (!args) SWIG_fail;
44603 swig_obj[0] = args;
44604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44605 if (!SWIG_IsOK(res1)) {
44606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44607 }
44608 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44609 {
44610 PyThreadState* __tstate = wxPyBeginAllowThreads();
44611 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44612 wxPyEndAllowThreads(__tstate);
44613 if (PyErr_Occurred()) SWIG_fail;
44614 }
44615 {
44616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44617 }
44618 return resultobj;
44619 fail:
44620 return NULL;
44621 }
44622
44623
44624 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44625 PyObject *resultobj = 0;
44626 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44627 unsigned int arg2 ;
44628 wxString result;
44629 void *argp1 = 0 ;
44630 int res1 = 0 ;
44631 unsigned int val2 ;
44632 int ecode2 = 0 ;
44633 PyObject * obj0 = 0 ;
44634 PyObject * obj1 = 0 ;
44635 char * kwnames[] = {
44636 (char *) "self",(char *) "n", NULL
44637 };
44638
44639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44641 if (!SWIG_IsOK(res1)) {
44642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44643 }
44644 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44645 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44646 if (!SWIG_IsOK(ecode2)) {
44647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44648 }
44649 arg2 = static_cast< unsigned int >(val2);
44650 {
44651 PyThreadState* __tstate = wxPyBeginAllowThreads();
44652 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44653 wxPyEndAllowThreads(__tstate);
44654 if (PyErr_Occurred()) SWIG_fail;
44655 }
44656 {
44657 #if wxUSE_UNICODE
44658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44659 #else
44660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44661 #endif
44662 }
44663 return resultobj;
44664 fail:
44665 return NULL;
44666 }
44667
44668
44669 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44670 PyObject *resultobj = 0;
44671 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44672 wxArrayString result;
44673 void *argp1 = 0 ;
44674 int res1 = 0 ;
44675 PyObject *swig_obj[1] ;
44676
44677 if (!args) SWIG_fail;
44678 swig_obj[0] = args;
44679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44680 if (!SWIG_IsOK(res1)) {
44681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44682 }
44683 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44684 {
44685 PyThreadState* __tstate = wxPyBeginAllowThreads();
44686 result = ((wxItemContainer const *)arg1)->GetStrings();
44687 wxPyEndAllowThreads(__tstate);
44688 if (PyErr_Occurred()) SWIG_fail;
44689 }
44690 {
44691 resultobj = wxArrayString2PyList_helper(result);
44692 }
44693 return resultobj;
44694 fail:
44695 return NULL;
44696 }
44697
44698
44699 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44700 PyObject *resultobj = 0;
44701 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44702 unsigned int arg2 ;
44703 wxString *arg3 = 0 ;
44704 void *argp1 = 0 ;
44705 int res1 = 0 ;
44706 unsigned int val2 ;
44707 int ecode2 = 0 ;
44708 bool temp3 = false ;
44709 PyObject * obj0 = 0 ;
44710 PyObject * obj1 = 0 ;
44711 PyObject * obj2 = 0 ;
44712 char * kwnames[] = {
44713 (char *) "self",(char *) "n",(char *) "s", NULL
44714 };
44715
44716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44718 if (!SWIG_IsOK(res1)) {
44719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44720 }
44721 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44722 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44723 if (!SWIG_IsOK(ecode2)) {
44724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44725 }
44726 arg2 = static_cast< unsigned int >(val2);
44727 {
44728 arg3 = wxString_in_helper(obj2);
44729 if (arg3 == NULL) SWIG_fail;
44730 temp3 = true;
44731 }
44732 {
44733 PyThreadState* __tstate = wxPyBeginAllowThreads();
44734 (arg1)->SetString(arg2,(wxString const &)*arg3);
44735 wxPyEndAllowThreads(__tstate);
44736 if (PyErr_Occurred()) SWIG_fail;
44737 }
44738 resultobj = SWIG_Py_Void();
44739 {
44740 if (temp3)
44741 delete arg3;
44742 }
44743 return resultobj;
44744 fail:
44745 {
44746 if (temp3)
44747 delete arg3;
44748 }
44749 return NULL;
44750 }
44751
44752
44753 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44754 PyObject *resultobj = 0;
44755 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44756 wxString *arg2 = 0 ;
44757 int result;
44758 void *argp1 = 0 ;
44759 int res1 = 0 ;
44760 bool temp2 = false ;
44761 PyObject * obj0 = 0 ;
44762 PyObject * obj1 = 0 ;
44763 char * kwnames[] = {
44764 (char *) "self",(char *) "s", NULL
44765 };
44766
44767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44769 if (!SWIG_IsOK(res1)) {
44770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44771 }
44772 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44773 {
44774 arg2 = wxString_in_helper(obj1);
44775 if (arg2 == NULL) SWIG_fail;
44776 temp2 = true;
44777 }
44778 {
44779 PyThreadState* __tstate = wxPyBeginAllowThreads();
44780 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44781 wxPyEndAllowThreads(__tstate);
44782 if (PyErr_Occurred()) SWIG_fail;
44783 }
44784 resultobj = SWIG_From_int(static_cast< int >(result));
44785 {
44786 if (temp2)
44787 delete arg2;
44788 }
44789 return resultobj;
44790 fail:
44791 {
44792 if (temp2)
44793 delete arg2;
44794 }
44795 return NULL;
44796 }
44797
44798
44799 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44800 PyObject *resultobj = 0;
44801 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44802 int arg2 ;
44803 void *argp1 = 0 ;
44804 int res1 = 0 ;
44805 int val2 ;
44806 int ecode2 = 0 ;
44807 PyObject * obj0 = 0 ;
44808 PyObject * obj1 = 0 ;
44809 char * kwnames[] = {
44810 (char *) "self",(char *) "n", NULL
44811 };
44812
44813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44815 if (!SWIG_IsOK(res1)) {
44816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44817 }
44818 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44819 ecode2 = SWIG_AsVal_int(obj1, &val2);
44820 if (!SWIG_IsOK(ecode2)) {
44821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44822 }
44823 arg2 = static_cast< int >(val2);
44824 {
44825 PyThreadState* __tstate = wxPyBeginAllowThreads();
44826 (arg1)->SetSelection(arg2);
44827 wxPyEndAllowThreads(__tstate);
44828 if (PyErr_Occurred()) SWIG_fail;
44829 }
44830 resultobj = SWIG_Py_Void();
44831 return resultobj;
44832 fail:
44833 return NULL;
44834 }
44835
44836
44837 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44838 PyObject *resultobj = 0;
44839 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44840 int result;
44841 void *argp1 = 0 ;
44842 int res1 = 0 ;
44843 PyObject *swig_obj[1] ;
44844
44845 if (!args) SWIG_fail;
44846 swig_obj[0] = args;
44847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44848 if (!SWIG_IsOK(res1)) {
44849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44850 }
44851 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44852 {
44853 PyThreadState* __tstate = wxPyBeginAllowThreads();
44854 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44855 wxPyEndAllowThreads(__tstate);
44856 if (PyErr_Occurred()) SWIG_fail;
44857 }
44858 resultobj = SWIG_From_int(static_cast< int >(result));
44859 return resultobj;
44860 fail:
44861 return NULL;
44862 }
44863
44864
44865 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44866 PyObject *resultobj = 0;
44867 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44868 wxString *arg2 = 0 ;
44869 bool result;
44870 void *argp1 = 0 ;
44871 int res1 = 0 ;
44872 bool temp2 = false ;
44873 PyObject * obj0 = 0 ;
44874 PyObject * obj1 = 0 ;
44875 char * kwnames[] = {
44876 (char *) "self",(char *) "s", NULL
44877 };
44878
44879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44881 if (!SWIG_IsOK(res1)) {
44882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44883 }
44884 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44885 {
44886 arg2 = wxString_in_helper(obj1);
44887 if (arg2 == NULL) SWIG_fail;
44888 temp2 = true;
44889 }
44890 {
44891 PyThreadState* __tstate = wxPyBeginAllowThreads();
44892 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44893 wxPyEndAllowThreads(__tstate);
44894 if (PyErr_Occurred()) SWIG_fail;
44895 }
44896 {
44897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44898 }
44899 {
44900 if (temp2)
44901 delete arg2;
44902 }
44903 return resultobj;
44904 fail:
44905 {
44906 if (temp2)
44907 delete arg2;
44908 }
44909 return NULL;
44910 }
44911
44912
44913 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44914 PyObject *resultobj = 0;
44915 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44916 wxString result;
44917 void *argp1 = 0 ;
44918 int res1 = 0 ;
44919 PyObject *swig_obj[1] ;
44920
44921 if (!args) SWIG_fail;
44922 swig_obj[0] = args;
44923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44924 if (!SWIG_IsOK(res1)) {
44925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44926 }
44927 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44928 {
44929 PyThreadState* __tstate = wxPyBeginAllowThreads();
44930 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 {
44935 #if wxUSE_UNICODE
44936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44937 #else
44938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44939 #endif
44940 }
44941 return resultobj;
44942 fail:
44943 return NULL;
44944 }
44945
44946
44947 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44948 PyObject *resultobj = 0;
44949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44950 int arg2 ;
44951 void *argp1 = 0 ;
44952 int res1 = 0 ;
44953 int val2 ;
44954 int ecode2 = 0 ;
44955 PyObject * obj0 = 0 ;
44956 PyObject * obj1 = 0 ;
44957 char * kwnames[] = {
44958 (char *) "self",(char *) "n", NULL
44959 };
44960
44961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44963 if (!SWIG_IsOK(res1)) {
44964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44965 }
44966 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44967 ecode2 = SWIG_AsVal_int(obj1, &val2);
44968 if (!SWIG_IsOK(ecode2)) {
44969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44970 }
44971 arg2 = static_cast< int >(val2);
44972 {
44973 PyThreadState* __tstate = wxPyBeginAllowThreads();
44974 (arg1)->Select(arg2);
44975 wxPyEndAllowThreads(__tstate);
44976 if (PyErr_Occurred()) SWIG_fail;
44977 }
44978 resultobj = SWIG_Py_Void();
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44986 PyObject *obj;
44987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44988 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44989 return SWIG_Py_Void();
44990 }
44991
44992 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44993 PyObject *obj;
44994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44995 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44996 return SWIG_Py_Void();
44997 }
44998
44999 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45000 PyObject *resultobj = 0;
45001 wxSizerItem *result = 0 ;
45002
45003 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45004 {
45005 PyThreadState* __tstate = wxPyBeginAllowThreads();
45006 result = (wxSizerItem *)new wxSizerItem();
45007 wxPyEndAllowThreads(__tstate);
45008 if (PyErr_Occurred()) SWIG_fail;
45009 }
45010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45011 return resultobj;
45012 fail:
45013 return NULL;
45014 }
45015
45016
45017 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45018 PyObject *resultobj = 0;
45019 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45020 void *argp1 = 0 ;
45021 int res1 = 0 ;
45022 PyObject *swig_obj[1] ;
45023
45024 if (!args) SWIG_fail;
45025 swig_obj[0] = args;
45026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45027 if (!SWIG_IsOK(res1)) {
45028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45029 }
45030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45031 {
45032 PyThreadState* __tstate = wxPyBeginAllowThreads();
45033 delete arg1;
45034
45035 wxPyEndAllowThreads(__tstate);
45036 if (PyErr_Occurred()) SWIG_fail;
45037 }
45038 resultobj = SWIG_Py_Void();
45039 return resultobj;
45040 fail:
45041 return NULL;
45042 }
45043
45044
45045 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45046 PyObject *resultobj = 0;
45047 wxWindow *arg1 = (wxWindow *) 0 ;
45048 int arg2 ;
45049 int arg3 ;
45050 int arg4 ;
45051 PyObject *arg5 = (PyObject *) NULL ;
45052 wxSizerItem *result = 0 ;
45053 void *argp1 = 0 ;
45054 int res1 = 0 ;
45055 int val2 ;
45056 int ecode2 = 0 ;
45057 int val3 ;
45058 int ecode3 = 0 ;
45059 int val4 ;
45060 int ecode4 = 0 ;
45061 PyObject * obj0 = 0 ;
45062 PyObject * obj1 = 0 ;
45063 PyObject * obj2 = 0 ;
45064 PyObject * obj3 = 0 ;
45065 PyObject * obj4 = 0 ;
45066 char * kwnames[] = {
45067 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45068 };
45069
45070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45072 if (!SWIG_IsOK(res1)) {
45073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45074 }
45075 arg1 = reinterpret_cast< wxWindow * >(argp1);
45076 ecode2 = SWIG_AsVal_int(obj1, &val2);
45077 if (!SWIG_IsOK(ecode2)) {
45078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45079 }
45080 arg2 = static_cast< int >(val2);
45081 ecode3 = SWIG_AsVal_int(obj2, &val3);
45082 if (!SWIG_IsOK(ecode3)) {
45083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45084 }
45085 arg3 = static_cast< int >(val3);
45086 ecode4 = SWIG_AsVal_int(obj3, &val4);
45087 if (!SWIG_IsOK(ecode4)) {
45088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45089 }
45090 arg4 = static_cast< int >(val4);
45091 if (obj4) {
45092 arg5 = obj4;
45093 }
45094 {
45095 PyThreadState* __tstate = wxPyBeginAllowThreads();
45096 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45097 wxPyEndAllowThreads(__tstate);
45098 if (PyErr_Occurred()) SWIG_fail;
45099 }
45100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45101 return resultobj;
45102 fail:
45103 return NULL;
45104 }
45105
45106
45107 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45108 PyObject *resultobj = 0;
45109 int arg1 ;
45110 int arg2 ;
45111 int arg3 ;
45112 int arg4 ;
45113 int arg5 ;
45114 PyObject *arg6 = (PyObject *) NULL ;
45115 wxSizerItem *result = 0 ;
45116 int val1 ;
45117 int ecode1 = 0 ;
45118 int val2 ;
45119 int ecode2 = 0 ;
45120 int val3 ;
45121 int ecode3 = 0 ;
45122 int val4 ;
45123 int ecode4 = 0 ;
45124 int val5 ;
45125 int ecode5 = 0 ;
45126 PyObject * obj0 = 0 ;
45127 PyObject * obj1 = 0 ;
45128 PyObject * obj2 = 0 ;
45129 PyObject * obj3 = 0 ;
45130 PyObject * obj4 = 0 ;
45131 PyObject * obj5 = 0 ;
45132 char * kwnames[] = {
45133 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45134 };
45135
45136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45137 ecode1 = SWIG_AsVal_int(obj0, &val1);
45138 if (!SWIG_IsOK(ecode1)) {
45139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45140 }
45141 arg1 = static_cast< int >(val1);
45142 ecode2 = SWIG_AsVal_int(obj1, &val2);
45143 if (!SWIG_IsOK(ecode2)) {
45144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45145 }
45146 arg2 = static_cast< int >(val2);
45147 ecode3 = SWIG_AsVal_int(obj2, &val3);
45148 if (!SWIG_IsOK(ecode3)) {
45149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45150 }
45151 arg3 = static_cast< int >(val3);
45152 ecode4 = SWIG_AsVal_int(obj3, &val4);
45153 if (!SWIG_IsOK(ecode4)) {
45154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45155 }
45156 arg4 = static_cast< int >(val4);
45157 ecode5 = SWIG_AsVal_int(obj4, &val5);
45158 if (!SWIG_IsOK(ecode5)) {
45159 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45160 }
45161 arg5 = static_cast< int >(val5);
45162 if (obj5) {
45163 arg6 = obj5;
45164 }
45165 {
45166 PyThreadState* __tstate = wxPyBeginAllowThreads();
45167 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45168 wxPyEndAllowThreads(__tstate);
45169 if (PyErr_Occurred()) SWIG_fail;
45170 }
45171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45172 return resultobj;
45173 fail:
45174 return NULL;
45175 }
45176
45177
45178 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45179 PyObject *resultobj = 0;
45180 wxSizer *arg1 = (wxSizer *) 0 ;
45181 int arg2 ;
45182 int arg3 ;
45183 int arg4 ;
45184 PyObject *arg5 = (PyObject *) NULL ;
45185 wxSizerItem *result = 0 ;
45186 int res1 = 0 ;
45187 int val2 ;
45188 int ecode2 = 0 ;
45189 int val3 ;
45190 int ecode3 = 0 ;
45191 int val4 ;
45192 int ecode4 = 0 ;
45193 PyObject * obj0 = 0 ;
45194 PyObject * obj1 = 0 ;
45195 PyObject * obj2 = 0 ;
45196 PyObject * obj3 = 0 ;
45197 PyObject * obj4 = 0 ;
45198 char * kwnames[] = {
45199 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45200 };
45201
45202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45203 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45204 if (!SWIG_IsOK(res1)) {
45205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45206 }
45207 ecode2 = SWIG_AsVal_int(obj1, &val2);
45208 if (!SWIG_IsOK(ecode2)) {
45209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45210 }
45211 arg2 = static_cast< int >(val2);
45212 ecode3 = SWIG_AsVal_int(obj2, &val3);
45213 if (!SWIG_IsOK(ecode3)) {
45214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45215 }
45216 arg3 = static_cast< int >(val3);
45217 ecode4 = SWIG_AsVal_int(obj3, &val4);
45218 if (!SWIG_IsOK(ecode4)) {
45219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45220 }
45221 arg4 = static_cast< int >(val4);
45222 if (obj4) {
45223 arg5 = obj4;
45224 }
45225 {
45226 PyThreadState* __tstate = wxPyBeginAllowThreads();
45227 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45228 wxPyEndAllowThreads(__tstate);
45229 if (PyErr_Occurred()) SWIG_fail;
45230 }
45231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45232 return resultobj;
45233 fail:
45234 return NULL;
45235 }
45236
45237
45238 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45239 PyObject *resultobj = 0;
45240 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45241 void *argp1 = 0 ;
45242 int res1 = 0 ;
45243 PyObject *swig_obj[1] ;
45244
45245 if (!args) SWIG_fail;
45246 swig_obj[0] = args;
45247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45248 if (!SWIG_IsOK(res1)) {
45249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45250 }
45251 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45252 {
45253 PyThreadState* __tstate = wxPyBeginAllowThreads();
45254 (arg1)->DeleteWindows();
45255 wxPyEndAllowThreads(__tstate);
45256 if (PyErr_Occurred()) SWIG_fail;
45257 }
45258 resultobj = SWIG_Py_Void();
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45266 PyObject *resultobj = 0;
45267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45268 void *argp1 = 0 ;
45269 int res1 = 0 ;
45270 PyObject *swig_obj[1] ;
45271
45272 if (!args) SWIG_fail;
45273 swig_obj[0] = args;
45274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45275 if (!SWIG_IsOK(res1)) {
45276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45277 }
45278 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 (arg1)->DetachSizer();
45282 wxPyEndAllowThreads(__tstate);
45283 if (PyErr_Occurred()) SWIG_fail;
45284 }
45285 resultobj = SWIG_Py_Void();
45286 return resultobj;
45287 fail:
45288 return NULL;
45289 }
45290
45291
45292 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45293 PyObject *resultobj = 0;
45294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45295 wxSize result;
45296 void *argp1 = 0 ;
45297 int res1 = 0 ;
45298 PyObject *swig_obj[1] ;
45299
45300 if (!args) SWIG_fail;
45301 swig_obj[0] = args;
45302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45303 if (!SWIG_IsOK(res1)) {
45304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45305 }
45306 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45307 {
45308 PyThreadState* __tstate = wxPyBeginAllowThreads();
45309 result = (arg1)->GetSize();
45310 wxPyEndAllowThreads(__tstate);
45311 if (PyErr_Occurred()) SWIG_fail;
45312 }
45313 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45314 return resultobj;
45315 fail:
45316 return NULL;
45317 }
45318
45319
45320 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45321 PyObject *resultobj = 0;
45322 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45323 wxSize result;
45324 void *argp1 = 0 ;
45325 int res1 = 0 ;
45326 PyObject *swig_obj[1] ;
45327
45328 if (!args) SWIG_fail;
45329 swig_obj[0] = args;
45330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45331 if (!SWIG_IsOK(res1)) {
45332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45333 }
45334 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45335 {
45336 PyThreadState* __tstate = wxPyBeginAllowThreads();
45337 result = (arg1)->CalcMin();
45338 wxPyEndAllowThreads(__tstate);
45339 if (PyErr_Occurred()) SWIG_fail;
45340 }
45341 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45342 return resultobj;
45343 fail:
45344 return NULL;
45345 }
45346
45347
45348 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45349 PyObject *resultobj = 0;
45350 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45351 wxPoint *arg2 = 0 ;
45352 wxSize *arg3 = 0 ;
45353 void *argp1 = 0 ;
45354 int res1 = 0 ;
45355 wxPoint temp2 ;
45356 wxSize temp3 ;
45357 PyObject * obj0 = 0 ;
45358 PyObject * obj1 = 0 ;
45359 PyObject * obj2 = 0 ;
45360 char * kwnames[] = {
45361 (char *) "self",(char *) "pos",(char *) "size", NULL
45362 };
45363
45364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45366 if (!SWIG_IsOK(res1)) {
45367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45368 }
45369 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45370 {
45371 arg2 = &temp2;
45372 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45373 }
45374 {
45375 arg3 = &temp3;
45376 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45377 }
45378 {
45379 PyThreadState* __tstate = wxPyBeginAllowThreads();
45380 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45381 wxPyEndAllowThreads(__tstate);
45382 if (PyErr_Occurred()) SWIG_fail;
45383 }
45384 resultobj = SWIG_Py_Void();
45385 return resultobj;
45386 fail:
45387 return NULL;
45388 }
45389
45390
45391 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45392 PyObject *resultobj = 0;
45393 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45394 wxSize result;
45395 void *argp1 = 0 ;
45396 int res1 = 0 ;
45397 PyObject *swig_obj[1] ;
45398
45399 if (!args) SWIG_fail;
45400 swig_obj[0] = args;
45401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45402 if (!SWIG_IsOK(res1)) {
45403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45404 }
45405 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45406 {
45407 PyThreadState* __tstate = wxPyBeginAllowThreads();
45408 result = (arg1)->GetMinSize();
45409 wxPyEndAllowThreads(__tstate);
45410 if (PyErr_Occurred()) SWIG_fail;
45411 }
45412 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45413 return resultobj;
45414 fail:
45415 return NULL;
45416 }
45417
45418
45419 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45420 PyObject *resultobj = 0;
45421 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45422 wxSize result;
45423 void *argp1 = 0 ;
45424 int res1 = 0 ;
45425 PyObject *swig_obj[1] ;
45426
45427 if (!args) SWIG_fail;
45428 swig_obj[0] = args;
45429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45430 if (!SWIG_IsOK(res1)) {
45431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45432 }
45433 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45434 {
45435 PyThreadState* __tstate = wxPyBeginAllowThreads();
45436 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45437 wxPyEndAllowThreads(__tstate);
45438 if (PyErr_Occurred()) SWIG_fail;
45439 }
45440 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45441 return resultobj;
45442 fail:
45443 return NULL;
45444 }
45445
45446
45447 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45448 PyObject *resultobj = 0;
45449 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45450 int arg2 ;
45451 int arg3 ;
45452 void *argp1 = 0 ;
45453 int res1 = 0 ;
45454 int val2 ;
45455 int ecode2 = 0 ;
45456 int val3 ;
45457 int ecode3 = 0 ;
45458 PyObject * obj0 = 0 ;
45459 PyObject * obj1 = 0 ;
45460 PyObject * obj2 = 0 ;
45461 char * kwnames[] = {
45462 (char *) "self",(char *) "x",(char *) "y", NULL
45463 };
45464
45465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45467 if (!SWIG_IsOK(res1)) {
45468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45469 }
45470 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45471 ecode2 = SWIG_AsVal_int(obj1, &val2);
45472 if (!SWIG_IsOK(ecode2)) {
45473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45474 }
45475 arg2 = static_cast< int >(val2);
45476 ecode3 = SWIG_AsVal_int(obj2, &val3);
45477 if (!SWIG_IsOK(ecode3)) {
45478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45479 }
45480 arg3 = static_cast< int >(val3);
45481 {
45482 PyThreadState* __tstate = wxPyBeginAllowThreads();
45483 (arg1)->SetInitSize(arg2,arg3);
45484 wxPyEndAllowThreads(__tstate);
45485 if (PyErr_Occurred()) SWIG_fail;
45486 }
45487 resultobj = SWIG_Py_Void();
45488 return resultobj;
45489 fail:
45490 return NULL;
45491 }
45492
45493
45494 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45495 PyObject *resultobj = 0;
45496 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45497 int arg2 ;
45498 int arg3 ;
45499 void *argp1 = 0 ;
45500 int res1 = 0 ;
45501 int val2 ;
45502 int ecode2 = 0 ;
45503 int val3 ;
45504 int ecode3 = 0 ;
45505 PyObject * obj0 = 0 ;
45506 PyObject * obj1 = 0 ;
45507 PyObject * obj2 = 0 ;
45508 char * kwnames[] = {
45509 (char *) "self",(char *) "width",(char *) "height", NULL
45510 };
45511
45512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45516 }
45517 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45518 ecode2 = SWIG_AsVal_int(obj1, &val2);
45519 if (!SWIG_IsOK(ecode2)) {
45520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45521 }
45522 arg2 = static_cast< int >(val2);
45523 ecode3 = SWIG_AsVal_int(obj2, &val3);
45524 if (!SWIG_IsOK(ecode3)) {
45525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45526 }
45527 arg3 = static_cast< int >(val3);
45528 {
45529 PyThreadState* __tstate = wxPyBeginAllowThreads();
45530 (arg1)->SetRatio(arg2,arg3);
45531 wxPyEndAllowThreads(__tstate);
45532 if (PyErr_Occurred()) SWIG_fail;
45533 }
45534 resultobj = SWIG_Py_Void();
45535 return resultobj;
45536 fail:
45537 return NULL;
45538 }
45539
45540
45541 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45542 PyObject *resultobj = 0;
45543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45544 wxSize *arg2 = 0 ;
45545 void *argp1 = 0 ;
45546 int res1 = 0 ;
45547 wxSize temp2 ;
45548 PyObject * obj0 = 0 ;
45549 PyObject * obj1 = 0 ;
45550 char * kwnames[] = {
45551 (char *) "self",(char *) "size", NULL
45552 };
45553
45554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45556 if (!SWIG_IsOK(res1)) {
45557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45558 }
45559 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45560 {
45561 arg2 = &temp2;
45562 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45563 }
45564 {
45565 PyThreadState* __tstate = wxPyBeginAllowThreads();
45566 (arg1)->SetRatio((wxSize const &)*arg2);
45567 wxPyEndAllowThreads(__tstate);
45568 if (PyErr_Occurred()) SWIG_fail;
45569 }
45570 resultobj = SWIG_Py_Void();
45571 return resultobj;
45572 fail:
45573 return NULL;
45574 }
45575
45576
45577 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45578 PyObject *resultobj = 0;
45579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45580 float arg2 ;
45581 void *argp1 = 0 ;
45582 int res1 = 0 ;
45583 float val2 ;
45584 int ecode2 = 0 ;
45585 PyObject * obj0 = 0 ;
45586 PyObject * obj1 = 0 ;
45587 char * kwnames[] = {
45588 (char *) "self",(char *) "ratio", NULL
45589 };
45590
45591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45593 if (!SWIG_IsOK(res1)) {
45594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45595 }
45596 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45597 ecode2 = SWIG_AsVal_float(obj1, &val2);
45598 if (!SWIG_IsOK(ecode2)) {
45599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45600 }
45601 arg2 = static_cast< float >(val2);
45602 {
45603 PyThreadState* __tstate = wxPyBeginAllowThreads();
45604 (arg1)->SetRatio(arg2);
45605 wxPyEndAllowThreads(__tstate);
45606 if (PyErr_Occurred()) SWIG_fail;
45607 }
45608 resultobj = SWIG_Py_Void();
45609 return resultobj;
45610 fail:
45611 return NULL;
45612 }
45613
45614
45615 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45616 PyObject *resultobj = 0;
45617 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45618 float result;
45619 void *argp1 = 0 ;
45620 int res1 = 0 ;
45621 PyObject *swig_obj[1] ;
45622
45623 if (!args) SWIG_fail;
45624 swig_obj[0] = args;
45625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45626 if (!SWIG_IsOK(res1)) {
45627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45628 }
45629 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45630 {
45631 PyThreadState* __tstate = wxPyBeginAllowThreads();
45632 result = (float)(arg1)->GetRatio();
45633 wxPyEndAllowThreads(__tstate);
45634 if (PyErr_Occurred()) SWIG_fail;
45635 }
45636 resultobj = SWIG_From_float(static_cast< float >(result));
45637 return resultobj;
45638 fail:
45639 return NULL;
45640 }
45641
45642
45643 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45644 PyObject *resultobj = 0;
45645 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45646 wxRect result;
45647 void *argp1 = 0 ;
45648 int res1 = 0 ;
45649 PyObject *swig_obj[1] ;
45650
45651 if (!args) SWIG_fail;
45652 swig_obj[0] = args;
45653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45654 if (!SWIG_IsOK(res1)) {
45655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45656 }
45657 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45658 {
45659 PyThreadState* __tstate = wxPyBeginAllowThreads();
45660 result = (arg1)->GetRect();
45661 wxPyEndAllowThreads(__tstate);
45662 if (PyErr_Occurred()) SWIG_fail;
45663 }
45664 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45665 return resultobj;
45666 fail:
45667 return NULL;
45668 }
45669
45670
45671 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45672 PyObject *resultobj = 0;
45673 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45674 bool result;
45675 void *argp1 = 0 ;
45676 int res1 = 0 ;
45677 PyObject *swig_obj[1] ;
45678
45679 if (!args) SWIG_fail;
45680 swig_obj[0] = args;
45681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45682 if (!SWIG_IsOK(res1)) {
45683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45684 }
45685 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45686 {
45687 PyThreadState* __tstate = wxPyBeginAllowThreads();
45688 result = (bool)(arg1)->IsWindow();
45689 wxPyEndAllowThreads(__tstate);
45690 if (PyErr_Occurred()) SWIG_fail;
45691 }
45692 {
45693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45694 }
45695 return resultobj;
45696 fail:
45697 return NULL;
45698 }
45699
45700
45701 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45702 PyObject *resultobj = 0;
45703 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45704 bool result;
45705 void *argp1 = 0 ;
45706 int res1 = 0 ;
45707 PyObject *swig_obj[1] ;
45708
45709 if (!args) SWIG_fail;
45710 swig_obj[0] = args;
45711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45712 if (!SWIG_IsOK(res1)) {
45713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45714 }
45715 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45716 {
45717 PyThreadState* __tstate = wxPyBeginAllowThreads();
45718 result = (bool)(arg1)->IsSizer();
45719 wxPyEndAllowThreads(__tstate);
45720 if (PyErr_Occurred()) SWIG_fail;
45721 }
45722 {
45723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45724 }
45725 return resultobj;
45726 fail:
45727 return NULL;
45728 }
45729
45730
45731 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45732 PyObject *resultobj = 0;
45733 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45734 bool result;
45735 void *argp1 = 0 ;
45736 int res1 = 0 ;
45737 PyObject *swig_obj[1] ;
45738
45739 if (!args) SWIG_fail;
45740 swig_obj[0] = args;
45741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45742 if (!SWIG_IsOK(res1)) {
45743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45744 }
45745 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45746 {
45747 PyThreadState* __tstate = wxPyBeginAllowThreads();
45748 result = (bool)(arg1)->IsSpacer();
45749 wxPyEndAllowThreads(__tstate);
45750 if (PyErr_Occurred()) SWIG_fail;
45751 }
45752 {
45753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45754 }
45755 return resultobj;
45756 fail:
45757 return NULL;
45758 }
45759
45760
45761 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45762 PyObject *resultobj = 0;
45763 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45764 int arg2 ;
45765 void *argp1 = 0 ;
45766 int res1 = 0 ;
45767 int val2 ;
45768 int ecode2 = 0 ;
45769 PyObject * obj0 = 0 ;
45770 PyObject * obj1 = 0 ;
45771 char * kwnames[] = {
45772 (char *) "self",(char *) "proportion", NULL
45773 };
45774
45775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45777 if (!SWIG_IsOK(res1)) {
45778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45779 }
45780 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45781 ecode2 = SWIG_AsVal_int(obj1, &val2);
45782 if (!SWIG_IsOK(ecode2)) {
45783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45784 }
45785 arg2 = static_cast< int >(val2);
45786 {
45787 PyThreadState* __tstate = wxPyBeginAllowThreads();
45788 (arg1)->SetProportion(arg2);
45789 wxPyEndAllowThreads(__tstate);
45790 if (PyErr_Occurred()) SWIG_fail;
45791 }
45792 resultobj = SWIG_Py_Void();
45793 return resultobj;
45794 fail:
45795 return NULL;
45796 }
45797
45798
45799 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45800 PyObject *resultobj = 0;
45801 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45802 int result;
45803 void *argp1 = 0 ;
45804 int res1 = 0 ;
45805 PyObject *swig_obj[1] ;
45806
45807 if (!args) SWIG_fail;
45808 swig_obj[0] = args;
45809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45810 if (!SWIG_IsOK(res1)) {
45811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45812 }
45813 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45814 {
45815 PyThreadState* __tstate = wxPyBeginAllowThreads();
45816 result = (int)(arg1)->GetProportion();
45817 wxPyEndAllowThreads(__tstate);
45818 if (PyErr_Occurred()) SWIG_fail;
45819 }
45820 resultobj = SWIG_From_int(static_cast< int >(result));
45821 return resultobj;
45822 fail:
45823 return NULL;
45824 }
45825
45826
45827 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45828 PyObject *resultobj = 0;
45829 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45830 int arg2 ;
45831 void *argp1 = 0 ;
45832 int res1 = 0 ;
45833 int val2 ;
45834 int ecode2 = 0 ;
45835 PyObject * obj0 = 0 ;
45836 PyObject * obj1 = 0 ;
45837 char * kwnames[] = {
45838 (char *) "self",(char *) "flag", NULL
45839 };
45840
45841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45843 if (!SWIG_IsOK(res1)) {
45844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45845 }
45846 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45847 ecode2 = SWIG_AsVal_int(obj1, &val2);
45848 if (!SWIG_IsOK(ecode2)) {
45849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45850 }
45851 arg2 = static_cast< int >(val2);
45852 {
45853 PyThreadState* __tstate = wxPyBeginAllowThreads();
45854 (arg1)->SetFlag(arg2);
45855 wxPyEndAllowThreads(__tstate);
45856 if (PyErr_Occurred()) SWIG_fail;
45857 }
45858 resultobj = SWIG_Py_Void();
45859 return resultobj;
45860 fail:
45861 return NULL;
45862 }
45863
45864
45865 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45866 PyObject *resultobj = 0;
45867 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45868 int result;
45869 void *argp1 = 0 ;
45870 int res1 = 0 ;
45871 PyObject *swig_obj[1] ;
45872
45873 if (!args) SWIG_fail;
45874 swig_obj[0] = args;
45875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45876 if (!SWIG_IsOK(res1)) {
45877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45878 }
45879 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45880 {
45881 PyThreadState* __tstate = wxPyBeginAllowThreads();
45882 result = (int)(arg1)->GetFlag();
45883 wxPyEndAllowThreads(__tstate);
45884 if (PyErr_Occurred()) SWIG_fail;
45885 }
45886 resultobj = SWIG_From_int(static_cast< int >(result));
45887 return resultobj;
45888 fail:
45889 return NULL;
45890 }
45891
45892
45893 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45894 PyObject *resultobj = 0;
45895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45896 int arg2 ;
45897 void *argp1 = 0 ;
45898 int res1 = 0 ;
45899 int val2 ;
45900 int ecode2 = 0 ;
45901 PyObject * obj0 = 0 ;
45902 PyObject * obj1 = 0 ;
45903 char * kwnames[] = {
45904 (char *) "self",(char *) "border", NULL
45905 };
45906
45907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45909 if (!SWIG_IsOK(res1)) {
45910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45911 }
45912 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45913 ecode2 = SWIG_AsVal_int(obj1, &val2);
45914 if (!SWIG_IsOK(ecode2)) {
45915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45916 }
45917 arg2 = static_cast< int >(val2);
45918 {
45919 PyThreadState* __tstate = wxPyBeginAllowThreads();
45920 (arg1)->SetBorder(arg2);
45921 wxPyEndAllowThreads(__tstate);
45922 if (PyErr_Occurred()) SWIG_fail;
45923 }
45924 resultobj = SWIG_Py_Void();
45925 return resultobj;
45926 fail:
45927 return NULL;
45928 }
45929
45930
45931 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45932 PyObject *resultobj = 0;
45933 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45934 int result;
45935 void *argp1 = 0 ;
45936 int res1 = 0 ;
45937 PyObject *swig_obj[1] ;
45938
45939 if (!args) SWIG_fail;
45940 swig_obj[0] = args;
45941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45942 if (!SWIG_IsOK(res1)) {
45943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45944 }
45945 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45946 {
45947 PyThreadState* __tstate = wxPyBeginAllowThreads();
45948 result = (int)(arg1)->GetBorder();
45949 wxPyEndAllowThreads(__tstate);
45950 if (PyErr_Occurred()) SWIG_fail;
45951 }
45952 resultobj = SWIG_From_int(static_cast< int >(result));
45953 return resultobj;
45954 fail:
45955 return NULL;
45956 }
45957
45958
45959 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45960 PyObject *resultobj = 0;
45961 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45962 wxWindow *result = 0 ;
45963 void *argp1 = 0 ;
45964 int res1 = 0 ;
45965 PyObject *swig_obj[1] ;
45966
45967 if (!args) SWIG_fail;
45968 swig_obj[0] = args;
45969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45970 if (!SWIG_IsOK(res1)) {
45971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45972 }
45973 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45974 {
45975 PyThreadState* __tstate = wxPyBeginAllowThreads();
45976 result = (wxWindow *)(arg1)->GetWindow();
45977 wxPyEndAllowThreads(__tstate);
45978 if (PyErr_Occurred()) SWIG_fail;
45979 }
45980 {
45981 resultobj = wxPyMake_wxObject(result, 0);
45982 }
45983 return resultobj;
45984 fail:
45985 return NULL;
45986 }
45987
45988
45989 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45990 PyObject *resultobj = 0;
45991 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45992 wxWindow *arg2 = (wxWindow *) 0 ;
45993 void *argp1 = 0 ;
45994 int res1 = 0 ;
45995 void *argp2 = 0 ;
45996 int res2 = 0 ;
45997 PyObject * obj0 = 0 ;
45998 PyObject * obj1 = 0 ;
45999 char * kwnames[] = {
46000 (char *) "self",(char *) "window", NULL
46001 };
46002
46003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46005 if (!SWIG_IsOK(res1)) {
46006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46007 }
46008 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46009 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46010 if (!SWIG_IsOK(res2)) {
46011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46012 }
46013 arg2 = reinterpret_cast< wxWindow * >(argp2);
46014 {
46015 PyThreadState* __tstate = wxPyBeginAllowThreads();
46016 (arg1)->SetWindow(arg2);
46017 wxPyEndAllowThreads(__tstate);
46018 if (PyErr_Occurred()) SWIG_fail;
46019 }
46020 resultobj = SWIG_Py_Void();
46021 return resultobj;
46022 fail:
46023 return NULL;
46024 }
46025
46026
46027 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46028 PyObject *resultobj = 0;
46029 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46030 wxSizer *result = 0 ;
46031 void *argp1 = 0 ;
46032 int res1 = 0 ;
46033 PyObject *swig_obj[1] ;
46034
46035 if (!args) SWIG_fail;
46036 swig_obj[0] = args;
46037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46038 if (!SWIG_IsOK(res1)) {
46039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46040 }
46041 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46042 {
46043 PyThreadState* __tstate = wxPyBeginAllowThreads();
46044 result = (wxSizer *)(arg1)->GetSizer();
46045 wxPyEndAllowThreads(__tstate);
46046 if (PyErr_Occurred()) SWIG_fail;
46047 }
46048 {
46049 resultobj = wxPyMake_wxObject(result, (bool)0);
46050 }
46051 return resultobj;
46052 fail:
46053 return NULL;
46054 }
46055
46056
46057 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46058 PyObject *resultobj = 0;
46059 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46060 wxSizer *arg2 = (wxSizer *) 0 ;
46061 void *argp1 = 0 ;
46062 int res1 = 0 ;
46063 int res2 = 0 ;
46064 PyObject * obj0 = 0 ;
46065 PyObject * obj1 = 0 ;
46066 char * kwnames[] = {
46067 (char *) "self",(char *) "sizer", NULL
46068 };
46069
46070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46072 if (!SWIG_IsOK(res1)) {
46073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46074 }
46075 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46076 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46077 if (!SWIG_IsOK(res2)) {
46078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46079 }
46080 {
46081 PyThreadState* __tstate = wxPyBeginAllowThreads();
46082 (arg1)->SetSizer(arg2);
46083 wxPyEndAllowThreads(__tstate);
46084 if (PyErr_Occurred()) SWIG_fail;
46085 }
46086 resultobj = SWIG_Py_Void();
46087 return resultobj;
46088 fail:
46089 return NULL;
46090 }
46091
46092
46093 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46094 PyObject *resultobj = 0;
46095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46096 wxSize *result = 0 ;
46097 void *argp1 = 0 ;
46098 int res1 = 0 ;
46099 PyObject *swig_obj[1] ;
46100
46101 if (!args) SWIG_fail;
46102 swig_obj[0] = args;
46103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46104 if (!SWIG_IsOK(res1)) {
46105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46106 }
46107 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46108 {
46109 PyThreadState* __tstate = wxPyBeginAllowThreads();
46110 {
46111 wxSize const &_result_ref = (arg1)->GetSpacer();
46112 result = (wxSize *) &_result_ref;
46113 }
46114 wxPyEndAllowThreads(__tstate);
46115 if (PyErr_Occurred()) SWIG_fail;
46116 }
46117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46118 return resultobj;
46119 fail:
46120 return NULL;
46121 }
46122
46123
46124 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46125 PyObject *resultobj = 0;
46126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46127 wxSize *arg2 = 0 ;
46128 void *argp1 = 0 ;
46129 int res1 = 0 ;
46130 wxSize temp2 ;
46131 PyObject * obj0 = 0 ;
46132 PyObject * obj1 = 0 ;
46133 char * kwnames[] = {
46134 (char *) "self",(char *) "size", NULL
46135 };
46136
46137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46139 if (!SWIG_IsOK(res1)) {
46140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46141 }
46142 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46143 {
46144 arg2 = &temp2;
46145 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46146 }
46147 {
46148 PyThreadState* __tstate = wxPyBeginAllowThreads();
46149 (arg1)->SetSpacer((wxSize const &)*arg2);
46150 wxPyEndAllowThreads(__tstate);
46151 if (PyErr_Occurred()) SWIG_fail;
46152 }
46153 resultobj = SWIG_Py_Void();
46154 return resultobj;
46155 fail:
46156 return NULL;
46157 }
46158
46159
46160 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46161 PyObject *resultobj = 0;
46162 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46163 bool arg2 ;
46164 void *argp1 = 0 ;
46165 int res1 = 0 ;
46166 bool val2 ;
46167 int ecode2 = 0 ;
46168 PyObject * obj0 = 0 ;
46169 PyObject * obj1 = 0 ;
46170 char * kwnames[] = {
46171 (char *) "self",(char *) "show", NULL
46172 };
46173
46174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46176 if (!SWIG_IsOK(res1)) {
46177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46178 }
46179 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46181 if (!SWIG_IsOK(ecode2)) {
46182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46183 }
46184 arg2 = static_cast< bool >(val2);
46185 {
46186 PyThreadState* __tstate = wxPyBeginAllowThreads();
46187 (arg1)->Show(arg2);
46188 wxPyEndAllowThreads(__tstate);
46189 if (PyErr_Occurred()) SWIG_fail;
46190 }
46191 resultobj = SWIG_Py_Void();
46192 return resultobj;
46193 fail:
46194 return NULL;
46195 }
46196
46197
46198 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46199 PyObject *resultobj = 0;
46200 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46201 bool result;
46202 void *argp1 = 0 ;
46203 int res1 = 0 ;
46204 PyObject *swig_obj[1] ;
46205
46206 if (!args) SWIG_fail;
46207 swig_obj[0] = args;
46208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46209 if (!SWIG_IsOK(res1)) {
46210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46211 }
46212 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46213 {
46214 PyThreadState* __tstate = wxPyBeginAllowThreads();
46215 result = (bool)(arg1)->IsShown();
46216 wxPyEndAllowThreads(__tstate);
46217 if (PyErr_Occurred()) SWIG_fail;
46218 }
46219 {
46220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46221 }
46222 return resultobj;
46223 fail:
46224 return NULL;
46225 }
46226
46227
46228 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46229 PyObject *resultobj = 0;
46230 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46231 wxPoint result;
46232 void *argp1 = 0 ;
46233 int res1 = 0 ;
46234 PyObject *swig_obj[1] ;
46235
46236 if (!args) SWIG_fail;
46237 swig_obj[0] = args;
46238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46239 if (!SWIG_IsOK(res1)) {
46240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46241 }
46242 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46243 {
46244 PyThreadState* __tstate = wxPyBeginAllowThreads();
46245 result = (arg1)->GetPosition();
46246 wxPyEndAllowThreads(__tstate);
46247 if (PyErr_Occurred()) SWIG_fail;
46248 }
46249 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46250 return resultobj;
46251 fail:
46252 return NULL;
46253 }
46254
46255
46256 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46257 PyObject *resultobj = 0;
46258 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46259 PyObject *result = 0 ;
46260 void *argp1 = 0 ;
46261 int res1 = 0 ;
46262 PyObject *swig_obj[1] ;
46263
46264 if (!args) SWIG_fail;
46265 swig_obj[0] = args;
46266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46267 if (!SWIG_IsOK(res1)) {
46268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46269 }
46270 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46271 {
46272 PyThreadState* __tstate = wxPyBeginAllowThreads();
46273 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46274 wxPyEndAllowThreads(__tstate);
46275 if (PyErr_Occurred()) SWIG_fail;
46276 }
46277 resultobj = result;
46278 return resultobj;
46279 fail:
46280 return NULL;
46281 }
46282
46283
46284 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46285 PyObject *resultobj = 0;
46286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46287 PyObject *arg2 = (PyObject *) 0 ;
46288 void *argp1 = 0 ;
46289 int res1 = 0 ;
46290 PyObject * obj0 = 0 ;
46291 PyObject * obj1 = 0 ;
46292 char * kwnames[] = {
46293 (char *) "self",(char *) "userData", NULL
46294 };
46295
46296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46298 if (!SWIG_IsOK(res1)) {
46299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46300 }
46301 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46302 arg2 = obj1;
46303 {
46304 PyThreadState* __tstate = wxPyBeginAllowThreads();
46305 wxSizerItem_SetUserData(arg1,arg2);
46306 wxPyEndAllowThreads(__tstate);
46307 if (PyErr_Occurred()) SWIG_fail;
46308 }
46309 resultobj = SWIG_Py_Void();
46310 return resultobj;
46311 fail:
46312 return NULL;
46313 }
46314
46315
46316 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46317 PyObject *obj;
46318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46319 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46320 return SWIG_Py_Void();
46321 }
46322
46323 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46324 return SWIG_Python_InitShadowInstance(args);
46325 }
46326
46327 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46328 PyObject *resultobj = 0;
46329 wxSizer *arg1 = (wxSizer *) 0 ;
46330 void *argp1 = 0 ;
46331 int res1 = 0 ;
46332 PyObject *swig_obj[1] ;
46333
46334 if (!args) SWIG_fail;
46335 swig_obj[0] = args;
46336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46337 if (!SWIG_IsOK(res1)) {
46338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46339 }
46340 arg1 = reinterpret_cast< wxSizer * >(argp1);
46341 {
46342 PyThreadState* __tstate = wxPyBeginAllowThreads();
46343 delete arg1;
46344
46345 wxPyEndAllowThreads(__tstate);
46346 if (PyErr_Occurred()) SWIG_fail;
46347 }
46348 resultobj = SWIG_Py_Void();
46349 return resultobj;
46350 fail:
46351 return NULL;
46352 }
46353
46354
46355 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46356 PyObject *resultobj = 0;
46357 wxSizer *arg1 = (wxSizer *) 0 ;
46358 PyObject *arg2 = (PyObject *) 0 ;
46359 void *argp1 = 0 ;
46360 int res1 = 0 ;
46361 PyObject * obj0 = 0 ;
46362 PyObject * obj1 = 0 ;
46363 char * kwnames[] = {
46364 (char *) "self",(char *) "_self", NULL
46365 };
46366
46367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46369 if (!SWIG_IsOK(res1)) {
46370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46371 }
46372 arg1 = reinterpret_cast< wxSizer * >(argp1);
46373 arg2 = obj1;
46374 {
46375 PyThreadState* __tstate = wxPyBeginAllowThreads();
46376 wxSizer__setOORInfo(arg1,arg2);
46377 wxPyEndAllowThreads(__tstate);
46378 if (PyErr_Occurred()) SWIG_fail;
46379 }
46380 resultobj = SWIG_Py_Void();
46381 return resultobj;
46382 fail:
46383 return NULL;
46384 }
46385
46386
46387 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46388 PyObject *resultobj = 0;
46389 wxSizer *arg1 = (wxSizer *) 0 ;
46390 PyObject *arg2 = (PyObject *) 0 ;
46391 int arg3 = (int) 0 ;
46392 int arg4 = (int) 0 ;
46393 int arg5 = (int) 0 ;
46394 PyObject *arg6 = (PyObject *) NULL ;
46395 wxSizerItem *result = 0 ;
46396 void *argp1 = 0 ;
46397 int res1 = 0 ;
46398 int val3 ;
46399 int ecode3 = 0 ;
46400 int val4 ;
46401 int ecode4 = 0 ;
46402 int val5 ;
46403 int ecode5 = 0 ;
46404 PyObject * obj0 = 0 ;
46405 PyObject * obj1 = 0 ;
46406 PyObject * obj2 = 0 ;
46407 PyObject * obj3 = 0 ;
46408 PyObject * obj4 = 0 ;
46409 PyObject * obj5 = 0 ;
46410 char * kwnames[] = {
46411 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46412 };
46413
46414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46416 if (!SWIG_IsOK(res1)) {
46417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46418 }
46419 arg1 = reinterpret_cast< wxSizer * >(argp1);
46420 arg2 = obj1;
46421 if (obj2) {
46422 ecode3 = SWIG_AsVal_int(obj2, &val3);
46423 if (!SWIG_IsOK(ecode3)) {
46424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46425 }
46426 arg3 = static_cast< int >(val3);
46427 }
46428 if (obj3) {
46429 ecode4 = SWIG_AsVal_int(obj3, &val4);
46430 if (!SWIG_IsOK(ecode4)) {
46431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46432 }
46433 arg4 = static_cast< int >(val4);
46434 }
46435 if (obj4) {
46436 ecode5 = SWIG_AsVal_int(obj4, &val5);
46437 if (!SWIG_IsOK(ecode5)) {
46438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46439 }
46440 arg5 = static_cast< int >(val5);
46441 }
46442 if (obj5) {
46443 arg6 = obj5;
46444 }
46445 {
46446 PyThreadState* __tstate = wxPyBeginAllowThreads();
46447 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46448 wxPyEndAllowThreads(__tstate);
46449 if (PyErr_Occurred()) SWIG_fail;
46450 }
46451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46452 return resultobj;
46453 fail:
46454 return NULL;
46455 }
46456
46457
46458 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46459 PyObject *resultobj = 0;
46460 wxSizer *arg1 = (wxSizer *) 0 ;
46461 int arg2 ;
46462 PyObject *arg3 = (PyObject *) 0 ;
46463 int arg4 = (int) 0 ;
46464 int arg5 = (int) 0 ;
46465 int arg6 = (int) 0 ;
46466 PyObject *arg7 = (PyObject *) NULL ;
46467 wxSizerItem *result = 0 ;
46468 void *argp1 = 0 ;
46469 int res1 = 0 ;
46470 int val2 ;
46471 int ecode2 = 0 ;
46472 int val4 ;
46473 int ecode4 = 0 ;
46474 int val5 ;
46475 int ecode5 = 0 ;
46476 int val6 ;
46477 int ecode6 = 0 ;
46478 PyObject * obj0 = 0 ;
46479 PyObject * obj1 = 0 ;
46480 PyObject * obj2 = 0 ;
46481 PyObject * obj3 = 0 ;
46482 PyObject * obj4 = 0 ;
46483 PyObject * obj5 = 0 ;
46484 PyObject * obj6 = 0 ;
46485 char * kwnames[] = {
46486 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46487 };
46488
46489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46491 if (!SWIG_IsOK(res1)) {
46492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46493 }
46494 arg1 = reinterpret_cast< wxSizer * >(argp1);
46495 ecode2 = SWIG_AsVal_int(obj1, &val2);
46496 if (!SWIG_IsOK(ecode2)) {
46497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46498 }
46499 arg2 = static_cast< int >(val2);
46500 arg3 = obj2;
46501 if (obj3) {
46502 ecode4 = SWIG_AsVal_int(obj3, &val4);
46503 if (!SWIG_IsOK(ecode4)) {
46504 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46505 }
46506 arg4 = static_cast< int >(val4);
46507 }
46508 if (obj4) {
46509 ecode5 = SWIG_AsVal_int(obj4, &val5);
46510 if (!SWIG_IsOK(ecode5)) {
46511 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46512 }
46513 arg5 = static_cast< int >(val5);
46514 }
46515 if (obj5) {
46516 ecode6 = SWIG_AsVal_int(obj5, &val6);
46517 if (!SWIG_IsOK(ecode6)) {
46518 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46519 }
46520 arg6 = static_cast< int >(val6);
46521 }
46522 if (obj6) {
46523 arg7 = obj6;
46524 }
46525 {
46526 PyThreadState* __tstate = wxPyBeginAllowThreads();
46527 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46528 wxPyEndAllowThreads(__tstate);
46529 if (PyErr_Occurred()) SWIG_fail;
46530 }
46531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46532 return resultobj;
46533 fail:
46534 return NULL;
46535 }
46536
46537
46538 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46539 PyObject *resultobj = 0;
46540 wxSizer *arg1 = (wxSizer *) 0 ;
46541 PyObject *arg2 = (PyObject *) 0 ;
46542 int arg3 = (int) 0 ;
46543 int arg4 = (int) 0 ;
46544 int arg5 = (int) 0 ;
46545 PyObject *arg6 = (PyObject *) NULL ;
46546 wxSizerItem *result = 0 ;
46547 void *argp1 = 0 ;
46548 int res1 = 0 ;
46549 int val3 ;
46550 int ecode3 = 0 ;
46551 int val4 ;
46552 int ecode4 = 0 ;
46553 int val5 ;
46554 int ecode5 = 0 ;
46555 PyObject * obj0 = 0 ;
46556 PyObject * obj1 = 0 ;
46557 PyObject * obj2 = 0 ;
46558 PyObject * obj3 = 0 ;
46559 PyObject * obj4 = 0 ;
46560 PyObject * obj5 = 0 ;
46561 char * kwnames[] = {
46562 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46563 };
46564
46565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46567 if (!SWIG_IsOK(res1)) {
46568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46569 }
46570 arg1 = reinterpret_cast< wxSizer * >(argp1);
46571 arg2 = obj1;
46572 if (obj2) {
46573 ecode3 = SWIG_AsVal_int(obj2, &val3);
46574 if (!SWIG_IsOK(ecode3)) {
46575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46576 }
46577 arg3 = static_cast< int >(val3);
46578 }
46579 if (obj3) {
46580 ecode4 = SWIG_AsVal_int(obj3, &val4);
46581 if (!SWIG_IsOK(ecode4)) {
46582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46583 }
46584 arg4 = static_cast< int >(val4);
46585 }
46586 if (obj4) {
46587 ecode5 = SWIG_AsVal_int(obj4, &val5);
46588 if (!SWIG_IsOK(ecode5)) {
46589 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46590 }
46591 arg5 = static_cast< int >(val5);
46592 }
46593 if (obj5) {
46594 arg6 = obj5;
46595 }
46596 {
46597 PyThreadState* __tstate = wxPyBeginAllowThreads();
46598 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46599 wxPyEndAllowThreads(__tstate);
46600 if (PyErr_Occurred()) SWIG_fail;
46601 }
46602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46603 return resultobj;
46604 fail:
46605 return NULL;
46606 }
46607
46608
46609 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46610 PyObject *resultobj = 0;
46611 wxSizer *arg1 = (wxSizer *) 0 ;
46612 PyObject *arg2 = (PyObject *) 0 ;
46613 bool result;
46614 void *argp1 = 0 ;
46615 int res1 = 0 ;
46616 PyObject * obj0 = 0 ;
46617 PyObject * obj1 = 0 ;
46618 char * kwnames[] = {
46619 (char *) "self",(char *) "item", NULL
46620 };
46621
46622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46624 if (!SWIG_IsOK(res1)) {
46625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46626 }
46627 arg1 = reinterpret_cast< wxSizer * >(argp1);
46628 arg2 = obj1;
46629 {
46630 PyThreadState* __tstate = wxPyBeginAllowThreads();
46631 result = (bool)wxSizer_Remove(arg1,arg2);
46632 wxPyEndAllowThreads(__tstate);
46633 if (PyErr_Occurred()) SWIG_fail;
46634 }
46635 {
46636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46637 }
46638 return resultobj;
46639 fail:
46640 return NULL;
46641 }
46642
46643
46644 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46645 PyObject *resultobj = 0;
46646 wxSizer *arg1 = (wxSizer *) 0 ;
46647 PyObject *arg2 = (PyObject *) 0 ;
46648 bool result;
46649 void *argp1 = 0 ;
46650 int res1 = 0 ;
46651 PyObject * obj0 = 0 ;
46652 PyObject * obj1 = 0 ;
46653 char * kwnames[] = {
46654 (char *) "self",(char *) "item", NULL
46655 };
46656
46657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46659 if (!SWIG_IsOK(res1)) {
46660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46661 }
46662 arg1 = reinterpret_cast< wxSizer * >(argp1);
46663 arg2 = obj1;
46664 {
46665 PyThreadState* __tstate = wxPyBeginAllowThreads();
46666 result = (bool)wxSizer_Detach(arg1,arg2);
46667 wxPyEndAllowThreads(__tstate);
46668 if (PyErr_Occurred()) SWIG_fail;
46669 }
46670 {
46671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46672 }
46673 return resultobj;
46674 fail:
46675 return NULL;
46676 }
46677
46678
46679 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46680 PyObject *resultobj = 0;
46681 wxSizer *arg1 = (wxSizer *) 0 ;
46682 PyObject *arg2 = (PyObject *) 0 ;
46683 wxSizerItem *result = 0 ;
46684 void *argp1 = 0 ;
46685 int res1 = 0 ;
46686 PyObject * obj0 = 0 ;
46687 PyObject * obj1 = 0 ;
46688 char * kwnames[] = {
46689 (char *) "self",(char *) "item", NULL
46690 };
46691
46692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46694 if (!SWIG_IsOK(res1)) {
46695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46696 }
46697 arg1 = reinterpret_cast< wxSizer * >(argp1);
46698 arg2 = obj1;
46699 {
46700 PyThreadState* __tstate = wxPyBeginAllowThreads();
46701 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46702 wxPyEndAllowThreads(__tstate);
46703 if (PyErr_Occurred()) SWIG_fail;
46704 }
46705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46706 return resultobj;
46707 fail:
46708 return NULL;
46709 }
46710
46711
46712 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46713 PyObject *resultobj = 0;
46714 wxSizer *arg1 = (wxSizer *) 0 ;
46715 PyObject *arg2 = (PyObject *) 0 ;
46716 wxSize *arg3 = 0 ;
46717 void *argp1 = 0 ;
46718 int res1 = 0 ;
46719 wxSize temp3 ;
46720 PyObject * obj0 = 0 ;
46721 PyObject * obj1 = 0 ;
46722 PyObject * obj2 = 0 ;
46723 char * kwnames[] = {
46724 (char *) "self",(char *) "item",(char *) "size", NULL
46725 };
46726
46727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46729 if (!SWIG_IsOK(res1)) {
46730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46731 }
46732 arg1 = reinterpret_cast< wxSizer * >(argp1);
46733 arg2 = obj1;
46734 {
46735 arg3 = &temp3;
46736 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46737 }
46738 {
46739 PyThreadState* __tstate = wxPyBeginAllowThreads();
46740 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46741 wxPyEndAllowThreads(__tstate);
46742 if (PyErr_Occurred()) SWIG_fail;
46743 }
46744 resultobj = SWIG_Py_Void();
46745 return resultobj;
46746 fail:
46747 return NULL;
46748 }
46749
46750
46751 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46752 PyObject *resultobj = 0;
46753 wxSizer *arg1 = (wxSizer *) 0 ;
46754 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46755 wxSizerItem *result = 0 ;
46756 void *argp1 = 0 ;
46757 int res1 = 0 ;
46758 int res2 = 0 ;
46759 PyObject * obj0 = 0 ;
46760 PyObject * obj1 = 0 ;
46761 char * kwnames[] = {
46762 (char *) "self",(char *) "item", NULL
46763 };
46764
46765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46767 if (!SWIG_IsOK(res1)) {
46768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46769 }
46770 arg1 = reinterpret_cast< wxSizer * >(argp1);
46771 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46772 if (!SWIG_IsOK(res2)) {
46773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46774 }
46775 {
46776 PyThreadState* __tstate = wxPyBeginAllowThreads();
46777 result = (wxSizerItem *)(arg1)->Add(arg2);
46778 wxPyEndAllowThreads(__tstate);
46779 if (PyErr_Occurred()) SWIG_fail;
46780 }
46781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46782 return resultobj;
46783 fail:
46784 return NULL;
46785 }
46786
46787
46788 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46789 PyObject *resultobj = 0;
46790 wxSizer *arg1 = (wxSizer *) 0 ;
46791 size_t arg2 ;
46792 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46793 wxSizerItem *result = 0 ;
46794 void *argp1 = 0 ;
46795 int res1 = 0 ;
46796 size_t val2 ;
46797 int ecode2 = 0 ;
46798 int res3 = 0 ;
46799 PyObject * obj0 = 0 ;
46800 PyObject * obj1 = 0 ;
46801 PyObject * obj2 = 0 ;
46802 char * kwnames[] = {
46803 (char *) "self",(char *) "index",(char *) "item", NULL
46804 };
46805
46806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46808 if (!SWIG_IsOK(res1)) {
46809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46810 }
46811 arg1 = reinterpret_cast< wxSizer * >(argp1);
46812 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46813 if (!SWIG_IsOK(ecode2)) {
46814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46815 }
46816 arg2 = static_cast< size_t >(val2);
46817 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46818 if (!SWIG_IsOK(res3)) {
46819 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46820 }
46821 {
46822 PyThreadState* __tstate = wxPyBeginAllowThreads();
46823 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46824 wxPyEndAllowThreads(__tstate);
46825 if (PyErr_Occurred()) SWIG_fail;
46826 }
46827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46828 return resultobj;
46829 fail:
46830 return NULL;
46831 }
46832
46833
46834 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46835 PyObject *resultobj = 0;
46836 wxSizer *arg1 = (wxSizer *) 0 ;
46837 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46838 wxSizerItem *result = 0 ;
46839 void *argp1 = 0 ;
46840 int res1 = 0 ;
46841 int res2 = 0 ;
46842 PyObject * obj0 = 0 ;
46843 PyObject * obj1 = 0 ;
46844 char * kwnames[] = {
46845 (char *) "self",(char *) "item", NULL
46846 };
46847
46848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46850 if (!SWIG_IsOK(res1)) {
46851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46852 }
46853 arg1 = reinterpret_cast< wxSizer * >(argp1);
46854 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46855 if (!SWIG_IsOK(res2)) {
46856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46857 }
46858 {
46859 PyThreadState* __tstate = wxPyBeginAllowThreads();
46860 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46861 wxPyEndAllowThreads(__tstate);
46862 if (PyErr_Occurred()) SWIG_fail;
46863 }
46864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46865 return resultobj;
46866 fail:
46867 return NULL;
46868 }
46869
46870
46871 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46872 PyObject *resultobj = 0;
46873 wxSizer *arg1 = (wxSizer *) 0 ;
46874 int arg2 ;
46875 int arg3 ;
46876 int arg4 ;
46877 int arg5 ;
46878 void *argp1 = 0 ;
46879 int res1 = 0 ;
46880 int val2 ;
46881 int ecode2 = 0 ;
46882 int val3 ;
46883 int ecode3 = 0 ;
46884 int val4 ;
46885 int ecode4 = 0 ;
46886 int val5 ;
46887 int ecode5 = 0 ;
46888 PyObject * obj0 = 0 ;
46889 PyObject * obj1 = 0 ;
46890 PyObject * obj2 = 0 ;
46891 PyObject * obj3 = 0 ;
46892 PyObject * obj4 = 0 ;
46893 char * kwnames[] = {
46894 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46895 };
46896
46897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46899 if (!SWIG_IsOK(res1)) {
46900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46901 }
46902 arg1 = reinterpret_cast< wxSizer * >(argp1);
46903 ecode2 = SWIG_AsVal_int(obj1, &val2);
46904 if (!SWIG_IsOK(ecode2)) {
46905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46906 }
46907 arg2 = static_cast< int >(val2);
46908 ecode3 = SWIG_AsVal_int(obj2, &val3);
46909 if (!SWIG_IsOK(ecode3)) {
46910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46911 }
46912 arg3 = static_cast< int >(val3);
46913 ecode4 = SWIG_AsVal_int(obj3, &val4);
46914 if (!SWIG_IsOK(ecode4)) {
46915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46916 }
46917 arg4 = static_cast< int >(val4);
46918 ecode5 = SWIG_AsVal_int(obj4, &val5);
46919 if (!SWIG_IsOK(ecode5)) {
46920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46921 }
46922 arg5 = static_cast< int >(val5);
46923 {
46924 PyThreadState* __tstate = wxPyBeginAllowThreads();
46925 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46926 wxPyEndAllowThreads(__tstate);
46927 if (PyErr_Occurred()) SWIG_fail;
46928 }
46929 resultobj = SWIG_Py_Void();
46930 return resultobj;
46931 fail:
46932 return NULL;
46933 }
46934
46935
46936 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46937 PyObject *resultobj = 0;
46938 wxSizer *arg1 = (wxSizer *) 0 ;
46939 wxSize *arg2 = 0 ;
46940 void *argp1 = 0 ;
46941 int res1 = 0 ;
46942 wxSize temp2 ;
46943 PyObject * obj0 = 0 ;
46944 PyObject * obj1 = 0 ;
46945 char * kwnames[] = {
46946 (char *) "self",(char *) "size", NULL
46947 };
46948
46949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46951 if (!SWIG_IsOK(res1)) {
46952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46953 }
46954 arg1 = reinterpret_cast< wxSizer * >(argp1);
46955 {
46956 arg2 = &temp2;
46957 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46958 }
46959 {
46960 PyThreadState* __tstate = wxPyBeginAllowThreads();
46961 (arg1)->SetMinSize((wxSize const &)*arg2);
46962 wxPyEndAllowThreads(__tstate);
46963 if (PyErr_Occurred()) SWIG_fail;
46964 }
46965 resultobj = SWIG_Py_Void();
46966 return resultobj;
46967 fail:
46968 return NULL;
46969 }
46970
46971
46972 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46973 PyObject *resultobj = 0;
46974 wxSizer *arg1 = (wxSizer *) 0 ;
46975 wxSize result;
46976 void *argp1 = 0 ;
46977 int res1 = 0 ;
46978 PyObject *swig_obj[1] ;
46979
46980 if (!args) SWIG_fail;
46981 swig_obj[0] = args;
46982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46983 if (!SWIG_IsOK(res1)) {
46984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46985 }
46986 arg1 = reinterpret_cast< wxSizer * >(argp1);
46987 {
46988 PyThreadState* __tstate = wxPyBeginAllowThreads();
46989 result = (arg1)->GetSize();
46990 wxPyEndAllowThreads(__tstate);
46991 if (PyErr_Occurred()) SWIG_fail;
46992 }
46993 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46994 return resultobj;
46995 fail:
46996 return NULL;
46997 }
46998
46999
47000 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47001 PyObject *resultobj = 0;
47002 wxSizer *arg1 = (wxSizer *) 0 ;
47003 wxPoint result;
47004 void *argp1 = 0 ;
47005 int res1 = 0 ;
47006 PyObject *swig_obj[1] ;
47007
47008 if (!args) SWIG_fail;
47009 swig_obj[0] = args;
47010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47011 if (!SWIG_IsOK(res1)) {
47012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47013 }
47014 arg1 = reinterpret_cast< wxSizer * >(argp1);
47015 {
47016 PyThreadState* __tstate = wxPyBeginAllowThreads();
47017 result = (arg1)->GetPosition();
47018 wxPyEndAllowThreads(__tstate);
47019 if (PyErr_Occurred()) SWIG_fail;
47020 }
47021 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47022 return resultobj;
47023 fail:
47024 return NULL;
47025 }
47026
47027
47028 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47029 PyObject *resultobj = 0;
47030 wxSizer *arg1 = (wxSizer *) 0 ;
47031 wxSize result;
47032 void *argp1 = 0 ;
47033 int res1 = 0 ;
47034 PyObject *swig_obj[1] ;
47035
47036 if (!args) SWIG_fail;
47037 swig_obj[0] = args;
47038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47039 if (!SWIG_IsOK(res1)) {
47040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47041 }
47042 arg1 = reinterpret_cast< wxSizer * >(argp1);
47043 {
47044 PyThreadState* __tstate = wxPyBeginAllowThreads();
47045 result = (arg1)->GetMinSize();
47046 wxPyEndAllowThreads(__tstate);
47047 if (PyErr_Occurred()) SWIG_fail;
47048 }
47049 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47050 return resultobj;
47051 fail:
47052 return NULL;
47053 }
47054
47055
47056 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47057 PyObject *resultobj = 0;
47058 wxSizer *arg1 = (wxSizer *) 0 ;
47059 void *argp1 = 0 ;
47060 int res1 = 0 ;
47061 PyObject *swig_obj[1] ;
47062
47063 if (!args) SWIG_fail;
47064 swig_obj[0] = args;
47065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47066 if (!SWIG_IsOK(res1)) {
47067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47068 }
47069 arg1 = reinterpret_cast< wxSizer * >(argp1);
47070 {
47071 PyThreadState* __tstate = wxPyBeginAllowThreads();
47072 (arg1)->RecalcSizes();
47073 wxPyEndAllowThreads(__tstate);
47074 if (PyErr_Occurred()) SWIG_fail;
47075 }
47076 resultobj = SWIG_Py_Void();
47077 return resultobj;
47078 fail:
47079 return NULL;
47080 }
47081
47082
47083 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47084 PyObject *resultobj = 0;
47085 wxSizer *arg1 = (wxSizer *) 0 ;
47086 wxSize result;
47087 void *argp1 = 0 ;
47088 int res1 = 0 ;
47089 PyObject *swig_obj[1] ;
47090
47091 if (!args) SWIG_fail;
47092 swig_obj[0] = args;
47093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47094 if (!SWIG_IsOK(res1)) {
47095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47096 }
47097 arg1 = reinterpret_cast< wxSizer * >(argp1);
47098 {
47099 PyThreadState* __tstate = wxPyBeginAllowThreads();
47100 result = (arg1)->CalcMin();
47101 wxPyEndAllowThreads(__tstate);
47102 if (PyErr_Occurred()) SWIG_fail;
47103 }
47104 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47105 return resultobj;
47106 fail:
47107 return NULL;
47108 }
47109
47110
47111 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47112 PyObject *resultobj = 0;
47113 wxSizer *arg1 = (wxSizer *) 0 ;
47114 void *argp1 = 0 ;
47115 int res1 = 0 ;
47116 PyObject *swig_obj[1] ;
47117
47118 if (!args) SWIG_fail;
47119 swig_obj[0] = args;
47120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47121 if (!SWIG_IsOK(res1)) {
47122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47123 }
47124 arg1 = reinterpret_cast< wxSizer * >(argp1);
47125 {
47126 PyThreadState* __tstate = wxPyBeginAllowThreads();
47127 (arg1)->Layout();
47128 wxPyEndAllowThreads(__tstate);
47129 if (PyErr_Occurred()) SWIG_fail;
47130 }
47131 resultobj = SWIG_Py_Void();
47132 return resultobj;
47133 fail:
47134 return NULL;
47135 }
47136
47137
47138 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47139 PyObject *resultobj = 0;
47140 wxSizer *arg1 = (wxSizer *) 0 ;
47141 wxWindow *arg2 = (wxWindow *) 0 ;
47142 wxSize result;
47143 void *argp1 = 0 ;
47144 int res1 = 0 ;
47145 void *argp2 = 0 ;
47146 int res2 = 0 ;
47147 PyObject * obj0 = 0 ;
47148 PyObject * obj1 = 0 ;
47149 char * kwnames[] = {
47150 (char *) "self",(char *) "window", NULL
47151 };
47152
47153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47155 if (!SWIG_IsOK(res1)) {
47156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47157 }
47158 arg1 = reinterpret_cast< wxSizer * >(argp1);
47159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47160 if (!SWIG_IsOK(res2)) {
47161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47162 }
47163 arg2 = reinterpret_cast< wxWindow * >(argp2);
47164 {
47165 PyThreadState* __tstate = wxPyBeginAllowThreads();
47166 result = (arg1)->Fit(arg2);
47167 wxPyEndAllowThreads(__tstate);
47168 if (PyErr_Occurred()) SWIG_fail;
47169 }
47170 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47171 return resultobj;
47172 fail:
47173 return NULL;
47174 }
47175
47176
47177 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47178 PyObject *resultobj = 0;
47179 wxSizer *arg1 = (wxSizer *) 0 ;
47180 wxWindow *arg2 = (wxWindow *) 0 ;
47181 void *argp1 = 0 ;
47182 int res1 = 0 ;
47183 void *argp2 = 0 ;
47184 int res2 = 0 ;
47185 PyObject * obj0 = 0 ;
47186 PyObject * obj1 = 0 ;
47187 char * kwnames[] = {
47188 (char *) "self",(char *) "window", NULL
47189 };
47190
47191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47193 if (!SWIG_IsOK(res1)) {
47194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47195 }
47196 arg1 = reinterpret_cast< wxSizer * >(argp1);
47197 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47198 if (!SWIG_IsOK(res2)) {
47199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47200 }
47201 arg2 = reinterpret_cast< wxWindow * >(argp2);
47202 {
47203 PyThreadState* __tstate = wxPyBeginAllowThreads();
47204 (arg1)->FitInside(arg2);
47205 wxPyEndAllowThreads(__tstate);
47206 if (PyErr_Occurred()) SWIG_fail;
47207 }
47208 resultobj = SWIG_Py_Void();
47209 return resultobj;
47210 fail:
47211 return NULL;
47212 }
47213
47214
47215 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47216 PyObject *resultobj = 0;
47217 wxSizer *arg1 = (wxSizer *) 0 ;
47218 wxWindow *arg2 = (wxWindow *) 0 ;
47219 void *argp1 = 0 ;
47220 int res1 = 0 ;
47221 void *argp2 = 0 ;
47222 int res2 = 0 ;
47223 PyObject * obj0 = 0 ;
47224 PyObject * obj1 = 0 ;
47225 char * kwnames[] = {
47226 (char *) "self",(char *) "window", NULL
47227 };
47228
47229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47231 if (!SWIG_IsOK(res1)) {
47232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47233 }
47234 arg1 = reinterpret_cast< wxSizer * >(argp1);
47235 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47236 if (!SWIG_IsOK(res2)) {
47237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47238 }
47239 arg2 = reinterpret_cast< wxWindow * >(argp2);
47240 {
47241 PyThreadState* __tstate = wxPyBeginAllowThreads();
47242 (arg1)->SetSizeHints(arg2);
47243 wxPyEndAllowThreads(__tstate);
47244 if (PyErr_Occurred()) SWIG_fail;
47245 }
47246 resultobj = SWIG_Py_Void();
47247 return resultobj;
47248 fail:
47249 return NULL;
47250 }
47251
47252
47253 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47254 PyObject *resultobj = 0;
47255 wxSizer *arg1 = (wxSizer *) 0 ;
47256 wxWindow *arg2 = (wxWindow *) 0 ;
47257 void *argp1 = 0 ;
47258 int res1 = 0 ;
47259 void *argp2 = 0 ;
47260 int res2 = 0 ;
47261 PyObject * obj0 = 0 ;
47262 PyObject * obj1 = 0 ;
47263 char * kwnames[] = {
47264 (char *) "self",(char *) "window", NULL
47265 };
47266
47267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47269 if (!SWIG_IsOK(res1)) {
47270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47271 }
47272 arg1 = reinterpret_cast< wxSizer * >(argp1);
47273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47274 if (!SWIG_IsOK(res2)) {
47275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47276 }
47277 arg2 = reinterpret_cast< wxWindow * >(argp2);
47278 {
47279 PyThreadState* __tstate = wxPyBeginAllowThreads();
47280 (arg1)->SetVirtualSizeHints(arg2);
47281 wxPyEndAllowThreads(__tstate);
47282 if (PyErr_Occurred()) SWIG_fail;
47283 }
47284 resultobj = SWIG_Py_Void();
47285 return resultobj;
47286 fail:
47287 return NULL;
47288 }
47289
47290
47291 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47292 PyObject *resultobj = 0;
47293 wxSizer *arg1 = (wxSizer *) 0 ;
47294 bool arg2 = (bool) false ;
47295 void *argp1 = 0 ;
47296 int res1 = 0 ;
47297 bool val2 ;
47298 int ecode2 = 0 ;
47299 PyObject * obj0 = 0 ;
47300 PyObject * obj1 = 0 ;
47301 char * kwnames[] = {
47302 (char *) "self",(char *) "deleteWindows", NULL
47303 };
47304
47305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47307 if (!SWIG_IsOK(res1)) {
47308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47309 }
47310 arg1 = reinterpret_cast< wxSizer * >(argp1);
47311 if (obj1) {
47312 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47313 if (!SWIG_IsOK(ecode2)) {
47314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47315 }
47316 arg2 = static_cast< bool >(val2);
47317 }
47318 {
47319 PyThreadState* __tstate = wxPyBeginAllowThreads();
47320 (arg1)->Clear(arg2);
47321 wxPyEndAllowThreads(__tstate);
47322 if (PyErr_Occurred()) SWIG_fail;
47323 }
47324 resultobj = SWIG_Py_Void();
47325 return resultobj;
47326 fail:
47327 return NULL;
47328 }
47329
47330
47331 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47332 PyObject *resultobj = 0;
47333 wxSizer *arg1 = (wxSizer *) 0 ;
47334 void *argp1 = 0 ;
47335 int res1 = 0 ;
47336 PyObject *swig_obj[1] ;
47337
47338 if (!args) SWIG_fail;
47339 swig_obj[0] = args;
47340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47341 if (!SWIG_IsOK(res1)) {
47342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47343 }
47344 arg1 = reinterpret_cast< wxSizer * >(argp1);
47345 {
47346 PyThreadState* __tstate = wxPyBeginAllowThreads();
47347 (arg1)->DeleteWindows();
47348 wxPyEndAllowThreads(__tstate);
47349 if (PyErr_Occurred()) SWIG_fail;
47350 }
47351 resultobj = SWIG_Py_Void();
47352 return resultobj;
47353 fail:
47354 return NULL;
47355 }
47356
47357
47358 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47359 PyObject *resultobj = 0;
47360 wxSizer *arg1 = (wxSizer *) 0 ;
47361 PyObject *result = 0 ;
47362 void *argp1 = 0 ;
47363 int res1 = 0 ;
47364 PyObject *swig_obj[1] ;
47365
47366 if (!args) SWIG_fail;
47367 swig_obj[0] = args;
47368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47369 if (!SWIG_IsOK(res1)) {
47370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47371 }
47372 arg1 = reinterpret_cast< wxSizer * >(argp1);
47373 {
47374 PyThreadState* __tstate = wxPyBeginAllowThreads();
47375 result = (PyObject *)wxSizer_GetChildren(arg1);
47376 wxPyEndAllowThreads(__tstate);
47377 if (PyErr_Occurred()) SWIG_fail;
47378 }
47379 resultobj = result;
47380 return resultobj;
47381 fail:
47382 return NULL;
47383 }
47384
47385
47386 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47387 PyObject *resultobj = 0;
47388 wxSizer *arg1 = (wxSizer *) 0 ;
47389 PyObject *arg2 = (PyObject *) 0 ;
47390 bool arg3 = (bool) true ;
47391 bool arg4 = (bool) false ;
47392 bool result;
47393 void *argp1 = 0 ;
47394 int res1 = 0 ;
47395 bool val3 ;
47396 int ecode3 = 0 ;
47397 bool val4 ;
47398 int ecode4 = 0 ;
47399 PyObject * obj0 = 0 ;
47400 PyObject * obj1 = 0 ;
47401 PyObject * obj2 = 0 ;
47402 PyObject * obj3 = 0 ;
47403 char * kwnames[] = {
47404 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47405 };
47406
47407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47409 if (!SWIG_IsOK(res1)) {
47410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47411 }
47412 arg1 = reinterpret_cast< wxSizer * >(argp1);
47413 arg2 = obj1;
47414 if (obj2) {
47415 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47416 if (!SWIG_IsOK(ecode3)) {
47417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47418 }
47419 arg3 = static_cast< bool >(val3);
47420 }
47421 if (obj3) {
47422 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47423 if (!SWIG_IsOK(ecode4)) {
47424 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47425 }
47426 arg4 = static_cast< bool >(val4);
47427 }
47428 {
47429 PyThreadState* __tstate = wxPyBeginAllowThreads();
47430 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47431 wxPyEndAllowThreads(__tstate);
47432 if (PyErr_Occurred()) SWIG_fail;
47433 }
47434 {
47435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47436 }
47437 return resultobj;
47438 fail:
47439 return NULL;
47440 }
47441
47442
47443 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47444 PyObject *resultobj = 0;
47445 wxSizer *arg1 = (wxSizer *) 0 ;
47446 PyObject *arg2 = (PyObject *) 0 ;
47447 bool result;
47448 void *argp1 = 0 ;
47449 int res1 = 0 ;
47450 PyObject * obj0 = 0 ;
47451 PyObject * obj1 = 0 ;
47452 char * kwnames[] = {
47453 (char *) "self",(char *) "item", NULL
47454 };
47455
47456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47458 if (!SWIG_IsOK(res1)) {
47459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47460 }
47461 arg1 = reinterpret_cast< wxSizer * >(argp1);
47462 arg2 = obj1;
47463 {
47464 PyThreadState* __tstate = wxPyBeginAllowThreads();
47465 result = (bool)wxSizer_IsShown(arg1,arg2);
47466 wxPyEndAllowThreads(__tstate);
47467 if (PyErr_Occurred()) SWIG_fail;
47468 }
47469 {
47470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47471 }
47472 return resultobj;
47473 fail:
47474 return NULL;
47475 }
47476
47477
47478 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47479 PyObject *resultobj = 0;
47480 wxSizer *arg1 = (wxSizer *) 0 ;
47481 bool arg2 ;
47482 void *argp1 = 0 ;
47483 int res1 = 0 ;
47484 bool val2 ;
47485 int ecode2 = 0 ;
47486 PyObject * obj0 = 0 ;
47487 PyObject * obj1 = 0 ;
47488 char * kwnames[] = {
47489 (char *) "self",(char *) "show", NULL
47490 };
47491
47492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47494 if (!SWIG_IsOK(res1)) {
47495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47496 }
47497 arg1 = reinterpret_cast< wxSizer * >(argp1);
47498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47499 if (!SWIG_IsOK(ecode2)) {
47500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47501 }
47502 arg2 = static_cast< bool >(val2);
47503 {
47504 PyThreadState* __tstate = wxPyBeginAllowThreads();
47505 (arg1)->ShowItems(arg2);
47506 wxPyEndAllowThreads(__tstate);
47507 if (PyErr_Occurred()) SWIG_fail;
47508 }
47509 resultobj = SWIG_Py_Void();
47510 return resultobj;
47511 fail:
47512 return NULL;
47513 }
47514
47515
47516 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47517 PyObject *obj;
47518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47519 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47520 return SWIG_Py_Void();
47521 }
47522
47523 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47524 PyObject *resultobj = 0;
47525 wxPySizer *result = 0 ;
47526
47527 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47528 {
47529 PyThreadState* __tstate = wxPyBeginAllowThreads();
47530 result = (wxPySizer *)new wxPySizer();
47531 wxPyEndAllowThreads(__tstate);
47532 if (PyErr_Occurred()) SWIG_fail;
47533 }
47534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47535 return resultobj;
47536 fail:
47537 return NULL;
47538 }
47539
47540
47541 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47542 PyObject *resultobj = 0;
47543 wxPySizer *arg1 = (wxPySizer *) 0 ;
47544 PyObject *arg2 = (PyObject *) 0 ;
47545 PyObject *arg3 = (PyObject *) 0 ;
47546 void *argp1 = 0 ;
47547 int res1 = 0 ;
47548 PyObject * obj0 = 0 ;
47549 PyObject * obj1 = 0 ;
47550 PyObject * obj2 = 0 ;
47551 char * kwnames[] = {
47552 (char *) "self",(char *) "self",(char *) "_class", NULL
47553 };
47554
47555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47557 if (!SWIG_IsOK(res1)) {
47558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47559 }
47560 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47561 arg2 = obj1;
47562 arg3 = obj2;
47563 {
47564 PyThreadState* __tstate = wxPyBeginAllowThreads();
47565 (arg1)->_setCallbackInfo(arg2,arg3);
47566 wxPyEndAllowThreads(__tstate);
47567 if (PyErr_Occurred()) SWIG_fail;
47568 }
47569 resultobj = SWIG_Py_Void();
47570 return resultobj;
47571 fail:
47572 return NULL;
47573 }
47574
47575
47576 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47577 PyObject *obj;
47578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47579 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47580 return SWIG_Py_Void();
47581 }
47582
47583 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47584 return SWIG_Python_InitShadowInstance(args);
47585 }
47586
47587 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47588 PyObject *resultobj = 0;
47589 int arg1 = (int) wxHORIZONTAL ;
47590 wxBoxSizer *result = 0 ;
47591 int val1 ;
47592 int ecode1 = 0 ;
47593 PyObject * obj0 = 0 ;
47594 char * kwnames[] = {
47595 (char *) "orient", NULL
47596 };
47597
47598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47599 if (obj0) {
47600 ecode1 = SWIG_AsVal_int(obj0, &val1);
47601 if (!SWIG_IsOK(ecode1)) {
47602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47603 }
47604 arg1 = static_cast< int >(val1);
47605 }
47606 {
47607 PyThreadState* __tstate = wxPyBeginAllowThreads();
47608 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47609 wxPyEndAllowThreads(__tstate);
47610 if (PyErr_Occurred()) SWIG_fail;
47611 }
47612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47613 return resultobj;
47614 fail:
47615 return NULL;
47616 }
47617
47618
47619 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47620 PyObject *resultobj = 0;
47621 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47622 int result;
47623 void *argp1 = 0 ;
47624 int res1 = 0 ;
47625 PyObject *swig_obj[1] ;
47626
47627 if (!args) SWIG_fail;
47628 swig_obj[0] = args;
47629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47630 if (!SWIG_IsOK(res1)) {
47631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47632 }
47633 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47634 {
47635 PyThreadState* __tstate = wxPyBeginAllowThreads();
47636 result = (int)(arg1)->GetOrientation();
47637 wxPyEndAllowThreads(__tstate);
47638 if (PyErr_Occurred()) SWIG_fail;
47639 }
47640 resultobj = SWIG_From_int(static_cast< int >(result));
47641 return resultobj;
47642 fail:
47643 return NULL;
47644 }
47645
47646
47647 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47648 PyObject *resultobj = 0;
47649 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47650 int arg2 ;
47651 void *argp1 = 0 ;
47652 int res1 = 0 ;
47653 int val2 ;
47654 int ecode2 = 0 ;
47655 PyObject * obj0 = 0 ;
47656 PyObject * obj1 = 0 ;
47657 char * kwnames[] = {
47658 (char *) "self",(char *) "orient", NULL
47659 };
47660
47661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47663 if (!SWIG_IsOK(res1)) {
47664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47665 }
47666 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47667 ecode2 = SWIG_AsVal_int(obj1, &val2);
47668 if (!SWIG_IsOK(ecode2)) {
47669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47670 }
47671 arg2 = static_cast< int >(val2);
47672 {
47673 PyThreadState* __tstate = wxPyBeginAllowThreads();
47674 (arg1)->SetOrientation(arg2);
47675 wxPyEndAllowThreads(__tstate);
47676 if (PyErr_Occurred()) SWIG_fail;
47677 }
47678 resultobj = SWIG_Py_Void();
47679 return resultobj;
47680 fail:
47681 return NULL;
47682 }
47683
47684
47685 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47686 PyObject *obj;
47687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47688 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47689 return SWIG_Py_Void();
47690 }
47691
47692 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47693 return SWIG_Python_InitShadowInstance(args);
47694 }
47695
47696 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47697 PyObject *resultobj = 0;
47698 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47699 int arg2 = (int) wxHORIZONTAL ;
47700 wxStaticBoxSizer *result = 0 ;
47701 void *argp1 = 0 ;
47702 int res1 = 0 ;
47703 int val2 ;
47704 int ecode2 = 0 ;
47705 PyObject * obj0 = 0 ;
47706 PyObject * obj1 = 0 ;
47707 char * kwnames[] = {
47708 (char *) "box",(char *) "orient", NULL
47709 };
47710
47711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47713 if (!SWIG_IsOK(res1)) {
47714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47715 }
47716 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47717 if (obj1) {
47718 ecode2 = SWIG_AsVal_int(obj1, &val2);
47719 if (!SWIG_IsOK(ecode2)) {
47720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47721 }
47722 arg2 = static_cast< int >(val2);
47723 }
47724 {
47725 PyThreadState* __tstate = wxPyBeginAllowThreads();
47726 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47727 wxPyEndAllowThreads(__tstate);
47728 if (PyErr_Occurred()) SWIG_fail;
47729 }
47730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47731 return resultobj;
47732 fail:
47733 return NULL;
47734 }
47735
47736
47737 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47738 PyObject *resultobj = 0;
47739 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47740 wxStaticBox *result = 0 ;
47741 void *argp1 = 0 ;
47742 int res1 = 0 ;
47743 PyObject *swig_obj[1] ;
47744
47745 if (!args) SWIG_fail;
47746 swig_obj[0] = args;
47747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47748 if (!SWIG_IsOK(res1)) {
47749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47750 }
47751 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47752 {
47753 PyThreadState* __tstate = wxPyBeginAllowThreads();
47754 result = (wxStaticBox *)(arg1)->GetStaticBox();
47755 wxPyEndAllowThreads(__tstate);
47756 if (PyErr_Occurred()) SWIG_fail;
47757 }
47758 {
47759 resultobj = wxPyMake_wxObject(result, (bool)0);
47760 }
47761 return resultobj;
47762 fail:
47763 return NULL;
47764 }
47765
47766
47767 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47768 PyObject *obj;
47769 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47770 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47771 return SWIG_Py_Void();
47772 }
47773
47774 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47775 return SWIG_Python_InitShadowInstance(args);
47776 }
47777
47778 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47779 PyObject *resultobj = 0;
47780 int arg1 = (int) 1 ;
47781 int arg2 = (int) 0 ;
47782 int arg3 = (int) 0 ;
47783 int arg4 = (int) 0 ;
47784 wxGridSizer *result = 0 ;
47785 int val1 ;
47786 int ecode1 = 0 ;
47787 int val2 ;
47788 int ecode2 = 0 ;
47789 int val3 ;
47790 int ecode3 = 0 ;
47791 int val4 ;
47792 int ecode4 = 0 ;
47793 PyObject * obj0 = 0 ;
47794 PyObject * obj1 = 0 ;
47795 PyObject * obj2 = 0 ;
47796 PyObject * obj3 = 0 ;
47797 char * kwnames[] = {
47798 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47799 };
47800
47801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47802 if (obj0) {
47803 ecode1 = SWIG_AsVal_int(obj0, &val1);
47804 if (!SWIG_IsOK(ecode1)) {
47805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47806 }
47807 arg1 = static_cast< int >(val1);
47808 }
47809 if (obj1) {
47810 ecode2 = SWIG_AsVal_int(obj1, &val2);
47811 if (!SWIG_IsOK(ecode2)) {
47812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47813 }
47814 arg2 = static_cast< int >(val2);
47815 }
47816 if (obj2) {
47817 ecode3 = SWIG_AsVal_int(obj2, &val3);
47818 if (!SWIG_IsOK(ecode3)) {
47819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47820 }
47821 arg3 = static_cast< int >(val3);
47822 }
47823 if (obj3) {
47824 ecode4 = SWIG_AsVal_int(obj3, &val4);
47825 if (!SWIG_IsOK(ecode4)) {
47826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47827 }
47828 arg4 = static_cast< int >(val4);
47829 }
47830 {
47831 PyThreadState* __tstate = wxPyBeginAllowThreads();
47832 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47833 wxPyEndAllowThreads(__tstate);
47834 if (PyErr_Occurred()) SWIG_fail;
47835 }
47836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47837 return resultobj;
47838 fail:
47839 return NULL;
47840 }
47841
47842
47843 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47844 PyObject *resultobj = 0;
47845 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47846 int arg2 ;
47847 void *argp1 = 0 ;
47848 int res1 = 0 ;
47849 int val2 ;
47850 int ecode2 = 0 ;
47851 PyObject * obj0 = 0 ;
47852 PyObject * obj1 = 0 ;
47853 char * kwnames[] = {
47854 (char *) "self",(char *) "cols", NULL
47855 };
47856
47857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47859 if (!SWIG_IsOK(res1)) {
47860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47861 }
47862 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47863 ecode2 = SWIG_AsVal_int(obj1, &val2);
47864 if (!SWIG_IsOK(ecode2)) {
47865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47866 }
47867 arg2 = static_cast< int >(val2);
47868 {
47869 PyThreadState* __tstate = wxPyBeginAllowThreads();
47870 (arg1)->SetCols(arg2);
47871 wxPyEndAllowThreads(__tstate);
47872 if (PyErr_Occurred()) SWIG_fail;
47873 }
47874 resultobj = SWIG_Py_Void();
47875 return resultobj;
47876 fail:
47877 return NULL;
47878 }
47879
47880
47881 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47882 PyObject *resultobj = 0;
47883 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47884 int arg2 ;
47885 void *argp1 = 0 ;
47886 int res1 = 0 ;
47887 int val2 ;
47888 int ecode2 = 0 ;
47889 PyObject * obj0 = 0 ;
47890 PyObject * obj1 = 0 ;
47891 char * kwnames[] = {
47892 (char *) "self",(char *) "rows", NULL
47893 };
47894
47895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47897 if (!SWIG_IsOK(res1)) {
47898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47899 }
47900 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47901 ecode2 = SWIG_AsVal_int(obj1, &val2);
47902 if (!SWIG_IsOK(ecode2)) {
47903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47904 }
47905 arg2 = static_cast< int >(val2);
47906 {
47907 PyThreadState* __tstate = wxPyBeginAllowThreads();
47908 (arg1)->SetRows(arg2);
47909 wxPyEndAllowThreads(__tstate);
47910 if (PyErr_Occurred()) SWIG_fail;
47911 }
47912 resultobj = SWIG_Py_Void();
47913 return resultobj;
47914 fail:
47915 return NULL;
47916 }
47917
47918
47919 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47920 PyObject *resultobj = 0;
47921 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47922 int arg2 ;
47923 void *argp1 = 0 ;
47924 int res1 = 0 ;
47925 int val2 ;
47926 int ecode2 = 0 ;
47927 PyObject * obj0 = 0 ;
47928 PyObject * obj1 = 0 ;
47929 char * kwnames[] = {
47930 (char *) "self",(char *) "gap", NULL
47931 };
47932
47933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47935 if (!SWIG_IsOK(res1)) {
47936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47937 }
47938 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47939 ecode2 = SWIG_AsVal_int(obj1, &val2);
47940 if (!SWIG_IsOK(ecode2)) {
47941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47942 }
47943 arg2 = static_cast< int >(val2);
47944 {
47945 PyThreadState* __tstate = wxPyBeginAllowThreads();
47946 (arg1)->SetVGap(arg2);
47947 wxPyEndAllowThreads(__tstate);
47948 if (PyErr_Occurred()) SWIG_fail;
47949 }
47950 resultobj = SWIG_Py_Void();
47951 return resultobj;
47952 fail:
47953 return NULL;
47954 }
47955
47956
47957 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47958 PyObject *resultobj = 0;
47959 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47960 int arg2 ;
47961 void *argp1 = 0 ;
47962 int res1 = 0 ;
47963 int val2 ;
47964 int ecode2 = 0 ;
47965 PyObject * obj0 = 0 ;
47966 PyObject * obj1 = 0 ;
47967 char * kwnames[] = {
47968 (char *) "self",(char *) "gap", NULL
47969 };
47970
47971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47973 if (!SWIG_IsOK(res1)) {
47974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47975 }
47976 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47977 ecode2 = SWIG_AsVal_int(obj1, &val2);
47978 if (!SWIG_IsOK(ecode2)) {
47979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47980 }
47981 arg2 = static_cast< int >(val2);
47982 {
47983 PyThreadState* __tstate = wxPyBeginAllowThreads();
47984 (arg1)->SetHGap(arg2);
47985 wxPyEndAllowThreads(__tstate);
47986 if (PyErr_Occurred()) SWIG_fail;
47987 }
47988 resultobj = SWIG_Py_Void();
47989 return resultobj;
47990 fail:
47991 return NULL;
47992 }
47993
47994
47995 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47996 PyObject *resultobj = 0;
47997 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47998 int result;
47999 void *argp1 = 0 ;
48000 int res1 = 0 ;
48001 PyObject *swig_obj[1] ;
48002
48003 if (!args) SWIG_fail;
48004 swig_obj[0] = args;
48005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48006 if (!SWIG_IsOK(res1)) {
48007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48008 }
48009 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48010 {
48011 PyThreadState* __tstate = wxPyBeginAllowThreads();
48012 result = (int)(arg1)->GetCols();
48013 wxPyEndAllowThreads(__tstate);
48014 if (PyErr_Occurred()) SWIG_fail;
48015 }
48016 resultobj = SWIG_From_int(static_cast< int >(result));
48017 return resultobj;
48018 fail:
48019 return NULL;
48020 }
48021
48022
48023 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48024 PyObject *resultobj = 0;
48025 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48026 int result;
48027 void *argp1 = 0 ;
48028 int res1 = 0 ;
48029 PyObject *swig_obj[1] ;
48030
48031 if (!args) SWIG_fail;
48032 swig_obj[0] = args;
48033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48034 if (!SWIG_IsOK(res1)) {
48035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48036 }
48037 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48038 {
48039 PyThreadState* __tstate = wxPyBeginAllowThreads();
48040 result = (int)(arg1)->GetRows();
48041 wxPyEndAllowThreads(__tstate);
48042 if (PyErr_Occurred()) SWIG_fail;
48043 }
48044 resultobj = SWIG_From_int(static_cast< int >(result));
48045 return resultobj;
48046 fail:
48047 return NULL;
48048 }
48049
48050
48051 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48052 PyObject *resultobj = 0;
48053 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48054 int result;
48055 void *argp1 = 0 ;
48056 int res1 = 0 ;
48057 PyObject *swig_obj[1] ;
48058
48059 if (!args) SWIG_fail;
48060 swig_obj[0] = args;
48061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48062 if (!SWIG_IsOK(res1)) {
48063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48064 }
48065 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48066 {
48067 PyThreadState* __tstate = wxPyBeginAllowThreads();
48068 result = (int)(arg1)->GetVGap();
48069 wxPyEndAllowThreads(__tstate);
48070 if (PyErr_Occurred()) SWIG_fail;
48071 }
48072 resultobj = SWIG_From_int(static_cast< int >(result));
48073 return resultobj;
48074 fail:
48075 return NULL;
48076 }
48077
48078
48079 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48080 PyObject *resultobj = 0;
48081 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48082 int result;
48083 void *argp1 = 0 ;
48084 int res1 = 0 ;
48085 PyObject *swig_obj[1] ;
48086
48087 if (!args) SWIG_fail;
48088 swig_obj[0] = args;
48089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48090 if (!SWIG_IsOK(res1)) {
48091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48092 }
48093 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48094 {
48095 PyThreadState* __tstate = wxPyBeginAllowThreads();
48096 result = (int)(arg1)->GetHGap();
48097 wxPyEndAllowThreads(__tstate);
48098 if (PyErr_Occurred()) SWIG_fail;
48099 }
48100 resultobj = SWIG_From_int(static_cast< int >(result));
48101 return resultobj;
48102 fail:
48103 return NULL;
48104 }
48105
48106
48107 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48108 PyObject *obj;
48109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48110 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48111 return SWIG_Py_Void();
48112 }
48113
48114 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48115 return SWIG_Python_InitShadowInstance(args);
48116 }
48117
48118 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48119 PyObject *resultobj = 0;
48120 int arg1 = (int) 1 ;
48121 int arg2 = (int) 0 ;
48122 int arg3 = (int) 0 ;
48123 int arg4 = (int) 0 ;
48124 wxFlexGridSizer *result = 0 ;
48125 int val1 ;
48126 int ecode1 = 0 ;
48127 int val2 ;
48128 int ecode2 = 0 ;
48129 int val3 ;
48130 int ecode3 = 0 ;
48131 int val4 ;
48132 int ecode4 = 0 ;
48133 PyObject * obj0 = 0 ;
48134 PyObject * obj1 = 0 ;
48135 PyObject * obj2 = 0 ;
48136 PyObject * obj3 = 0 ;
48137 char * kwnames[] = {
48138 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48139 };
48140
48141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48142 if (obj0) {
48143 ecode1 = SWIG_AsVal_int(obj0, &val1);
48144 if (!SWIG_IsOK(ecode1)) {
48145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48146 }
48147 arg1 = static_cast< int >(val1);
48148 }
48149 if (obj1) {
48150 ecode2 = SWIG_AsVal_int(obj1, &val2);
48151 if (!SWIG_IsOK(ecode2)) {
48152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48153 }
48154 arg2 = static_cast< int >(val2);
48155 }
48156 if (obj2) {
48157 ecode3 = SWIG_AsVal_int(obj2, &val3);
48158 if (!SWIG_IsOK(ecode3)) {
48159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48160 }
48161 arg3 = static_cast< int >(val3);
48162 }
48163 if (obj3) {
48164 ecode4 = SWIG_AsVal_int(obj3, &val4);
48165 if (!SWIG_IsOK(ecode4)) {
48166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48167 }
48168 arg4 = static_cast< int >(val4);
48169 }
48170 {
48171 PyThreadState* __tstate = wxPyBeginAllowThreads();
48172 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48173 wxPyEndAllowThreads(__tstate);
48174 if (PyErr_Occurred()) SWIG_fail;
48175 }
48176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48177 return resultobj;
48178 fail:
48179 return NULL;
48180 }
48181
48182
48183 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48184 PyObject *resultobj = 0;
48185 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48186 size_t arg2 ;
48187 int arg3 = (int) 0 ;
48188 void *argp1 = 0 ;
48189 int res1 = 0 ;
48190 size_t val2 ;
48191 int ecode2 = 0 ;
48192 int val3 ;
48193 int ecode3 = 0 ;
48194 PyObject * obj0 = 0 ;
48195 PyObject * obj1 = 0 ;
48196 PyObject * obj2 = 0 ;
48197 char * kwnames[] = {
48198 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48199 };
48200
48201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48203 if (!SWIG_IsOK(res1)) {
48204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48205 }
48206 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48207 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48208 if (!SWIG_IsOK(ecode2)) {
48209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48210 }
48211 arg2 = static_cast< size_t >(val2);
48212 if (obj2) {
48213 ecode3 = SWIG_AsVal_int(obj2, &val3);
48214 if (!SWIG_IsOK(ecode3)) {
48215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48216 }
48217 arg3 = static_cast< int >(val3);
48218 }
48219 {
48220 PyThreadState* __tstate = wxPyBeginAllowThreads();
48221 (arg1)->AddGrowableRow(arg2,arg3);
48222 wxPyEndAllowThreads(__tstate);
48223 if (PyErr_Occurred()) SWIG_fail;
48224 }
48225 resultobj = SWIG_Py_Void();
48226 return resultobj;
48227 fail:
48228 return NULL;
48229 }
48230
48231
48232 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48233 PyObject *resultobj = 0;
48234 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48235 size_t arg2 ;
48236 void *argp1 = 0 ;
48237 int res1 = 0 ;
48238 size_t val2 ;
48239 int ecode2 = 0 ;
48240 PyObject * obj0 = 0 ;
48241 PyObject * obj1 = 0 ;
48242 char * kwnames[] = {
48243 (char *) "self",(char *) "idx", NULL
48244 };
48245
48246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48248 if (!SWIG_IsOK(res1)) {
48249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48250 }
48251 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48252 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48253 if (!SWIG_IsOK(ecode2)) {
48254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48255 }
48256 arg2 = static_cast< size_t >(val2);
48257 {
48258 PyThreadState* __tstate = wxPyBeginAllowThreads();
48259 (arg1)->RemoveGrowableRow(arg2);
48260 wxPyEndAllowThreads(__tstate);
48261 if (PyErr_Occurred()) SWIG_fail;
48262 }
48263 resultobj = SWIG_Py_Void();
48264 return resultobj;
48265 fail:
48266 return NULL;
48267 }
48268
48269
48270 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48271 PyObject *resultobj = 0;
48272 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48273 size_t arg2 ;
48274 int arg3 = (int) 0 ;
48275 void *argp1 = 0 ;
48276 int res1 = 0 ;
48277 size_t val2 ;
48278 int ecode2 = 0 ;
48279 int val3 ;
48280 int ecode3 = 0 ;
48281 PyObject * obj0 = 0 ;
48282 PyObject * obj1 = 0 ;
48283 PyObject * obj2 = 0 ;
48284 char * kwnames[] = {
48285 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48286 };
48287
48288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48290 if (!SWIG_IsOK(res1)) {
48291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48292 }
48293 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48294 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48295 if (!SWIG_IsOK(ecode2)) {
48296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48297 }
48298 arg2 = static_cast< size_t >(val2);
48299 if (obj2) {
48300 ecode3 = SWIG_AsVal_int(obj2, &val3);
48301 if (!SWIG_IsOK(ecode3)) {
48302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48303 }
48304 arg3 = static_cast< int >(val3);
48305 }
48306 {
48307 PyThreadState* __tstate = wxPyBeginAllowThreads();
48308 (arg1)->AddGrowableCol(arg2,arg3);
48309 wxPyEndAllowThreads(__tstate);
48310 if (PyErr_Occurred()) SWIG_fail;
48311 }
48312 resultobj = SWIG_Py_Void();
48313 return resultobj;
48314 fail:
48315 return NULL;
48316 }
48317
48318
48319 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48320 PyObject *resultobj = 0;
48321 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48322 size_t arg2 ;
48323 void *argp1 = 0 ;
48324 int res1 = 0 ;
48325 size_t val2 ;
48326 int ecode2 = 0 ;
48327 PyObject * obj0 = 0 ;
48328 PyObject * obj1 = 0 ;
48329 char * kwnames[] = {
48330 (char *) "self",(char *) "idx", NULL
48331 };
48332
48333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48335 if (!SWIG_IsOK(res1)) {
48336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48337 }
48338 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48339 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48340 if (!SWIG_IsOK(ecode2)) {
48341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48342 }
48343 arg2 = static_cast< size_t >(val2);
48344 {
48345 PyThreadState* __tstate = wxPyBeginAllowThreads();
48346 (arg1)->RemoveGrowableCol(arg2);
48347 wxPyEndAllowThreads(__tstate);
48348 if (PyErr_Occurred()) SWIG_fail;
48349 }
48350 resultobj = SWIG_Py_Void();
48351 return resultobj;
48352 fail:
48353 return NULL;
48354 }
48355
48356
48357 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48358 PyObject *resultobj = 0;
48359 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48360 int arg2 ;
48361 void *argp1 = 0 ;
48362 int res1 = 0 ;
48363 int val2 ;
48364 int ecode2 = 0 ;
48365 PyObject * obj0 = 0 ;
48366 PyObject * obj1 = 0 ;
48367 char * kwnames[] = {
48368 (char *) "self",(char *) "direction", NULL
48369 };
48370
48371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48373 if (!SWIG_IsOK(res1)) {
48374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48375 }
48376 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48377 ecode2 = SWIG_AsVal_int(obj1, &val2);
48378 if (!SWIG_IsOK(ecode2)) {
48379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48380 }
48381 arg2 = static_cast< int >(val2);
48382 {
48383 PyThreadState* __tstate = wxPyBeginAllowThreads();
48384 (arg1)->SetFlexibleDirection(arg2);
48385 wxPyEndAllowThreads(__tstate);
48386 if (PyErr_Occurred()) SWIG_fail;
48387 }
48388 resultobj = SWIG_Py_Void();
48389 return resultobj;
48390 fail:
48391 return NULL;
48392 }
48393
48394
48395 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48396 PyObject *resultobj = 0;
48397 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48398 int result;
48399 void *argp1 = 0 ;
48400 int res1 = 0 ;
48401 PyObject *swig_obj[1] ;
48402
48403 if (!args) SWIG_fail;
48404 swig_obj[0] = args;
48405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48406 if (!SWIG_IsOK(res1)) {
48407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48408 }
48409 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48410 {
48411 PyThreadState* __tstate = wxPyBeginAllowThreads();
48412 result = (int)(arg1)->GetFlexibleDirection();
48413 wxPyEndAllowThreads(__tstate);
48414 if (PyErr_Occurred()) SWIG_fail;
48415 }
48416 resultobj = SWIG_From_int(static_cast< int >(result));
48417 return resultobj;
48418 fail:
48419 return NULL;
48420 }
48421
48422
48423 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48424 PyObject *resultobj = 0;
48425 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48426 wxFlexSizerGrowMode arg2 ;
48427 void *argp1 = 0 ;
48428 int res1 = 0 ;
48429 int val2 ;
48430 int ecode2 = 0 ;
48431 PyObject * obj0 = 0 ;
48432 PyObject * obj1 = 0 ;
48433 char * kwnames[] = {
48434 (char *) "self",(char *) "mode", NULL
48435 };
48436
48437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48439 if (!SWIG_IsOK(res1)) {
48440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48441 }
48442 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48443 ecode2 = SWIG_AsVal_int(obj1, &val2);
48444 if (!SWIG_IsOK(ecode2)) {
48445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48446 }
48447 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48448 {
48449 PyThreadState* __tstate = wxPyBeginAllowThreads();
48450 (arg1)->SetNonFlexibleGrowMode(arg2);
48451 wxPyEndAllowThreads(__tstate);
48452 if (PyErr_Occurred()) SWIG_fail;
48453 }
48454 resultobj = SWIG_Py_Void();
48455 return resultobj;
48456 fail:
48457 return NULL;
48458 }
48459
48460
48461 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48462 PyObject *resultobj = 0;
48463 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48464 wxFlexSizerGrowMode result;
48465 void *argp1 = 0 ;
48466 int res1 = 0 ;
48467 PyObject *swig_obj[1] ;
48468
48469 if (!args) SWIG_fail;
48470 swig_obj[0] = args;
48471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48472 if (!SWIG_IsOK(res1)) {
48473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48474 }
48475 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48476 {
48477 PyThreadState* __tstate = wxPyBeginAllowThreads();
48478 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48479 wxPyEndAllowThreads(__tstate);
48480 if (PyErr_Occurred()) SWIG_fail;
48481 }
48482 resultobj = SWIG_From_int(static_cast< int >(result));
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48490 PyObject *resultobj = 0;
48491 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48492 wxArrayInt *result = 0 ;
48493 void *argp1 = 0 ;
48494 int res1 = 0 ;
48495 PyObject *swig_obj[1] ;
48496
48497 if (!args) SWIG_fail;
48498 swig_obj[0] = args;
48499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48500 if (!SWIG_IsOK(res1)) {
48501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48502 }
48503 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48504 {
48505 PyThreadState* __tstate = wxPyBeginAllowThreads();
48506 {
48507 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48508 result = (wxArrayInt *) &_result_ref;
48509 }
48510 wxPyEndAllowThreads(__tstate);
48511 if (PyErr_Occurred()) SWIG_fail;
48512 }
48513 {
48514 resultobj = PyList_New(0);
48515 size_t idx;
48516 for (idx = 0; idx < result->GetCount(); idx += 1) {
48517 PyObject* val = PyInt_FromLong( result->Item(idx) );
48518 PyList_Append(resultobj, val);
48519 Py_DECREF(val);
48520 }
48521 }
48522 return resultobj;
48523 fail:
48524 return NULL;
48525 }
48526
48527
48528 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48529 PyObject *resultobj = 0;
48530 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48531 wxArrayInt *result = 0 ;
48532 void *argp1 = 0 ;
48533 int res1 = 0 ;
48534 PyObject *swig_obj[1] ;
48535
48536 if (!args) SWIG_fail;
48537 swig_obj[0] = args;
48538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48539 if (!SWIG_IsOK(res1)) {
48540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48541 }
48542 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48543 {
48544 PyThreadState* __tstate = wxPyBeginAllowThreads();
48545 {
48546 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48547 result = (wxArrayInt *) &_result_ref;
48548 }
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 {
48553 resultobj = PyList_New(0);
48554 size_t idx;
48555 for (idx = 0; idx < result->GetCount(); idx += 1) {
48556 PyObject* val = PyInt_FromLong( result->Item(idx) );
48557 PyList_Append(resultobj, val);
48558 Py_DECREF(val);
48559 }
48560 }
48561 return resultobj;
48562 fail:
48563 return NULL;
48564 }
48565
48566
48567 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48568 PyObject *obj;
48569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48570 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48571 return SWIG_Py_Void();
48572 }
48573
48574 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48575 return SWIG_Python_InitShadowInstance(args);
48576 }
48577
48578 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48579 PyObject *resultobj = 0;
48580 wxStdDialogButtonSizer *result = 0 ;
48581
48582 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48583 {
48584 PyThreadState* __tstate = wxPyBeginAllowThreads();
48585 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48586 wxPyEndAllowThreads(__tstate);
48587 if (PyErr_Occurred()) SWIG_fail;
48588 }
48589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48590 return resultobj;
48591 fail:
48592 return NULL;
48593 }
48594
48595
48596 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48597 PyObject *resultobj = 0;
48598 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48599 wxButton *arg2 = (wxButton *) 0 ;
48600 void *argp1 = 0 ;
48601 int res1 = 0 ;
48602 void *argp2 = 0 ;
48603 int res2 = 0 ;
48604 PyObject * obj0 = 0 ;
48605 PyObject * obj1 = 0 ;
48606 char * kwnames[] = {
48607 (char *) "self",(char *) "button", NULL
48608 };
48609
48610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48612 if (!SWIG_IsOK(res1)) {
48613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48614 }
48615 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48617 if (!SWIG_IsOK(res2)) {
48618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48619 }
48620 arg2 = reinterpret_cast< wxButton * >(argp2);
48621 {
48622 PyThreadState* __tstate = wxPyBeginAllowThreads();
48623 (arg1)->AddButton(arg2);
48624 wxPyEndAllowThreads(__tstate);
48625 if (PyErr_Occurred()) SWIG_fail;
48626 }
48627 resultobj = SWIG_Py_Void();
48628 return resultobj;
48629 fail:
48630 return NULL;
48631 }
48632
48633
48634 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48635 PyObject *resultobj = 0;
48636 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48637 void *argp1 = 0 ;
48638 int res1 = 0 ;
48639 PyObject *swig_obj[1] ;
48640
48641 if (!args) SWIG_fail;
48642 swig_obj[0] = args;
48643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48644 if (!SWIG_IsOK(res1)) {
48645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48646 }
48647 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48648 {
48649 PyThreadState* __tstate = wxPyBeginAllowThreads();
48650 (arg1)->Realize();
48651 wxPyEndAllowThreads(__tstate);
48652 if (PyErr_Occurred()) SWIG_fail;
48653 }
48654 resultobj = SWIG_Py_Void();
48655 return resultobj;
48656 fail:
48657 return NULL;
48658 }
48659
48660
48661 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48662 PyObject *resultobj = 0;
48663 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48664 wxButton *arg2 = (wxButton *) 0 ;
48665 void *argp1 = 0 ;
48666 int res1 = 0 ;
48667 void *argp2 = 0 ;
48668 int res2 = 0 ;
48669 PyObject * obj0 = 0 ;
48670 PyObject * obj1 = 0 ;
48671 char * kwnames[] = {
48672 (char *) "self",(char *) "button", NULL
48673 };
48674
48675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48677 if (!SWIG_IsOK(res1)) {
48678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48679 }
48680 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48681 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48682 if (!SWIG_IsOK(res2)) {
48683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48684 }
48685 arg2 = reinterpret_cast< wxButton * >(argp2);
48686 {
48687 PyThreadState* __tstate = wxPyBeginAllowThreads();
48688 (arg1)->SetAffirmativeButton(arg2);
48689 wxPyEndAllowThreads(__tstate);
48690 if (PyErr_Occurred()) SWIG_fail;
48691 }
48692 resultobj = SWIG_Py_Void();
48693 return resultobj;
48694 fail:
48695 return NULL;
48696 }
48697
48698
48699 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48700 PyObject *resultobj = 0;
48701 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48702 wxButton *arg2 = (wxButton *) 0 ;
48703 void *argp1 = 0 ;
48704 int res1 = 0 ;
48705 void *argp2 = 0 ;
48706 int res2 = 0 ;
48707 PyObject * obj0 = 0 ;
48708 PyObject * obj1 = 0 ;
48709 char * kwnames[] = {
48710 (char *) "self",(char *) "button", NULL
48711 };
48712
48713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48715 if (!SWIG_IsOK(res1)) {
48716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48717 }
48718 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48720 if (!SWIG_IsOK(res2)) {
48721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48722 }
48723 arg2 = reinterpret_cast< wxButton * >(argp2);
48724 {
48725 PyThreadState* __tstate = wxPyBeginAllowThreads();
48726 (arg1)->SetNegativeButton(arg2);
48727 wxPyEndAllowThreads(__tstate);
48728 if (PyErr_Occurred()) SWIG_fail;
48729 }
48730 resultobj = SWIG_Py_Void();
48731 return resultobj;
48732 fail:
48733 return NULL;
48734 }
48735
48736
48737 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48738 PyObject *resultobj = 0;
48739 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48740 wxButton *arg2 = (wxButton *) 0 ;
48741 void *argp1 = 0 ;
48742 int res1 = 0 ;
48743 void *argp2 = 0 ;
48744 int res2 = 0 ;
48745 PyObject * obj0 = 0 ;
48746 PyObject * obj1 = 0 ;
48747 char * kwnames[] = {
48748 (char *) "self",(char *) "button", NULL
48749 };
48750
48751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48753 if (!SWIG_IsOK(res1)) {
48754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48755 }
48756 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48758 if (!SWIG_IsOK(res2)) {
48759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48760 }
48761 arg2 = reinterpret_cast< wxButton * >(argp2);
48762 {
48763 PyThreadState* __tstate = wxPyBeginAllowThreads();
48764 (arg1)->SetCancelButton(arg2);
48765 wxPyEndAllowThreads(__tstate);
48766 if (PyErr_Occurred()) SWIG_fail;
48767 }
48768 resultobj = SWIG_Py_Void();
48769 return resultobj;
48770 fail:
48771 return NULL;
48772 }
48773
48774
48775 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48776 PyObject *resultobj = 0;
48777 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48778 wxButton *result = 0 ;
48779 void *argp1 = 0 ;
48780 int res1 = 0 ;
48781 PyObject *swig_obj[1] ;
48782
48783 if (!args) SWIG_fail;
48784 swig_obj[0] = args;
48785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48786 if (!SWIG_IsOK(res1)) {
48787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48788 }
48789 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48790 {
48791 PyThreadState* __tstate = wxPyBeginAllowThreads();
48792 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48793 wxPyEndAllowThreads(__tstate);
48794 if (PyErr_Occurred()) SWIG_fail;
48795 }
48796 {
48797 resultobj = wxPyMake_wxObject(result, (bool)0);
48798 }
48799 return resultobj;
48800 fail:
48801 return NULL;
48802 }
48803
48804
48805 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48806 PyObject *resultobj = 0;
48807 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48808 wxButton *result = 0 ;
48809 void *argp1 = 0 ;
48810 int res1 = 0 ;
48811 PyObject *swig_obj[1] ;
48812
48813 if (!args) SWIG_fail;
48814 swig_obj[0] = args;
48815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48816 if (!SWIG_IsOK(res1)) {
48817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48818 }
48819 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48820 {
48821 PyThreadState* __tstate = wxPyBeginAllowThreads();
48822 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48823 wxPyEndAllowThreads(__tstate);
48824 if (PyErr_Occurred()) SWIG_fail;
48825 }
48826 {
48827 resultobj = wxPyMake_wxObject(result, (bool)0);
48828 }
48829 return resultobj;
48830 fail:
48831 return NULL;
48832 }
48833
48834
48835 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48836 PyObject *resultobj = 0;
48837 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48838 wxButton *result = 0 ;
48839 void *argp1 = 0 ;
48840 int res1 = 0 ;
48841 PyObject *swig_obj[1] ;
48842
48843 if (!args) SWIG_fail;
48844 swig_obj[0] = args;
48845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48846 if (!SWIG_IsOK(res1)) {
48847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48848 }
48849 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48850 {
48851 PyThreadState* __tstate = wxPyBeginAllowThreads();
48852 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48853 wxPyEndAllowThreads(__tstate);
48854 if (PyErr_Occurred()) SWIG_fail;
48855 }
48856 {
48857 resultobj = wxPyMake_wxObject(result, (bool)0);
48858 }
48859 return resultobj;
48860 fail:
48861 return NULL;
48862 }
48863
48864
48865 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48866 PyObject *resultobj = 0;
48867 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48868 wxButton *result = 0 ;
48869 void *argp1 = 0 ;
48870 int res1 = 0 ;
48871 PyObject *swig_obj[1] ;
48872
48873 if (!args) SWIG_fail;
48874 swig_obj[0] = args;
48875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48876 if (!SWIG_IsOK(res1)) {
48877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48878 }
48879 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48880 {
48881 PyThreadState* __tstate = wxPyBeginAllowThreads();
48882 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48883 wxPyEndAllowThreads(__tstate);
48884 if (PyErr_Occurred()) SWIG_fail;
48885 }
48886 {
48887 resultobj = wxPyMake_wxObject(result, (bool)0);
48888 }
48889 return resultobj;
48890 fail:
48891 return NULL;
48892 }
48893
48894
48895 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48896 PyObject *resultobj = 0;
48897 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48898 wxButton *result = 0 ;
48899 void *argp1 = 0 ;
48900 int res1 = 0 ;
48901 PyObject *swig_obj[1] ;
48902
48903 if (!args) SWIG_fail;
48904 swig_obj[0] = args;
48905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48906 if (!SWIG_IsOK(res1)) {
48907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48908 }
48909 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48910 {
48911 PyThreadState* __tstate = wxPyBeginAllowThreads();
48912 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48913 wxPyEndAllowThreads(__tstate);
48914 if (PyErr_Occurred()) SWIG_fail;
48915 }
48916 {
48917 resultobj = wxPyMake_wxObject(result, (bool)0);
48918 }
48919 return resultobj;
48920 fail:
48921 return NULL;
48922 }
48923
48924
48925 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48926 PyObject *obj;
48927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48928 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48929 return SWIG_Py_Void();
48930 }
48931
48932 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48933 return SWIG_Python_InitShadowInstance(args);
48934 }
48935
48936 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48937 PyObject *resultobj = 0;
48938 int arg1 = (int) 0 ;
48939 int arg2 = (int) 0 ;
48940 wxGBPosition *result = 0 ;
48941 int val1 ;
48942 int ecode1 = 0 ;
48943 int val2 ;
48944 int ecode2 = 0 ;
48945 PyObject * obj0 = 0 ;
48946 PyObject * obj1 = 0 ;
48947 char * kwnames[] = {
48948 (char *) "row",(char *) "col", NULL
48949 };
48950
48951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48952 if (obj0) {
48953 ecode1 = SWIG_AsVal_int(obj0, &val1);
48954 if (!SWIG_IsOK(ecode1)) {
48955 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48956 }
48957 arg1 = static_cast< int >(val1);
48958 }
48959 if (obj1) {
48960 ecode2 = SWIG_AsVal_int(obj1, &val2);
48961 if (!SWIG_IsOK(ecode2)) {
48962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48963 }
48964 arg2 = static_cast< int >(val2);
48965 }
48966 {
48967 PyThreadState* __tstate = wxPyBeginAllowThreads();
48968 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48969 wxPyEndAllowThreads(__tstate);
48970 if (PyErr_Occurred()) SWIG_fail;
48971 }
48972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48973 return resultobj;
48974 fail:
48975 return NULL;
48976 }
48977
48978
48979 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48980 PyObject *resultobj = 0;
48981 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48982 void *argp1 = 0 ;
48983 int res1 = 0 ;
48984 PyObject *swig_obj[1] ;
48985
48986 if (!args) SWIG_fail;
48987 swig_obj[0] = args;
48988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48989 if (!SWIG_IsOK(res1)) {
48990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48991 }
48992 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48993 {
48994 PyThreadState* __tstate = wxPyBeginAllowThreads();
48995 delete arg1;
48996
48997 wxPyEndAllowThreads(__tstate);
48998 if (PyErr_Occurred()) SWIG_fail;
48999 }
49000 resultobj = SWIG_Py_Void();
49001 return resultobj;
49002 fail:
49003 return NULL;
49004 }
49005
49006
49007 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49008 PyObject *resultobj = 0;
49009 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49010 int result;
49011 void *argp1 = 0 ;
49012 int res1 = 0 ;
49013 PyObject *swig_obj[1] ;
49014
49015 if (!args) SWIG_fail;
49016 swig_obj[0] = args;
49017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49018 if (!SWIG_IsOK(res1)) {
49019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49020 }
49021 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49022 {
49023 PyThreadState* __tstate = wxPyBeginAllowThreads();
49024 result = (int)((wxGBPosition const *)arg1)->GetRow();
49025 wxPyEndAllowThreads(__tstate);
49026 if (PyErr_Occurred()) SWIG_fail;
49027 }
49028 resultobj = SWIG_From_int(static_cast< int >(result));
49029 return resultobj;
49030 fail:
49031 return NULL;
49032 }
49033
49034
49035 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49036 PyObject *resultobj = 0;
49037 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49038 int result;
49039 void *argp1 = 0 ;
49040 int res1 = 0 ;
49041 PyObject *swig_obj[1] ;
49042
49043 if (!args) SWIG_fail;
49044 swig_obj[0] = args;
49045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49046 if (!SWIG_IsOK(res1)) {
49047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49048 }
49049 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49050 {
49051 PyThreadState* __tstate = wxPyBeginAllowThreads();
49052 result = (int)((wxGBPosition const *)arg1)->GetCol();
49053 wxPyEndAllowThreads(__tstate);
49054 if (PyErr_Occurred()) SWIG_fail;
49055 }
49056 resultobj = SWIG_From_int(static_cast< int >(result));
49057 return resultobj;
49058 fail:
49059 return NULL;
49060 }
49061
49062
49063 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49064 PyObject *resultobj = 0;
49065 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49066 int arg2 ;
49067 void *argp1 = 0 ;
49068 int res1 = 0 ;
49069 int val2 ;
49070 int ecode2 = 0 ;
49071 PyObject * obj0 = 0 ;
49072 PyObject * obj1 = 0 ;
49073 char * kwnames[] = {
49074 (char *) "self",(char *) "row", NULL
49075 };
49076
49077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49079 if (!SWIG_IsOK(res1)) {
49080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49081 }
49082 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49083 ecode2 = SWIG_AsVal_int(obj1, &val2);
49084 if (!SWIG_IsOK(ecode2)) {
49085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49086 }
49087 arg2 = static_cast< int >(val2);
49088 {
49089 PyThreadState* __tstate = wxPyBeginAllowThreads();
49090 (arg1)->SetRow(arg2);
49091 wxPyEndAllowThreads(__tstate);
49092 if (PyErr_Occurred()) SWIG_fail;
49093 }
49094 resultobj = SWIG_Py_Void();
49095 return resultobj;
49096 fail:
49097 return NULL;
49098 }
49099
49100
49101 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49102 PyObject *resultobj = 0;
49103 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49104 int arg2 ;
49105 void *argp1 = 0 ;
49106 int res1 = 0 ;
49107 int val2 ;
49108 int ecode2 = 0 ;
49109 PyObject * obj0 = 0 ;
49110 PyObject * obj1 = 0 ;
49111 char * kwnames[] = {
49112 (char *) "self",(char *) "col", NULL
49113 };
49114
49115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49117 if (!SWIG_IsOK(res1)) {
49118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49119 }
49120 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49121 ecode2 = SWIG_AsVal_int(obj1, &val2);
49122 if (!SWIG_IsOK(ecode2)) {
49123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49124 }
49125 arg2 = static_cast< int >(val2);
49126 {
49127 PyThreadState* __tstate = wxPyBeginAllowThreads();
49128 (arg1)->SetCol(arg2);
49129 wxPyEndAllowThreads(__tstate);
49130 if (PyErr_Occurred()) SWIG_fail;
49131 }
49132 resultobj = SWIG_Py_Void();
49133 return resultobj;
49134 fail:
49135 return NULL;
49136 }
49137
49138
49139 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49140 PyObject *resultobj = 0;
49141 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49142 PyObject *arg2 = (PyObject *) 0 ;
49143 bool result;
49144 void *argp1 = 0 ;
49145 int res1 = 0 ;
49146 PyObject * obj0 = 0 ;
49147 PyObject * obj1 = 0 ;
49148 char * kwnames[] = {
49149 (char *) "self",(char *) "other", NULL
49150 };
49151
49152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49154 if (!SWIG_IsOK(res1)) {
49155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49156 }
49157 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49158 arg2 = obj1;
49159 {
49160 result = (bool)wxGBPosition___eq__(arg1,arg2);
49161 if (PyErr_Occurred()) SWIG_fail;
49162 }
49163 {
49164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49165 }
49166 return resultobj;
49167 fail:
49168 return NULL;
49169 }
49170
49171
49172 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49173 PyObject *resultobj = 0;
49174 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49175 PyObject *arg2 = (PyObject *) 0 ;
49176 bool result;
49177 void *argp1 = 0 ;
49178 int res1 = 0 ;
49179 PyObject * obj0 = 0 ;
49180 PyObject * obj1 = 0 ;
49181 char * kwnames[] = {
49182 (char *) "self",(char *) "other", NULL
49183 };
49184
49185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49187 if (!SWIG_IsOK(res1)) {
49188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49189 }
49190 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49191 arg2 = obj1;
49192 {
49193 result = (bool)wxGBPosition___ne__(arg1,arg2);
49194 if (PyErr_Occurred()) SWIG_fail;
49195 }
49196 {
49197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49198 }
49199 return resultobj;
49200 fail:
49201 return NULL;
49202 }
49203
49204
49205 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49206 PyObject *resultobj = 0;
49207 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49208 int arg2 = (int) 0 ;
49209 int arg3 = (int) 0 ;
49210 void *argp1 = 0 ;
49211 int res1 = 0 ;
49212 int val2 ;
49213 int ecode2 = 0 ;
49214 int val3 ;
49215 int ecode3 = 0 ;
49216 PyObject * obj0 = 0 ;
49217 PyObject * obj1 = 0 ;
49218 PyObject * obj2 = 0 ;
49219 char * kwnames[] = {
49220 (char *) "self",(char *) "row",(char *) "col", NULL
49221 };
49222
49223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49225 if (!SWIG_IsOK(res1)) {
49226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49227 }
49228 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49229 if (obj1) {
49230 ecode2 = SWIG_AsVal_int(obj1, &val2);
49231 if (!SWIG_IsOK(ecode2)) {
49232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49233 }
49234 arg2 = static_cast< int >(val2);
49235 }
49236 if (obj2) {
49237 ecode3 = SWIG_AsVal_int(obj2, &val3);
49238 if (!SWIG_IsOK(ecode3)) {
49239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49240 }
49241 arg3 = static_cast< int >(val3);
49242 }
49243 {
49244 PyThreadState* __tstate = wxPyBeginAllowThreads();
49245 wxGBPosition_Set(arg1,arg2,arg3);
49246 wxPyEndAllowThreads(__tstate);
49247 if (PyErr_Occurred()) SWIG_fail;
49248 }
49249 resultobj = SWIG_Py_Void();
49250 return resultobj;
49251 fail:
49252 return NULL;
49253 }
49254
49255
49256 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49257 PyObject *resultobj = 0;
49258 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49259 PyObject *result = 0 ;
49260 void *argp1 = 0 ;
49261 int res1 = 0 ;
49262 PyObject *swig_obj[1] ;
49263
49264 if (!args) SWIG_fail;
49265 swig_obj[0] = args;
49266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49267 if (!SWIG_IsOK(res1)) {
49268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49269 }
49270 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49271 {
49272 PyThreadState* __tstate = wxPyBeginAllowThreads();
49273 result = (PyObject *)wxGBPosition_Get(arg1);
49274 wxPyEndAllowThreads(__tstate);
49275 if (PyErr_Occurred()) SWIG_fail;
49276 }
49277 resultobj = result;
49278 return resultobj;
49279 fail:
49280 return NULL;
49281 }
49282
49283
49284 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49285 PyObject *obj;
49286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49287 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49288 return SWIG_Py_Void();
49289 }
49290
49291 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49292 return SWIG_Python_InitShadowInstance(args);
49293 }
49294
49295 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49296 PyObject *resultobj = 0;
49297 int arg1 = (int) 1 ;
49298 int arg2 = (int) 1 ;
49299 wxGBSpan *result = 0 ;
49300 int val1 ;
49301 int ecode1 = 0 ;
49302 int val2 ;
49303 int ecode2 = 0 ;
49304 PyObject * obj0 = 0 ;
49305 PyObject * obj1 = 0 ;
49306 char * kwnames[] = {
49307 (char *) "rowspan",(char *) "colspan", NULL
49308 };
49309
49310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49311 if (obj0) {
49312 ecode1 = SWIG_AsVal_int(obj0, &val1);
49313 if (!SWIG_IsOK(ecode1)) {
49314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49315 }
49316 arg1 = static_cast< int >(val1);
49317 }
49318 if (obj1) {
49319 ecode2 = SWIG_AsVal_int(obj1, &val2);
49320 if (!SWIG_IsOK(ecode2)) {
49321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49322 }
49323 arg2 = static_cast< int >(val2);
49324 }
49325 {
49326 PyThreadState* __tstate = wxPyBeginAllowThreads();
49327 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49328 wxPyEndAllowThreads(__tstate);
49329 if (PyErr_Occurred()) SWIG_fail;
49330 }
49331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49332 return resultobj;
49333 fail:
49334 return NULL;
49335 }
49336
49337
49338 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49339 PyObject *resultobj = 0;
49340 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49341 void *argp1 = 0 ;
49342 int res1 = 0 ;
49343 PyObject *swig_obj[1] ;
49344
49345 if (!args) SWIG_fail;
49346 swig_obj[0] = args;
49347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49348 if (!SWIG_IsOK(res1)) {
49349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49350 }
49351 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49352 {
49353 PyThreadState* __tstate = wxPyBeginAllowThreads();
49354 delete arg1;
49355
49356 wxPyEndAllowThreads(__tstate);
49357 if (PyErr_Occurred()) SWIG_fail;
49358 }
49359 resultobj = SWIG_Py_Void();
49360 return resultobj;
49361 fail:
49362 return NULL;
49363 }
49364
49365
49366 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49367 PyObject *resultobj = 0;
49368 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49369 int result;
49370 void *argp1 = 0 ;
49371 int res1 = 0 ;
49372 PyObject *swig_obj[1] ;
49373
49374 if (!args) SWIG_fail;
49375 swig_obj[0] = args;
49376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49377 if (!SWIG_IsOK(res1)) {
49378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49379 }
49380 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49381 {
49382 PyThreadState* __tstate = wxPyBeginAllowThreads();
49383 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49384 wxPyEndAllowThreads(__tstate);
49385 if (PyErr_Occurred()) SWIG_fail;
49386 }
49387 resultobj = SWIG_From_int(static_cast< int >(result));
49388 return resultobj;
49389 fail:
49390 return NULL;
49391 }
49392
49393
49394 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49395 PyObject *resultobj = 0;
49396 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49397 int result;
49398 void *argp1 = 0 ;
49399 int res1 = 0 ;
49400 PyObject *swig_obj[1] ;
49401
49402 if (!args) SWIG_fail;
49403 swig_obj[0] = args;
49404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49405 if (!SWIG_IsOK(res1)) {
49406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49407 }
49408 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49409 {
49410 PyThreadState* __tstate = wxPyBeginAllowThreads();
49411 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49412 wxPyEndAllowThreads(__tstate);
49413 if (PyErr_Occurred()) SWIG_fail;
49414 }
49415 resultobj = SWIG_From_int(static_cast< int >(result));
49416 return resultobj;
49417 fail:
49418 return NULL;
49419 }
49420
49421
49422 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49423 PyObject *resultobj = 0;
49424 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49425 int arg2 ;
49426 void *argp1 = 0 ;
49427 int res1 = 0 ;
49428 int val2 ;
49429 int ecode2 = 0 ;
49430 PyObject * obj0 = 0 ;
49431 PyObject * obj1 = 0 ;
49432 char * kwnames[] = {
49433 (char *) "self",(char *) "rowspan", NULL
49434 };
49435
49436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49438 if (!SWIG_IsOK(res1)) {
49439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49440 }
49441 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49442 ecode2 = SWIG_AsVal_int(obj1, &val2);
49443 if (!SWIG_IsOK(ecode2)) {
49444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49445 }
49446 arg2 = static_cast< int >(val2);
49447 {
49448 PyThreadState* __tstate = wxPyBeginAllowThreads();
49449 (arg1)->SetRowspan(arg2);
49450 wxPyEndAllowThreads(__tstate);
49451 if (PyErr_Occurred()) SWIG_fail;
49452 }
49453 resultobj = SWIG_Py_Void();
49454 return resultobj;
49455 fail:
49456 return NULL;
49457 }
49458
49459
49460 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49461 PyObject *resultobj = 0;
49462 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49463 int arg2 ;
49464 void *argp1 = 0 ;
49465 int res1 = 0 ;
49466 int val2 ;
49467 int ecode2 = 0 ;
49468 PyObject * obj0 = 0 ;
49469 PyObject * obj1 = 0 ;
49470 char * kwnames[] = {
49471 (char *) "self",(char *) "colspan", NULL
49472 };
49473
49474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49476 if (!SWIG_IsOK(res1)) {
49477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49478 }
49479 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49480 ecode2 = SWIG_AsVal_int(obj1, &val2);
49481 if (!SWIG_IsOK(ecode2)) {
49482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49483 }
49484 arg2 = static_cast< int >(val2);
49485 {
49486 PyThreadState* __tstate = wxPyBeginAllowThreads();
49487 (arg1)->SetColspan(arg2);
49488 wxPyEndAllowThreads(__tstate);
49489 if (PyErr_Occurred()) SWIG_fail;
49490 }
49491 resultobj = SWIG_Py_Void();
49492 return resultobj;
49493 fail:
49494 return NULL;
49495 }
49496
49497
49498 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49499 PyObject *resultobj = 0;
49500 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49501 PyObject *arg2 = (PyObject *) 0 ;
49502 bool result;
49503 void *argp1 = 0 ;
49504 int res1 = 0 ;
49505 PyObject * obj0 = 0 ;
49506 PyObject * obj1 = 0 ;
49507 char * kwnames[] = {
49508 (char *) "self",(char *) "other", NULL
49509 };
49510
49511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49513 if (!SWIG_IsOK(res1)) {
49514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49515 }
49516 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49517 arg2 = obj1;
49518 {
49519 result = (bool)wxGBSpan___eq__(arg1,arg2);
49520 if (PyErr_Occurred()) SWIG_fail;
49521 }
49522 {
49523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49524 }
49525 return resultobj;
49526 fail:
49527 return NULL;
49528 }
49529
49530
49531 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49532 PyObject *resultobj = 0;
49533 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49534 PyObject *arg2 = (PyObject *) 0 ;
49535 bool result;
49536 void *argp1 = 0 ;
49537 int res1 = 0 ;
49538 PyObject * obj0 = 0 ;
49539 PyObject * obj1 = 0 ;
49540 char * kwnames[] = {
49541 (char *) "self",(char *) "other", NULL
49542 };
49543
49544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49546 if (!SWIG_IsOK(res1)) {
49547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49548 }
49549 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49550 arg2 = obj1;
49551 {
49552 result = (bool)wxGBSpan___ne__(arg1,arg2);
49553 if (PyErr_Occurred()) SWIG_fail;
49554 }
49555 {
49556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49557 }
49558 return resultobj;
49559 fail:
49560 return NULL;
49561 }
49562
49563
49564 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49565 PyObject *resultobj = 0;
49566 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49567 int arg2 = (int) 1 ;
49568 int arg3 = (int) 1 ;
49569 void *argp1 = 0 ;
49570 int res1 = 0 ;
49571 int val2 ;
49572 int ecode2 = 0 ;
49573 int val3 ;
49574 int ecode3 = 0 ;
49575 PyObject * obj0 = 0 ;
49576 PyObject * obj1 = 0 ;
49577 PyObject * obj2 = 0 ;
49578 char * kwnames[] = {
49579 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49580 };
49581
49582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49584 if (!SWIG_IsOK(res1)) {
49585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49586 }
49587 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49588 if (obj1) {
49589 ecode2 = SWIG_AsVal_int(obj1, &val2);
49590 if (!SWIG_IsOK(ecode2)) {
49591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49592 }
49593 arg2 = static_cast< int >(val2);
49594 }
49595 if (obj2) {
49596 ecode3 = SWIG_AsVal_int(obj2, &val3);
49597 if (!SWIG_IsOK(ecode3)) {
49598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49599 }
49600 arg3 = static_cast< int >(val3);
49601 }
49602 {
49603 PyThreadState* __tstate = wxPyBeginAllowThreads();
49604 wxGBSpan_Set(arg1,arg2,arg3);
49605 wxPyEndAllowThreads(__tstate);
49606 if (PyErr_Occurred()) SWIG_fail;
49607 }
49608 resultobj = SWIG_Py_Void();
49609 return resultobj;
49610 fail:
49611 return NULL;
49612 }
49613
49614
49615 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49616 PyObject *resultobj = 0;
49617 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49618 PyObject *result = 0 ;
49619 void *argp1 = 0 ;
49620 int res1 = 0 ;
49621 PyObject *swig_obj[1] ;
49622
49623 if (!args) SWIG_fail;
49624 swig_obj[0] = args;
49625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49626 if (!SWIG_IsOK(res1)) {
49627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49628 }
49629 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49630 {
49631 PyThreadState* __tstate = wxPyBeginAllowThreads();
49632 result = (PyObject *)wxGBSpan_Get(arg1);
49633 wxPyEndAllowThreads(__tstate);
49634 if (PyErr_Occurred()) SWIG_fail;
49635 }
49636 resultobj = result;
49637 return resultobj;
49638 fail:
49639 return NULL;
49640 }
49641
49642
49643 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49644 PyObject *obj;
49645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49646 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49647 return SWIG_Py_Void();
49648 }
49649
49650 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49651 return SWIG_Python_InitShadowInstance(args);
49652 }
49653
49654 SWIGINTERN int DefaultSpan_set(PyObject *) {
49655 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49656 return 1;
49657 }
49658
49659
49660 SWIGINTERN PyObject *DefaultSpan_get(void) {
49661 PyObject *pyobj = 0;
49662
49663 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49664 return pyobj;
49665 }
49666
49667
49668 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49669 PyObject *resultobj = 0;
49670 wxGBSizerItem *result = 0 ;
49671
49672 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49673 {
49674 PyThreadState* __tstate = wxPyBeginAllowThreads();
49675 result = (wxGBSizerItem *)new wxGBSizerItem();
49676 wxPyEndAllowThreads(__tstate);
49677 if (PyErr_Occurred()) SWIG_fail;
49678 }
49679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49680 return resultobj;
49681 fail:
49682 return NULL;
49683 }
49684
49685
49686 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49687 PyObject *resultobj = 0;
49688 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49689 void *argp1 = 0 ;
49690 int res1 = 0 ;
49691 PyObject *swig_obj[1] ;
49692
49693 if (!args) SWIG_fail;
49694 swig_obj[0] = args;
49695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49696 if (!SWIG_IsOK(res1)) {
49697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49698 }
49699 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49700 {
49701 PyThreadState* __tstate = wxPyBeginAllowThreads();
49702 delete arg1;
49703
49704 wxPyEndAllowThreads(__tstate);
49705 if (PyErr_Occurred()) SWIG_fail;
49706 }
49707 resultobj = SWIG_Py_Void();
49708 return resultobj;
49709 fail:
49710 return NULL;
49711 }
49712
49713
49714 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49715 PyObject *resultobj = 0;
49716 wxWindow *arg1 = (wxWindow *) 0 ;
49717 wxGBPosition *arg2 = 0 ;
49718 wxGBSpan *arg3 = 0 ;
49719 int arg4 ;
49720 int arg5 ;
49721 PyObject *arg6 = (PyObject *) NULL ;
49722 wxGBSizerItem *result = 0 ;
49723 void *argp1 = 0 ;
49724 int res1 = 0 ;
49725 wxGBPosition temp2 ;
49726 wxGBSpan temp3 ;
49727 int val4 ;
49728 int ecode4 = 0 ;
49729 int val5 ;
49730 int ecode5 = 0 ;
49731 PyObject * obj0 = 0 ;
49732 PyObject * obj1 = 0 ;
49733 PyObject * obj2 = 0 ;
49734 PyObject * obj3 = 0 ;
49735 PyObject * obj4 = 0 ;
49736 PyObject * obj5 = 0 ;
49737 char * kwnames[] = {
49738 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49739 };
49740
49741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49743 if (!SWIG_IsOK(res1)) {
49744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49745 }
49746 arg1 = reinterpret_cast< wxWindow * >(argp1);
49747 {
49748 arg2 = &temp2;
49749 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49750 }
49751 {
49752 arg3 = &temp3;
49753 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49754 }
49755 ecode4 = SWIG_AsVal_int(obj3, &val4);
49756 if (!SWIG_IsOK(ecode4)) {
49757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49758 }
49759 arg4 = static_cast< int >(val4);
49760 ecode5 = SWIG_AsVal_int(obj4, &val5);
49761 if (!SWIG_IsOK(ecode5)) {
49762 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49763 }
49764 arg5 = static_cast< int >(val5);
49765 if (obj5) {
49766 arg6 = obj5;
49767 }
49768 {
49769 PyThreadState* __tstate = wxPyBeginAllowThreads();
49770 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49771 wxPyEndAllowThreads(__tstate);
49772 if (PyErr_Occurred()) SWIG_fail;
49773 }
49774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49775 return resultobj;
49776 fail:
49777 return NULL;
49778 }
49779
49780
49781 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49782 PyObject *resultobj = 0;
49783 wxSizer *arg1 = (wxSizer *) 0 ;
49784 wxGBPosition *arg2 = 0 ;
49785 wxGBSpan *arg3 = 0 ;
49786 int arg4 ;
49787 int arg5 ;
49788 PyObject *arg6 = (PyObject *) NULL ;
49789 wxGBSizerItem *result = 0 ;
49790 int res1 = 0 ;
49791 wxGBPosition temp2 ;
49792 wxGBSpan temp3 ;
49793 int val4 ;
49794 int ecode4 = 0 ;
49795 int val5 ;
49796 int ecode5 = 0 ;
49797 PyObject * obj0 = 0 ;
49798 PyObject * obj1 = 0 ;
49799 PyObject * obj2 = 0 ;
49800 PyObject * obj3 = 0 ;
49801 PyObject * obj4 = 0 ;
49802 PyObject * obj5 = 0 ;
49803 char * kwnames[] = {
49804 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49805 };
49806
49807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49808 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49809 if (!SWIG_IsOK(res1)) {
49810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49811 }
49812 {
49813 arg2 = &temp2;
49814 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49815 }
49816 {
49817 arg3 = &temp3;
49818 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49819 }
49820 ecode4 = SWIG_AsVal_int(obj3, &val4);
49821 if (!SWIG_IsOK(ecode4)) {
49822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49823 }
49824 arg4 = static_cast< int >(val4);
49825 ecode5 = SWIG_AsVal_int(obj4, &val5);
49826 if (!SWIG_IsOK(ecode5)) {
49827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49828 }
49829 arg5 = static_cast< int >(val5);
49830 if (obj5) {
49831 arg6 = obj5;
49832 }
49833 {
49834 PyThreadState* __tstate = wxPyBeginAllowThreads();
49835 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49836 wxPyEndAllowThreads(__tstate);
49837 if (PyErr_Occurred()) SWIG_fail;
49838 }
49839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49840 return resultobj;
49841 fail:
49842 return NULL;
49843 }
49844
49845
49846 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49847 PyObject *resultobj = 0;
49848 int arg1 ;
49849 int arg2 ;
49850 wxGBPosition *arg3 = 0 ;
49851 wxGBSpan *arg4 = 0 ;
49852 int arg5 ;
49853 int arg6 ;
49854 PyObject *arg7 = (PyObject *) NULL ;
49855 wxGBSizerItem *result = 0 ;
49856 int val1 ;
49857 int ecode1 = 0 ;
49858 int val2 ;
49859 int ecode2 = 0 ;
49860 wxGBPosition temp3 ;
49861 wxGBSpan temp4 ;
49862 int val5 ;
49863 int ecode5 = 0 ;
49864 int val6 ;
49865 int ecode6 = 0 ;
49866 PyObject * obj0 = 0 ;
49867 PyObject * obj1 = 0 ;
49868 PyObject * obj2 = 0 ;
49869 PyObject * obj3 = 0 ;
49870 PyObject * obj4 = 0 ;
49871 PyObject * obj5 = 0 ;
49872 PyObject * obj6 = 0 ;
49873 char * kwnames[] = {
49874 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49875 };
49876
49877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49878 ecode1 = SWIG_AsVal_int(obj0, &val1);
49879 if (!SWIG_IsOK(ecode1)) {
49880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49881 }
49882 arg1 = static_cast< int >(val1);
49883 ecode2 = SWIG_AsVal_int(obj1, &val2);
49884 if (!SWIG_IsOK(ecode2)) {
49885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49886 }
49887 arg2 = static_cast< int >(val2);
49888 {
49889 arg3 = &temp3;
49890 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49891 }
49892 {
49893 arg4 = &temp4;
49894 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49895 }
49896 ecode5 = SWIG_AsVal_int(obj4, &val5);
49897 if (!SWIG_IsOK(ecode5)) {
49898 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49899 }
49900 arg5 = static_cast< int >(val5);
49901 ecode6 = SWIG_AsVal_int(obj5, &val6);
49902 if (!SWIG_IsOK(ecode6)) {
49903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49904 }
49905 arg6 = static_cast< int >(val6);
49906 if (obj6) {
49907 arg7 = obj6;
49908 }
49909 {
49910 PyThreadState* __tstate = wxPyBeginAllowThreads();
49911 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49912 wxPyEndAllowThreads(__tstate);
49913 if (PyErr_Occurred()) SWIG_fail;
49914 }
49915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49916 return resultobj;
49917 fail:
49918 return NULL;
49919 }
49920
49921
49922 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49923 PyObject *resultobj = 0;
49924 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49925 wxGBPosition result;
49926 void *argp1 = 0 ;
49927 int res1 = 0 ;
49928 PyObject *swig_obj[1] ;
49929
49930 if (!args) SWIG_fail;
49931 swig_obj[0] = args;
49932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49933 if (!SWIG_IsOK(res1)) {
49934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49935 }
49936 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49937 {
49938 PyThreadState* __tstate = wxPyBeginAllowThreads();
49939 result = ((wxGBSizerItem const *)arg1)->GetPos();
49940 wxPyEndAllowThreads(__tstate);
49941 if (PyErr_Occurred()) SWIG_fail;
49942 }
49943 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49944 return resultobj;
49945 fail:
49946 return NULL;
49947 }
49948
49949
49950 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49951 PyObject *resultobj = 0;
49952 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49953 wxGBSpan result;
49954 void *argp1 = 0 ;
49955 int res1 = 0 ;
49956 PyObject *swig_obj[1] ;
49957
49958 if (!args) SWIG_fail;
49959 swig_obj[0] = args;
49960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49961 if (!SWIG_IsOK(res1)) {
49962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49963 }
49964 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49965 {
49966 PyThreadState* __tstate = wxPyBeginAllowThreads();
49967 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49968 wxPyEndAllowThreads(__tstate);
49969 if (PyErr_Occurred()) SWIG_fail;
49970 }
49971 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49972 return resultobj;
49973 fail:
49974 return NULL;
49975 }
49976
49977
49978 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49979 PyObject *resultobj = 0;
49980 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49981 wxGBPosition *arg2 = 0 ;
49982 bool result;
49983 void *argp1 = 0 ;
49984 int res1 = 0 ;
49985 wxGBPosition temp2 ;
49986 PyObject * obj0 = 0 ;
49987 PyObject * obj1 = 0 ;
49988 char * kwnames[] = {
49989 (char *) "self",(char *) "pos", NULL
49990 };
49991
49992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49994 if (!SWIG_IsOK(res1)) {
49995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49996 }
49997 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49998 {
49999 arg2 = &temp2;
50000 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50001 }
50002 {
50003 PyThreadState* __tstate = wxPyBeginAllowThreads();
50004 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50005 wxPyEndAllowThreads(__tstate);
50006 if (PyErr_Occurred()) SWIG_fail;
50007 }
50008 {
50009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50010 }
50011 return resultobj;
50012 fail:
50013 return NULL;
50014 }
50015
50016
50017 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50018 PyObject *resultobj = 0;
50019 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50020 wxGBSpan *arg2 = 0 ;
50021 bool result;
50022 void *argp1 = 0 ;
50023 int res1 = 0 ;
50024 wxGBSpan temp2 ;
50025 PyObject * obj0 = 0 ;
50026 PyObject * obj1 = 0 ;
50027 char * kwnames[] = {
50028 (char *) "self",(char *) "span", NULL
50029 };
50030
50031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50033 if (!SWIG_IsOK(res1)) {
50034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50035 }
50036 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50037 {
50038 arg2 = &temp2;
50039 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50040 }
50041 {
50042 PyThreadState* __tstate = wxPyBeginAllowThreads();
50043 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50044 wxPyEndAllowThreads(__tstate);
50045 if (PyErr_Occurred()) SWIG_fail;
50046 }
50047 {
50048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50049 }
50050 return resultobj;
50051 fail:
50052 return NULL;
50053 }
50054
50055
50056 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50057 PyObject *resultobj = 0;
50058 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50059 wxGBSizerItem *arg2 = 0 ;
50060 bool result;
50061 void *argp1 = 0 ;
50062 int res1 = 0 ;
50063 void *argp2 = 0 ;
50064 int res2 = 0 ;
50065 PyObject * obj0 = 0 ;
50066 PyObject * obj1 = 0 ;
50067 char * kwnames[] = {
50068 (char *) "self",(char *) "other", NULL
50069 };
50070
50071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50073 if (!SWIG_IsOK(res1)) {
50074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50075 }
50076 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50078 if (!SWIG_IsOK(res2)) {
50079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50080 }
50081 if (!argp2) {
50082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50083 }
50084 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50085 {
50086 PyThreadState* __tstate = wxPyBeginAllowThreads();
50087 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50088 wxPyEndAllowThreads(__tstate);
50089 if (PyErr_Occurred()) SWIG_fail;
50090 }
50091 {
50092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50093 }
50094 return resultobj;
50095 fail:
50096 return NULL;
50097 }
50098
50099
50100 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50101 PyObject *resultobj = 0;
50102 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50103 wxGBPosition *arg2 = 0 ;
50104 wxGBSpan *arg3 = 0 ;
50105 bool result;
50106 void *argp1 = 0 ;
50107 int res1 = 0 ;
50108 wxGBPosition temp2 ;
50109 wxGBSpan temp3 ;
50110 PyObject * obj0 = 0 ;
50111 PyObject * obj1 = 0 ;
50112 PyObject * obj2 = 0 ;
50113 char * kwnames[] = {
50114 (char *) "self",(char *) "pos",(char *) "span", NULL
50115 };
50116
50117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50119 if (!SWIG_IsOK(res1)) {
50120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50121 }
50122 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50123 {
50124 arg2 = &temp2;
50125 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50126 }
50127 {
50128 arg3 = &temp3;
50129 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50130 }
50131 {
50132 PyThreadState* __tstate = wxPyBeginAllowThreads();
50133 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50134 wxPyEndAllowThreads(__tstate);
50135 if (PyErr_Occurred()) SWIG_fail;
50136 }
50137 {
50138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50139 }
50140 return resultobj;
50141 fail:
50142 return NULL;
50143 }
50144
50145
50146 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50147 PyObject *resultobj = 0;
50148 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50149 wxGBPosition result;
50150 void *argp1 = 0 ;
50151 int res1 = 0 ;
50152 PyObject *swig_obj[1] ;
50153
50154 if (!args) SWIG_fail;
50155 swig_obj[0] = args;
50156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50157 if (!SWIG_IsOK(res1)) {
50158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50159 }
50160 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50161 {
50162 PyThreadState* __tstate = wxPyBeginAllowThreads();
50163 result = wxGBSizerItem_GetEndPos(arg1);
50164 wxPyEndAllowThreads(__tstate);
50165 if (PyErr_Occurred()) SWIG_fail;
50166 }
50167 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50168 return resultobj;
50169 fail:
50170 return NULL;
50171 }
50172
50173
50174 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50175 PyObject *resultobj = 0;
50176 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50177 wxGridBagSizer *result = 0 ;
50178 void *argp1 = 0 ;
50179 int res1 = 0 ;
50180 PyObject *swig_obj[1] ;
50181
50182 if (!args) SWIG_fail;
50183 swig_obj[0] = args;
50184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50185 if (!SWIG_IsOK(res1)) {
50186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50187 }
50188 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50189 {
50190 PyThreadState* __tstate = wxPyBeginAllowThreads();
50191 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50192 wxPyEndAllowThreads(__tstate);
50193 if (PyErr_Occurred()) SWIG_fail;
50194 }
50195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50196 return resultobj;
50197 fail:
50198 return NULL;
50199 }
50200
50201
50202 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50203 PyObject *resultobj = 0;
50204 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50205 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50206 void *argp1 = 0 ;
50207 int res1 = 0 ;
50208 void *argp2 = 0 ;
50209 int res2 = 0 ;
50210 PyObject * obj0 = 0 ;
50211 PyObject * obj1 = 0 ;
50212 char * kwnames[] = {
50213 (char *) "self",(char *) "sizer", NULL
50214 };
50215
50216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50218 if (!SWIG_IsOK(res1)) {
50219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50220 }
50221 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50223 if (!SWIG_IsOK(res2)) {
50224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50225 }
50226 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50227 {
50228 PyThreadState* __tstate = wxPyBeginAllowThreads();
50229 (arg1)->SetGBSizer(arg2);
50230 wxPyEndAllowThreads(__tstate);
50231 if (PyErr_Occurred()) SWIG_fail;
50232 }
50233 resultobj = SWIG_Py_Void();
50234 return resultobj;
50235 fail:
50236 return NULL;
50237 }
50238
50239
50240 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50241 PyObject *obj;
50242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50243 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50244 return SWIG_Py_Void();
50245 }
50246
50247 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50248 return SWIG_Python_InitShadowInstance(args);
50249 }
50250
50251 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50252 PyObject *resultobj = 0;
50253 int arg1 = (int) 0 ;
50254 int arg2 = (int) 0 ;
50255 wxGridBagSizer *result = 0 ;
50256 int val1 ;
50257 int ecode1 = 0 ;
50258 int val2 ;
50259 int ecode2 = 0 ;
50260 PyObject * obj0 = 0 ;
50261 PyObject * obj1 = 0 ;
50262 char * kwnames[] = {
50263 (char *) "vgap",(char *) "hgap", NULL
50264 };
50265
50266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50267 if (obj0) {
50268 ecode1 = SWIG_AsVal_int(obj0, &val1);
50269 if (!SWIG_IsOK(ecode1)) {
50270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50271 }
50272 arg1 = static_cast< int >(val1);
50273 }
50274 if (obj1) {
50275 ecode2 = SWIG_AsVal_int(obj1, &val2);
50276 if (!SWIG_IsOK(ecode2)) {
50277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50278 }
50279 arg2 = static_cast< int >(val2);
50280 }
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50288 return resultobj;
50289 fail:
50290 return NULL;
50291 }
50292
50293
50294 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50295 PyObject *resultobj = 0;
50296 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50297 PyObject *arg2 = (PyObject *) 0 ;
50298 wxGBPosition *arg3 = 0 ;
50299 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50300 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50301 int arg5 = (int) 0 ;
50302 int arg6 = (int) 0 ;
50303 PyObject *arg7 = (PyObject *) NULL ;
50304 wxGBSizerItem *result = 0 ;
50305 void *argp1 = 0 ;
50306 int res1 = 0 ;
50307 wxGBPosition temp3 ;
50308 wxGBSpan temp4 ;
50309 int val5 ;
50310 int ecode5 = 0 ;
50311 int val6 ;
50312 int ecode6 = 0 ;
50313 PyObject * obj0 = 0 ;
50314 PyObject * obj1 = 0 ;
50315 PyObject * obj2 = 0 ;
50316 PyObject * obj3 = 0 ;
50317 PyObject * obj4 = 0 ;
50318 PyObject * obj5 = 0 ;
50319 PyObject * obj6 = 0 ;
50320 char * kwnames[] = {
50321 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50322 };
50323
50324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50326 if (!SWIG_IsOK(res1)) {
50327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50328 }
50329 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50330 arg2 = obj1;
50331 {
50332 arg3 = &temp3;
50333 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50334 }
50335 if (obj3) {
50336 {
50337 arg4 = &temp4;
50338 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50339 }
50340 }
50341 if (obj4) {
50342 ecode5 = SWIG_AsVal_int(obj4, &val5);
50343 if (!SWIG_IsOK(ecode5)) {
50344 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50345 }
50346 arg5 = static_cast< int >(val5);
50347 }
50348 if (obj5) {
50349 ecode6 = SWIG_AsVal_int(obj5, &val6);
50350 if (!SWIG_IsOK(ecode6)) {
50351 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50352 }
50353 arg6 = static_cast< int >(val6);
50354 }
50355 if (obj6) {
50356 arg7 = obj6;
50357 }
50358 {
50359 PyThreadState* __tstate = wxPyBeginAllowThreads();
50360 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50361 wxPyEndAllowThreads(__tstate);
50362 if (PyErr_Occurred()) SWIG_fail;
50363 }
50364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50365 return resultobj;
50366 fail:
50367 return NULL;
50368 }
50369
50370
50371 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50372 PyObject *resultobj = 0;
50373 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50374 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50375 wxGBSizerItem *result = 0 ;
50376 void *argp1 = 0 ;
50377 int res1 = 0 ;
50378 int res2 = 0 ;
50379 PyObject * obj0 = 0 ;
50380 PyObject * obj1 = 0 ;
50381 char * kwnames[] = {
50382 (char *) "self",(char *) "item", NULL
50383 };
50384
50385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50387 if (!SWIG_IsOK(res1)) {
50388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50389 }
50390 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50391 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50392 if (!SWIG_IsOK(res2)) {
50393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50394 }
50395 {
50396 PyThreadState* __tstate = wxPyBeginAllowThreads();
50397 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50398 wxPyEndAllowThreads(__tstate);
50399 if (PyErr_Occurred()) SWIG_fail;
50400 }
50401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50402 return resultobj;
50403 fail:
50404 return NULL;
50405 }
50406
50407
50408 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50409 PyObject *resultobj = 0;
50410 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50411 int arg2 ;
50412 int arg3 ;
50413 wxSize result;
50414 void *argp1 = 0 ;
50415 int res1 = 0 ;
50416 int val2 ;
50417 int ecode2 = 0 ;
50418 int val3 ;
50419 int ecode3 = 0 ;
50420 PyObject * obj0 = 0 ;
50421 PyObject * obj1 = 0 ;
50422 PyObject * obj2 = 0 ;
50423 char * kwnames[] = {
50424 (char *) "self",(char *) "row",(char *) "col", NULL
50425 };
50426
50427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50429 if (!SWIG_IsOK(res1)) {
50430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50431 }
50432 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50433 ecode2 = SWIG_AsVal_int(obj1, &val2);
50434 if (!SWIG_IsOK(ecode2)) {
50435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50436 }
50437 arg2 = static_cast< int >(val2);
50438 ecode3 = SWIG_AsVal_int(obj2, &val3);
50439 if (!SWIG_IsOK(ecode3)) {
50440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50441 }
50442 arg3 = static_cast< int >(val3);
50443 {
50444 PyThreadState* __tstate = wxPyBeginAllowThreads();
50445 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50446 wxPyEndAllowThreads(__tstate);
50447 if (PyErr_Occurred()) SWIG_fail;
50448 }
50449 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50450 return resultobj;
50451 fail:
50452 return NULL;
50453 }
50454
50455
50456 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50457 PyObject *resultobj = 0;
50458 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50459 wxSize result;
50460 void *argp1 = 0 ;
50461 int res1 = 0 ;
50462 PyObject *swig_obj[1] ;
50463
50464 if (!args) SWIG_fail;
50465 swig_obj[0] = args;
50466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50467 if (!SWIG_IsOK(res1)) {
50468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50469 }
50470 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50471 {
50472 PyThreadState* __tstate = wxPyBeginAllowThreads();
50473 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50474 wxPyEndAllowThreads(__tstate);
50475 if (PyErr_Occurred()) SWIG_fail;
50476 }
50477 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50478 return resultobj;
50479 fail:
50480 return NULL;
50481 }
50482
50483
50484 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50485 PyObject *resultobj = 0;
50486 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50487 wxSize *arg2 = 0 ;
50488 void *argp1 = 0 ;
50489 int res1 = 0 ;
50490 wxSize temp2 ;
50491 PyObject * obj0 = 0 ;
50492 PyObject * obj1 = 0 ;
50493 char * kwnames[] = {
50494 (char *) "self",(char *) "sz", NULL
50495 };
50496
50497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50499 if (!SWIG_IsOK(res1)) {
50500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50501 }
50502 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50503 {
50504 arg2 = &temp2;
50505 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50506 }
50507 {
50508 PyThreadState* __tstate = wxPyBeginAllowThreads();
50509 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50510 wxPyEndAllowThreads(__tstate);
50511 if (PyErr_Occurred()) SWIG_fail;
50512 }
50513 resultobj = SWIG_Py_Void();
50514 return resultobj;
50515 fail:
50516 return NULL;
50517 }
50518
50519
50520 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50521 PyObject *resultobj = 0;
50522 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50523 wxWindow *arg2 = (wxWindow *) 0 ;
50524 wxGBPosition result;
50525 void *argp1 = 0 ;
50526 int res1 = 0 ;
50527 void *argp2 = 0 ;
50528 int res2 = 0 ;
50529
50530 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50532 if (!SWIG_IsOK(res1)) {
50533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50534 }
50535 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50536 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50537 if (!SWIG_IsOK(res2)) {
50538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50539 }
50540 arg2 = reinterpret_cast< wxWindow * >(argp2);
50541 {
50542 PyThreadState* __tstate = wxPyBeginAllowThreads();
50543 result = (arg1)->GetItemPosition(arg2);
50544 wxPyEndAllowThreads(__tstate);
50545 if (PyErr_Occurred()) SWIG_fail;
50546 }
50547 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50548 return resultobj;
50549 fail:
50550 return NULL;
50551 }
50552
50553
50554 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50555 PyObject *resultobj = 0;
50556 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50557 wxSizer *arg2 = (wxSizer *) 0 ;
50558 wxGBPosition result;
50559 void *argp1 = 0 ;
50560 int res1 = 0 ;
50561 void *argp2 = 0 ;
50562 int res2 = 0 ;
50563
50564 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50566 if (!SWIG_IsOK(res1)) {
50567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50568 }
50569 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50570 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50571 if (!SWIG_IsOK(res2)) {
50572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50573 }
50574 arg2 = reinterpret_cast< wxSizer * >(argp2);
50575 {
50576 PyThreadState* __tstate = wxPyBeginAllowThreads();
50577 result = (arg1)->GetItemPosition(arg2);
50578 wxPyEndAllowThreads(__tstate);
50579 if (PyErr_Occurred()) SWIG_fail;
50580 }
50581 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50582 return resultobj;
50583 fail:
50584 return NULL;
50585 }
50586
50587
50588 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50589 PyObject *resultobj = 0;
50590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50591 size_t arg2 ;
50592 wxGBPosition result;
50593 void *argp1 = 0 ;
50594 int res1 = 0 ;
50595 size_t val2 ;
50596 int ecode2 = 0 ;
50597
50598 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50600 if (!SWIG_IsOK(res1)) {
50601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50602 }
50603 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50604 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50605 if (!SWIG_IsOK(ecode2)) {
50606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50607 }
50608 arg2 = static_cast< size_t >(val2);
50609 {
50610 PyThreadState* __tstate = wxPyBeginAllowThreads();
50611 result = (arg1)->GetItemPosition(arg2);
50612 wxPyEndAllowThreads(__tstate);
50613 if (PyErr_Occurred()) SWIG_fail;
50614 }
50615 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50616 return resultobj;
50617 fail:
50618 return NULL;
50619 }
50620
50621
50622 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50623 int argc;
50624 PyObject *argv[3];
50625
50626 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50627 --argc;
50628 if (argc == 2) {
50629 int _v = 0;
50630 {
50631 void *vptr = 0;
50632 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50633 _v = SWIG_CheckState(res);
50634 }
50635 if (!_v) goto check_1;
50636 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50637 }
50638 check_1:
50639
50640 if (argc == 2) {
50641 int _v = 0;
50642 {
50643 void *vptr = 0;
50644 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50645 _v = SWIG_CheckState(res);
50646 }
50647 if (!_v) goto check_2;
50648 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50649 }
50650 check_2:
50651
50652 if (argc == 2) {
50653 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50654 }
50655
50656 fail:
50657 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50658 return NULL;
50659 }
50660
50661
50662 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50663 PyObject *resultobj = 0;
50664 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50665 wxWindow *arg2 = (wxWindow *) 0 ;
50666 wxGBPosition *arg3 = 0 ;
50667 bool result;
50668 void *argp1 = 0 ;
50669 int res1 = 0 ;
50670 void *argp2 = 0 ;
50671 int res2 = 0 ;
50672 wxGBPosition temp3 ;
50673
50674 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50676 if (!SWIG_IsOK(res1)) {
50677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50678 }
50679 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50680 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50681 if (!SWIG_IsOK(res2)) {
50682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50683 }
50684 arg2 = reinterpret_cast< wxWindow * >(argp2);
50685 {
50686 arg3 = &temp3;
50687 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50688 }
50689 {
50690 PyThreadState* __tstate = wxPyBeginAllowThreads();
50691 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50692 wxPyEndAllowThreads(__tstate);
50693 if (PyErr_Occurred()) SWIG_fail;
50694 }
50695 {
50696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50697 }
50698 return resultobj;
50699 fail:
50700 return NULL;
50701 }
50702
50703
50704 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50705 PyObject *resultobj = 0;
50706 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50707 wxSizer *arg2 = (wxSizer *) 0 ;
50708 wxGBPosition *arg3 = 0 ;
50709 bool result;
50710 void *argp1 = 0 ;
50711 int res1 = 0 ;
50712 void *argp2 = 0 ;
50713 int res2 = 0 ;
50714 wxGBPosition temp3 ;
50715
50716 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50718 if (!SWIG_IsOK(res1)) {
50719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50720 }
50721 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50722 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50723 if (!SWIG_IsOK(res2)) {
50724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50725 }
50726 arg2 = reinterpret_cast< wxSizer * >(argp2);
50727 {
50728 arg3 = &temp3;
50729 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50730 }
50731 {
50732 PyThreadState* __tstate = wxPyBeginAllowThreads();
50733 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50734 wxPyEndAllowThreads(__tstate);
50735 if (PyErr_Occurred()) SWIG_fail;
50736 }
50737 {
50738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50739 }
50740 return resultobj;
50741 fail:
50742 return NULL;
50743 }
50744
50745
50746 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50747 PyObject *resultobj = 0;
50748 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50749 size_t arg2 ;
50750 wxGBPosition *arg3 = 0 ;
50751 bool result;
50752 void *argp1 = 0 ;
50753 int res1 = 0 ;
50754 size_t val2 ;
50755 int ecode2 = 0 ;
50756 wxGBPosition temp3 ;
50757
50758 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50760 if (!SWIG_IsOK(res1)) {
50761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50762 }
50763 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50764 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50765 if (!SWIG_IsOK(ecode2)) {
50766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50767 }
50768 arg2 = static_cast< size_t >(val2);
50769 {
50770 arg3 = &temp3;
50771 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50772 }
50773 {
50774 PyThreadState* __tstate = wxPyBeginAllowThreads();
50775 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50776 wxPyEndAllowThreads(__tstate);
50777 if (PyErr_Occurred()) SWIG_fail;
50778 }
50779 {
50780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50781 }
50782 return resultobj;
50783 fail:
50784 return NULL;
50785 }
50786
50787
50788 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50789 int argc;
50790 PyObject *argv[4];
50791
50792 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50793 --argc;
50794 if (argc == 3) {
50795 int _v = 0;
50796 {
50797 void *vptr = 0;
50798 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50799 _v = SWIG_CheckState(res);
50800 }
50801 if (!_v) goto check_1;
50802 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50803 }
50804 check_1:
50805
50806 if (argc == 3) {
50807 int _v = 0;
50808 {
50809 void *vptr = 0;
50810 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50811 _v = SWIG_CheckState(res);
50812 }
50813 if (!_v) goto check_2;
50814 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50815 }
50816 check_2:
50817
50818 if (argc == 3) {
50819 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50820 }
50821
50822 fail:
50823 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50824 return NULL;
50825 }
50826
50827
50828 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50829 PyObject *resultobj = 0;
50830 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50831 wxWindow *arg2 = (wxWindow *) 0 ;
50832 wxGBSpan result;
50833 void *argp1 = 0 ;
50834 int res1 = 0 ;
50835 void *argp2 = 0 ;
50836 int res2 = 0 ;
50837
50838 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50840 if (!SWIG_IsOK(res1)) {
50841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50842 }
50843 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50844 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50845 if (!SWIG_IsOK(res2)) {
50846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50847 }
50848 arg2 = reinterpret_cast< wxWindow * >(argp2);
50849 {
50850 PyThreadState* __tstate = wxPyBeginAllowThreads();
50851 result = (arg1)->GetItemSpan(arg2);
50852 wxPyEndAllowThreads(__tstate);
50853 if (PyErr_Occurred()) SWIG_fail;
50854 }
50855 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50856 return resultobj;
50857 fail:
50858 return NULL;
50859 }
50860
50861
50862 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50863 PyObject *resultobj = 0;
50864 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50865 wxSizer *arg2 = (wxSizer *) 0 ;
50866 wxGBSpan result;
50867 void *argp1 = 0 ;
50868 int res1 = 0 ;
50869 void *argp2 = 0 ;
50870 int res2 = 0 ;
50871
50872 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50874 if (!SWIG_IsOK(res1)) {
50875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50876 }
50877 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50878 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50879 if (!SWIG_IsOK(res2)) {
50880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50881 }
50882 arg2 = reinterpret_cast< wxSizer * >(argp2);
50883 {
50884 PyThreadState* __tstate = wxPyBeginAllowThreads();
50885 result = (arg1)->GetItemSpan(arg2);
50886 wxPyEndAllowThreads(__tstate);
50887 if (PyErr_Occurred()) SWIG_fail;
50888 }
50889 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50890 return resultobj;
50891 fail:
50892 return NULL;
50893 }
50894
50895
50896 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50897 PyObject *resultobj = 0;
50898 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50899 size_t arg2 ;
50900 wxGBSpan result;
50901 void *argp1 = 0 ;
50902 int res1 = 0 ;
50903 size_t val2 ;
50904 int ecode2 = 0 ;
50905
50906 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50908 if (!SWIG_IsOK(res1)) {
50909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50910 }
50911 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50912 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50913 if (!SWIG_IsOK(ecode2)) {
50914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50915 }
50916 arg2 = static_cast< size_t >(val2);
50917 {
50918 PyThreadState* __tstate = wxPyBeginAllowThreads();
50919 result = (arg1)->GetItemSpan(arg2);
50920 wxPyEndAllowThreads(__tstate);
50921 if (PyErr_Occurred()) SWIG_fail;
50922 }
50923 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50924 return resultobj;
50925 fail:
50926 return NULL;
50927 }
50928
50929
50930 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50931 int argc;
50932 PyObject *argv[3];
50933
50934 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50935 --argc;
50936 if (argc == 2) {
50937 int _v = 0;
50938 {
50939 void *vptr = 0;
50940 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50941 _v = SWIG_CheckState(res);
50942 }
50943 if (!_v) goto check_1;
50944 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50945 }
50946 check_1:
50947
50948 if (argc == 2) {
50949 int _v = 0;
50950 {
50951 void *vptr = 0;
50952 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50953 _v = SWIG_CheckState(res);
50954 }
50955 if (!_v) goto check_2;
50956 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50957 }
50958 check_2:
50959
50960 if (argc == 2) {
50961 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50962 }
50963
50964 fail:
50965 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50966 return NULL;
50967 }
50968
50969
50970 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50971 PyObject *resultobj = 0;
50972 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50973 wxWindow *arg2 = (wxWindow *) 0 ;
50974 wxGBSpan *arg3 = 0 ;
50975 bool result;
50976 void *argp1 = 0 ;
50977 int res1 = 0 ;
50978 void *argp2 = 0 ;
50979 int res2 = 0 ;
50980 wxGBSpan temp3 ;
50981
50982 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50984 if (!SWIG_IsOK(res1)) {
50985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50986 }
50987 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50988 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50989 if (!SWIG_IsOK(res2)) {
50990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50991 }
50992 arg2 = reinterpret_cast< wxWindow * >(argp2);
50993 {
50994 arg3 = &temp3;
50995 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50996 }
50997 {
50998 PyThreadState* __tstate = wxPyBeginAllowThreads();
50999 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51000 wxPyEndAllowThreads(__tstate);
51001 if (PyErr_Occurred()) SWIG_fail;
51002 }
51003 {
51004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51005 }
51006 return resultobj;
51007 fail:
51008 return NULL;
51009 }
51010
51011
51012 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51013 PyObject *resultobj = 0;
51014 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51015 wxSizer *arg2 = (wxSizer *) 0 ;
51016 wxGBSpan *arg3 = 0 ;
51017 bool result;
51018 void *argp1 = 0 ;
51019 int res1 = 0 ;
51020 void *argp2 = 0 ;
51021 int res2 = 0 ;
51022 wxGBSpan temp3 ;
51023
51024 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51026 if (!SWIG_IsOK(res1)) {
51027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51028 }
51029 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51030 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51031 if (!SWIG_IsOK(res2)) {
51032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51033 }
51034 arg2 = reinterpret_cast< wxSizer * >(argp2);
51035 {
51036 arg3 = &temp3;
51037 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51038 }
51039 {
51040 PyThreadState* __tstate = wxPyBeginAllowThreads();
51041 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51042 wxPyEndAllowThreads(__tstate);
51043 if (PyErr_Occurred()) SWIG_fail;
51044 }
51045 {
51046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51047 }
51048 return resultobj;
51049 fail:
51050 return NULL;
51051 }
51052
51053
51054 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51055 PyObject *resultobj = 0;
51056 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51057 size_t arg2 ;
51058 wxGBSpan *arg3 = 0 ;
51059 bool result;
51060 void *argp1 = 0 ;
51061 int res1 = 0 ;
51062 size_t val2 ;
51063 int ecode2 = 0 ;
51064 wxGBSpan temp3 ;
51065
51066 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51068 if (!SWIG_IsOK(res1)) {
51069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51070 }
51071 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51072 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51073 if (!SWIG_IsOK(ecode2)) {
51074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51075 }
51076 arg2 = static_cast< size_t >(val2);
51077 {
51078 arg3 = &temp3;
51079 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51080 }
51081 {
51082 PyThreadState* __tstate = wxPyBeginAllowThreads();
51083 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51084 wxPyEndAllowThreads(__tstate);
51085 if (PyErr_Occurred()) SWIG_fail;
51086 }
51087 {
51088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51089 }
51090 return resultobj;
51091 fail:
51092 return NULL;
51093 }
51094
51095
51096 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51097 int argc;
51098 PyObject *argv[4];
51099
51100 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51101 --argc;
51102 if (argc == 3) {
51103 int _v = 0;
51104 {
51105 void *vptr = 0;
51106 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51107 _v = SWIG_CheckState(res);
51108 }
51109 if (!_v) goto check_1;
51110 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51111 }
51112 check_1:
51113
51114 if (argc == 3) {
51115 int _v = 0;
51116 {
51117 void *vptr = 0;
51118 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51119 _v = SWIG_CheckState(res);
51120 }
51121 if (!_v) goto check_2;
51122 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51123 }
51124 check_2:
51125
51126 if (argc == 3) {
51127 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51128 }
51129
51130 fail:
51131 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51132 return NULL;
51133 }
51134
51135
51136 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51137 PyObject *resultobj = 0;
51138 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51139 wxWindow *arg2 = (wxWindow *) 0 ;
51140 wxGBSizerItem *result = 0 ;
51141 void *argp1 = 0 ;
51142 int res1 = 0 ;
51143 void *argp2 = 0 ;
51144 int res2 = 0 ;
51145
51146 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51148 if (!SWIG_IsOK(res1)) {
51149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51150 }
51151 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51152 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51153 if (!SWIG_IsOK(res2)) {
51154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51155 }
51156 arg2 = reinterpret_cast< wxWindow * >(argp2);
51157 {
51158 PyThreadState* __tstate = wxPyBeginAllowThreads();
51159 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51160 wxPyEndAllowThreads(__tstate);
51161 if (PyErr_Occurred()) SWIG_fail;
51162 }
51163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51164 return resultobj;
51165 fail:
51166 return NULL;
51167 }
51168
51169
51170 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51171 PyObject *resultobj = 0;
51172 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51173 wxSizer *arg2 = (wxSizer *) 0 ;
51174 wxGBSizerItem *result = 0 ;
51175 void *argp1 = 0 ;
51176 int res1 = 0 ;
51177 void *argp2 = 0 ;
51178 int res2 = 0 ;
51179
51180 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51182 if (!SWIG_IsOK(res1)) {
51183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51184 }
51185 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51186 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51187 if (!SWIG_IsOK(res2)) {
51188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51189 }
51190 arg2 = reinterpret_cast< wxSizer * >(argp2);
51191 {
51192 PyThreadState* __tstate = wxPyBeginAllowThreads();
51193 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51194 wxPyEndAllowThreads(__tstate);
51195 if (PyErr_Occurred()) SWIG_fail;
51196 }
51197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51198 return resultobj;
51199 fail:
51200 return NULL;
51201 }
51202
51203
51204 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51205 int argc;
51206 PyObject *argv[3];
51207
51208 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51209 --argc;
51210 if (argc == 2) {
51211 int _v = 0;
51212 {
51213 void *vptr = 0;
51214 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51215 _v = SWIG_CheckState(res);
51216 }
51217 if (!_v) goto check_1;
51218 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51219 }
51220 check_1:
51221
51222 if (argc == 2) {
51223 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51224 }
51225
51226 fail:
51227 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51228 return NULL;
51229 }
51230
51231
51232 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51233 PyObject *resultobj = 0;
51234 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51235 wxGBPosition *arg2 = 0 ;
51236 wxGBSizerItem *result = 0 ;
51237 void *argp1 = 0 ;
51238 int res1 = 0 ;
51239 wxGBPosition temp2 ;
51240 PyObject * obj0 = 0 ;
51241 PyObject * obj1 = 0 ;
51242 char * kwnames[] = {
51243 (char *) "self",(char *) "pos", NULL
51244 };
51245
51246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51248 if (!SWIG_IsOK(res1)) {
51249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51250 }
51251 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51252 {
51253 arg2 = &temp2;
51254 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51255 }
51256 {
51257 PyThreadState* __tstate = wxPyBeginAllowThreads();
51258 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51259 wxPyEndAllowThreads(__tstate);
51260 if (PyErr_Occurred()) SWIG_fail;
51261 }
51262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51263 return resultobj;
51264 fail:
51265 return NULL;
51266 }
51267
51268
51269 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51270 PyObject *resultobj = 0;
51271 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51272 wxPoint *arg2 = 0 ;
51273 wxGBSizerItem *result = 0 ;
51274 void *argp1 = 0 ;
51275 int res1 = 0 ;
51276 wxPoint temp2 ;
51277 PyObject * obj0 = 0 ;
51278 PyObject * obj1 = 0 ;
51279 char * kwnames[] = {
51280 (char *) "self",(char *) "pt", NULL
51281 };
51282
51283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51285 if (!SWIG_IsOK(res1)) {
51286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51287 }
51288 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51289 {
51290 arg2 = &temp2;
51291 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51292 }
51293 {
51294 PyThreadState* __tstate = wxPyBeginAllowThreads();
51295 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51296 wxPyEndAllowThreads(__tstate);
51297 if (PyErr_Occurred()) SWIG_fail;
51298 }
51299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51300 return resultobj;
51301 fail:
51302 return NULL;
51303 }
51304
51305
51306 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51307 PyObject *resultobj = 0;
51308 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51309 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51310 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51311 bool result;
51312 void *argp1 = 0 ;
51313 int res1 = 0 ;
51314 void *argp2 = 0 ;
51315 int res2 = 0 ;
51316 void *argp3 = 0 ;
51317 int res3 = 0 ;
51318 PyObject * obj0 = 0 ;
51319 PyObject * obj1 = 0 ;
51320 PyObject * obj2 = 0 ;
51321 char * kwnames[] = {
51322 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51323 };
51324
51325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51327 if (!SWIG_IsOK(res1)) {
51328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51329 }
51330 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51332 if (!SWIG_IsOK(res2)) {
51333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51334 }
51335 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51336 if (obj2) {
51337 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51338 if (!SWIG_IsOK(res3)) {
51339 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51340 }
51341 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51342 }
51343 {
51344 PyThreadState* __tstate = wxPyBeginAllowThreads();
51345 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51346 wxPyEndAllowThreads(__tstate);
51347 if (PyErr_Occurred()) SWIG_fail;
51348 }
51349 {
51350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51351 }
51352 return resultobj;
51353 fail:
51354 return NULL;
51355 }
51356
51357
51358 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51359 PyObject *resultobj = 0;
51360 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51361 wxGBPosition *arg2 = 0 ;
51362 wxGBSpan *arg3 = 0 ;
51363 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51364 bool result;
51365 void *argp1 = 0 ;
51366 int res1 = 0 ;
51367 wxGBPosition temp2 ;
51368 wxGBSpan temp3 ;
51369 void *argp4 = 0 ;
51370 int res4 = 0 ;
51371 PyObject * obj0 = 0 ;
51372 PyObject * obj1 = 0 ;
51373 PyObject * obj2 = 0 ;
51374 PyObject * obj3 = 0 ;
51375 char * kwnames[] = {
51376 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51377 };
51378
51379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51381 if (!SWIG_IsOK(res1)) {
51382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51383 }
51384 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51385 {
51386 arg2 = &temp2;
51387 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51388 }
51389 {
51390 arg3 = &temp3;
51391 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51392 }
51393 if (obj3) {
51394 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51395 if (!SWIG_IsOK(res4)) {
51396 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51397 }
51398 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51399 }
51400 {
51401 PyThreadState* __tstate = wxPyBeginAllowThreads();
51402 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51403 wxPyEndAllowThreads(__tstate);
51404 if (PyErr_Occurred()) SWIG_fail;
51405 }
51406 {
51407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51408 }
51409 return resultobj;
51410 fail:
51411 return NULL;
51412 }
51413
51414
51415 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51416 PyObject *obj;
51417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51418 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51419 return SWIG_Py_Void();
51420 }
51421
51422 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51423 return SWIG_Python_InitShadowInstance(args);
51424 }
51425
51426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51427 PyObject *resultobj = 0;
51428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51429 wxRelationship arg2 ;
51430 wxWindow *arg3 = (wxWindow *) 0 ;
51431 wxEdge arg4 ;
51432 int arg5 = (int) 0 ;
51433 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51434 void *argp1 = 0 ;
51435 int res1 = 0 ;
51436 int val2 ;
51437 int ecode2 = 0 ;
51438 void *argp3 = 0 ;
51439 int res3 = 0 ;
51440 int val4 ;
51441 int ecode4 = 0 ;
51442 int val5 ;
51443 int ecode5 = 0 ;
51444 int val6 ;
51445 int ecode6 = 0 ;
51446 PyObject * obj0 = 0 ;
51447 PyObject * obj1 = 0 ;
51448 PyObject * obj2 = 0 ;
51449 PyObject * obj3 = 0 ;
51450 PyObject * obj4 = 0 ;
51451 PyObject * obj5 = 0 ;
51452 char * kwnames[] = {
51453 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51454 };
51455
51456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51458 if (!SWIG_IsOK(res1)) {
51459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51460 }
51461 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51462 ecode2 = SWIG_AsVal_int(obj1, &val2);
51463 if (!SWIG_IsOK(ecode2)) {
51464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51465 }
51466 arg2 = static_cast< wxRelationship >(val2);
51467 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51468 if (!SWIG_IsOK(res3)) {
51469 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51470 }
51471 arg3 = reinterpret_cast< wxWindow * >(argp3);
51472 ecode4 = SWIG_AsVal_int(obj3, &val4);
51473 if (!SWIG_IsOK(ecode4)) {
51474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51475 }
51476 arg4 = static_cast< wxEdge >(val4);
51477 if (obj4) {
51478 ecode5 = SWIG_AsVal_int(obj4, &val5);
51479 if (!SWIG_IsOK(ecode5)) {
51480 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51481 }
51482 arg5 = static_cast< int >(val5);
51483 }
51484 if (obj5) {
51485 ecode6 = SWIG_AsVal_int(obj5, &val6);
51486 if (!SWIG_IsOK(ecode6)) {
51487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51488 }
51489 arg6 = static_cast< int >(val6);
51490 }
51491 {
51492 PyThreadState* __tstate = wxPyBeginAllowThreads();
51493 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51494 wxPyEndAllowThreads(__tstate);
51495 if (PyErr_Occurred()) SWIG_fail;
51496 }
51497 resultobj = SWIG_Py_Void();
51498 return resultobj;
51499 fail:
51500 return NULL;
51501 }
51502
51503
51504 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51505 PyObject *resultobj = 0;
51506 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51507 wxWindow *arg2 = (wxWindow *) 0 ;
51508 int arg3 = (int) 0 ;
51509 void *argp1 = 0 ;
51510 int res1 = 0 ;
51511 void *argp2 = 0 ;
51512 int res2 = 0 ;
51513 int val3 ;
51514 int ecode3 = 0 ;
51515 PyObject * obj0 = 0 ;
51516 PyObject * obj1 = 0 ;
51517 PyObject * obj2 = 0 ;
51518 char * kwnames[] = {
51519 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51520 };
51521
51522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51524 if (!SWIG_IsOK(res1)) {
51525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51526 }
51527 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51529 if (!SWIG_IsOK(res2)) {
51530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51531 }
51532 arg2 = reinterpret_cast< wxWindow * >(argp2);
51533 if (obj2) {
51534 ecode3 = SWIG_AsVal_int(obj2, &val3);
51535 if (!SWIG_IsOK(ecode3)) {
51536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51537 }
51538 arg3 = static_cast< int >(val3);
51539 }
51540 {
51541 PyThreadState* __tstate = wxPyBeginAllowThreads();
51542 (arg1)->LeftOf(arg2,arg3);
51543 wxPyEndAllowThreads(__tstate);
51544 if (PyErr_Occurred()) SWIG_fail;
51545 }
51546 resultobj = SWIG_Py_Void();
51547 return resultobj;
51548 fail:
51549 return NULL;
51550 }
51551
51552
51553 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51554 PyObject *resultobj = 0;
51555 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51556 wxWindow *arg2 = (wxWindow *) 0 ;
51557 int arg3 = (int) 0 ;
51558 void *argp1 = 0 ;
51559 int res1 = 0 ;
51560 void *argp2 = 0 ;
51561 int res2 = 0 ;
51562 int val3 ;
51563 int ecode3 = 0 ;
51564 PyObject * obj0 = 0 ;
51565 PyObject * obj1 = 0 ;
51566 PyObject * obj2 = 0 ;
51567 char * kwnames[] = {
51568 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51569 };
51570
51571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51573 if (!SWIG_IsOK(res1)) {
51574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51575 }
51576 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51578 if (!SWIG_IsOK(res2)) {
51579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51580 }
51581 arg2 = reinterpret_cast< wxWindow * >(argp2);
51582 if (obj2) {
51583 ecode3 = SWIG_AsVal_int(obj2, &val3);
51584 if (!SWIG_IsOK(ecode3)) {
51585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51586 }
51587 arg3 = static_cast< int >(val3);
51588 }
51589 {
51590 PyThreadState* __tstate = wxPyBeginAllowThreads();
51591 (arg1)->RightOf(arg2,arg3);
51592 wxPyEndAllowThreads(__tstate);
51593 if (PyErr_Occurred()) SWIG_fail;
51594 }
51595 resultobj = SWIG_Py_Void();
51596 return resultobj;
51597 fail:
51598 return NULL;
51599 }
51600
51601
51602 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51603 PyObject *resultobj = 0;
51604 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51605 wxWindow *arg2 = (wxWindow *) 0 ;
51606 int arg3 = (int) 0 ;
51607 void *argp1 = 0 ;
51608 int res1 = 0 ;
51609 void *argp2 = 0 ;
51610 int res2 = 0 ;
51611 int val3 ;
51612 int ecode3 = 0 ;
51613 PyObject * obj0 = 0 ;
51614 PyObject * obj1 = 0 ;
51615 PyObject * obj2 = 0 ;
51616 char * kwnames[] = {
51617 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51618 };
51619
51620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51622 if (!SWIG_IsOK(res1)) {
51623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51624 }
51625 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51627 if (!SWIG_IsOK(res2)) {
51628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51629 }
51630 arg2 = reinterpret_cast< wxWindow * >(argp2);
51631 if (obj2) {
51632 ecode3 = SWIG_AsVal_int(obj2, &val3);
51633 if (!SWIG_IsOK(ecode3)) {
51634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51635 }
51636 arg3 = static_cast< int >(val3);
51637 }
51638 {
51639 PyThreadState* __tstate = wxPyBeginAllowThreads();
51640 (arg1)->Above(arg2,arg3);
51641 wxPyEndAllowThreads(__tstate);
51642 if (PyErr_Occurred()) SWIG_fail;
51643 }
51644 resultobj = SWIG_Py_Void();
51645 return resultobj;
51646 fail:
51647 return NULL;
51648 }
51649
51650
51651 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51652 PyObject *resultobj = 0;
51653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51654 wxWindow *arg2 = (wxWindow *) 0 ;
51655 int arg3 = (int) 0 ;
51656 void *argp1 = 0 ;
51657 int res1 = 0 ;
51658 void *argp2 = 0 ;
51659 int res2 = 0 ;
51660 int val3 ;
51661 int ecode3 = 0 ;
51662 PyObject * obj0 = 0 ;
51663 PyObject * obj1 = 0 ;
51664 PyObject * obj2 = 0 ;
51665 char * kwnames[] = {
51666 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51667 };
51668
51669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51671 if (!SWIG_IsOK(res1)) {
51672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51673 }
51674 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51676 if (!SWIG_IsOK(res2)) {
51677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51678 }
51679 arg2 = reinterpret_cast< wxWindow * >(argp2);
51680 if (obj2) {
51681 ecode3 = SWIG_AsVal_int(obj2, &val3);
51682 if (!SWIG_IsOK(ecode3)) {
51683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51684 }
51685 arg3 = static_cast< int >(val3);
51686 }
51687 {
51688 PyThreadState* __tstate = wxPyBeginAllowThreads();
51689 (arg1)->Below(arg2,arg3);
51690 wxPyEndAllowThreads(__tstate);
51691 if (PyErr_Occurred()) SWIG_fail;
51692 }
51693 resultobj = SWIG_Py_Void();
51694 return resultobj;
51695 fail:
51696 return NULL;
51697 }
51698
51699
51700 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51701 PyObject *resultobj = 0;
51702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51703 wxWindow *arg2 = (wxWindow *) 0 ;
51704 wxEdge arg3 ;
51705 int arg4 = (int) 0 ;
51706 void *argp1 = 0 ;
51707 int res1 = 0 ;
51708 void *argp2 = 0 ;
51709 int res2 = 0 ;
51710 int val3 ;
51711 int ecode3 = 0 ;
51712 int val4 ;
51713 int ecode4 = 0 ;
51714 PyObject * obj0 = 0 ;
51715 PyObject * obj1 = 0 ;
51716 PyObject * obj2 = 0 ;
51717 PyObject * obj3 = 0 ;
51718 char * kwnames[] = {
51719 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51720 };
51721
51722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51724 if (!SWIG_IsOK(res1)) {
51725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51726 }
51727 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51728 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51729 if (!SWIG_IsOK(res2)) {
51730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51731 }
51732 arg2 = reinterpret_cast< wxWindow * >(argp2);
51733 ecode3 = SWIG_AsVal_int(obj2, &val3);
51734 if (!SWIG_IsOK(ecode3)) {
51735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51736 }
51737 arg3 = static_cast< wxEdge >(val3);
51738 if (obj3) {
51739 ecode4 = SWIG_AsVal_int(obj3, &val4);
51740 if (!SWIG_IsOK(ecode4)) {
51741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51742 }
51743 arg4 = static_cast< int >(val4);
51744 }
51745 {
51746 PyThreadState* __tstate = wxPyBeginAllowThreads();
51747 (arg1)->SameAs(arg2,arg3,arg4);
51748 wxPyEndAllowThreads(__tstate);
51749 if (PyErr_Occurred()) SWIG_fail;
51750 }
51751 resultobj = SWIG_Py_Void();
51752 return resultobj;
51753 fail:
51754 return NULL;
51755 }
51756
51757
51758 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51759 PyObject *resultobj = 0;
51760 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51761 wxWindow *arg2 = (wxWindow *) 0 ;
51762 wxEdge arg3 ;
51763 int arg4 ;
51764 void *argp1 = 0 ;
51765 int res1 = 0 ;
51766 void *argp2 = 0 ;
51767 int res2 = 0 ;
51768 int val3 ;
51769 int ecode3 = 0 ;
51770 int val4 ;
51771 int ecode4 = 0 ;
51772 PyObject * obj0 = 0 ;
51773 PyObject * obj1 = 0 ;
51774 PyObject * obj2 = 0 ;
51775 PyObject * obj3 = 0 ;
51776 char * kwnames[] = {
51777 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51778 };
51779
51780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51782 if (!SWIG_IsOK(res1)) {
51783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51784 }
51785 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51787 if (!SWIG_IsOK(res2)) {
51788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51789 }
51790 arg2 = reinterpret_cast< wxWindow * >(argp2);
51791 ecode3 = SWIG_AsVal_int(obj2, &val3);
51792 if (!SWIG_IsOK(ecode3)) {
51793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51794 }
51795 arg3 = static_cast< wxEdge >(val3);
51796 ecode4 = SWIG_AsVal_int(obj3, &val4);
51797 if (!SWIG_IsOK(ecode4)) {
51798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51799 }
51800 arg4 = static_cast< int >(val4);
51801 {
51802 PyThreadState* __tstate = wxPyBeginAllowThreads();
51803 (arg1)->PercentOf(arg2,arg3,arg4);
51804 wxPyEndAllowThreads(__tstate);
51805 if (PyErr_Occurred()) SWIG_fail;
51806 }
51807 resultobj = SWIG_Py_Void();
51808 return resultobj;
51809 fail:
51810 return NULL;
51811 }
51812
51813
51814 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51815 PyObject *resultobj = 0;
51816 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51817 int arg2 ;
51818 void *argp1 = 0 ;
51819 int res1 = 0 ;
51820 int val2 ;
51821 int ecode2 = 0 ;
51822 PyObject * obj0 = 0 ;
51823 PyObject * obj1 = 0 ;
51824 char * kwnames[] = {
51825 (char *) "self",(char *) "val", NULL
51826 };
51827
51828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51830 if (!SWIG_IsOK(res1)) {
51831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51832 }
51833 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51834 ecode2 = SWIG_AsVal_int(obj1, &val2);
51835 if (!SWIG_IsOK(ecode2)) {
51836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51837 }
51838 arg2 = static_cast< int >(val2);
51839 {
51840 PyThreadState* __tstate = wxPyBeginAllowThreads();
51841 (arg1)->Absolute(arg2);
51842 wxPyEndAllowThreads(__tstate);
51843 if (PyErr_Occurred()) SWIG_fail;
51844 }
51845 resultobj = SWIG_Py_Void();
51846 return resultobj;
51847 fail:
51848 return NULL;
51849 }
51850
51851
51852 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51853 PyObject *resultobj = 0;
51854 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51855 void *argp1 = 0 ;
51856 int res1 = 0 ;
51857 PyObject *swig_obj[1] ;
51858
51859 if (!args) SWIG_fail;
51860 swig_obj[0] = args;
51861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51862 if (!SWIG_IsOK(res1)) {
51863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51864 }
51865 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51866 {
51867 PyThreadState* __tstate = wxPyBeginAllowThreads();
51868 (arg1)->Unconstrained();
51869 wxPyEndAllowThreads(__tstate);
51870 if (PyErr_Occurred()) SWIG_fail;
51871 }
51872 resultobj = SWIG_Py_Void();
51873 return resultobj;
51874 fail:
51875 return NULL;
51876 }
51877
51878
51879 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51880 PyObject *resultobj = 0;
51881 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51882 void *argp1 = 0 ;
51883 int res1 = 0 ;
51884 PyObject *swig_obj[1] ;
51885
51886 if (!args) SWIG_fail;
51887 swig_obj[0] = args;
51888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51889 if (!SWIG_IsOK(res1)) {
51890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51891 }
51892 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51893 {
51894 PyThreadState* __tstate = wxPyBeginAllowThreads();
51895 (arg1)->AsIs();
51896 wxPyEndAllowThreads(__tstate);
51897 if (PyErr_Occurred()) SWIG_fail;
51898 }
51899 resultobj = SWIG_Py_Void();
51900 return resultobj;
51901 fail:
51902 return NULL;
51903 }
51904
51905
51906 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51907 PyObject *resultobj = 0;
51908 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51909 wxWindow *result = 0 ;
51910 void *argp1 = 0 ;
51911 int res1 = 0 ;
51912 PyObject *swig_obj[1] ;
51913
51914 if (!args) SWIG_fail;
51915 swig_obj[0] = args;
51916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51917 if (!SWIG_IsOK(res1)) {
51918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51919 }
51920 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51921 {
51922 PyThreadState* __tstate = wxPyBeginAllowThreads();
51923 result = (wxWindow *)(arg1)->GetOtherWindow();
51924 wxPyEndAllowThreads(__tstate);
51925 if (PyErr_Occurred()) SWIG_fail;
51926 }
51927 {
51928 resultobj = wxPyMake_wxObject(result, 0);
51929 }
51930 return resultobj;
51931 fail:
51932 return NULL;
51933 }
51934
51935
51936 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51937 PyObject *resultobj = 0;
51938 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51939 wxEdge result;
51940 void *argp1 = 0 ;
51941 int res1 = 0 ;
51942 PyObject *swig_obj[1] ;
51943
51944 if (!args) SWIG_fail;
51945 swig_obj[0] = args;
51946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51947 if (!SWIG_IsOK(res1)) {
51948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51949 }
51950 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51951 {
51952 PyThreadState* __tstate = wxPyBeginAllowThreads();
51953 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51954 wxPyEndAllowThreads(__tstate);
51955 if (PyErr_Occurred()) SWIG_fail;
51956 }
51957 resultobj = SWIG_From_int(static_cast< int >(result));
51958 return resultobj;
51959 fail:
51960 return NULL;
51961 }
51962
51963
51964 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51965 PyObject *resultobj = 0;
51966 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51967 wxEdge arg2 ;
51968 void *argp1 = 0 ;
51969 int res1 = 0 ;
51970 int val2 ;
51971 int ecode2 = 0 ;
51972 PyObject * obj0 = 0 ;
51973 PyObject * obj1 = 0 ;
51974 char * kwnames[] = {
51975 (char *) "self",(char *) "which", NULL
51976 };
51977
51978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51980 if (!SWIG_IsOK(res1)) {
51981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51982 }
51983 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51984 ecode2 = SWIG_AsVal_int(obj1, &val2);
51985 if (!SWIG_IsOK(ecode2)) {
51986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51987 }
51988 arg2 = static_cast< wxEdge >(val2);
51989 {
51990 PyThreadState* __tstate = wxPyBeginAllowThreads();
51991 (arg1)->SetEdge(arg2);
51992 wxPyEndAllowThreads(__tstate);
51993 if (PyErr_Occurred()) SWIG_fail;
51994 }
51995 resultobj = SWIG_Py_Void();
51996 return resultobj;
51997 fail:
51998 return NULL;
51999 }
52000
52001
52002 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52003 PyObject *resultobj = 0;
52004 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52005 int arg2 ;
52006 void *argp1 = 0 ;
52007 int res1 = 0 ;
52008 int val2 ;
52009 int ecode2 = 0 ;
52010 PyObject * obj0 = 0 ;
52011 PyObject * obj1 = 0 ;
52012 char * kwnames[] = {
52013 (char *) "self",(char *) "v", NULL
52014 };
52015
52016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52018 if (!SWIG_IsOK(res1)) {
52019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52020 }
52021 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52022 ecode2 = SWIG_AsVal_int(obj1, &val2);
52023 if (!SWIG_IsOK(ecode2)) {
52024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52025 }
52026 arg2 = static_cast< int >(val2);
52027 {
52028 PyThreadState* __tstate = wxPyBeginAllowThreads();
52029 (arg1)->SetValue(arg2);
52030 wxPyEndAllowThreads(__tstate);
52031 if (PyErr_Occurred()) SWIG_fail;
52032 }
52033 resultobj = SWIG_Py_Void();
52034 return resultobj;
52035 fail:
52036 return NULL;
52037 }
52038
52039
52040 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52041 PyObject *resultobj = 0;
52042 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52043 int result;
52044 void *argp1 = 0 ;
52045 int res1 = 0 ;
52046 PyObject *swig_obj[1] ;
52047
52048 if (!args) SWIG_fail;
52049 swig_obj[0] = args;
52050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52051 if (!SWIG_IsOK(res1)) {
52052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52053 }
52054 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52055 {
52056 PyThreadState* __tstate = wxPyBeginAllowThreads();
52057 result = (int)(arg1)->GetMargin();
52058 wxPyEndAllowThreads(__tstate);
52059 if (PyErr_Occurred()) SWIG_fail;
52060 }
52061 resultobj = SWIG_From_int(static_cast< int >(result));
52062 return resultobj;
52063 fail:
52064 return NULL;
52065 }
52066
52067
52068 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52069 PyObject *resultobj = 0;
52070 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52071 int arg2 ;
52072 void *argp1 = 0 ;
52073 int res1 = 0 ;
52074 int val2 ;
52075 int ecode2 = 0 ;
52076 PyObject * obj0 = 0 ;
52077 PyObject * obj1 = 0 ;
52078 char * kwnames[] = {
52079 (char *) "self",(char *) "m", NULL
52080 };
52081
52082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52084 if (!SWIG_IsOK(res1)) {
52085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52086 }
52087 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52088 ecode2 = SWIG_AsVal_int(obj1, &val2);
52089 if (!SWIG_IsOK(ecode2)) {
52090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52091 }
52092 arg2 = static_cast< int >(val2);
52093 {
52094 PyThreadState* __tstate = wxPyBeginAllowThreads();
52095 (arg1)->SetMargin(arg2);
52096 wxPyEndAllowThreads(__tstate);
52097 if (PyErr_Occurred()) SWIG_fail;
52098 }
52099 resultobj = SWIG_Py_Void();
52100 return resultobj;
52101 fail:
52102 return NULL;
52103 }
52104
52105
52106 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52107 PyObject *resultobj = 0;
52108 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52109 int result;
52110 void *argp1 = 0 ;
52111 int res1 = 0 ;
52112 PyObject *swig_obj[1] ;
52113
52114 if (!args) SWIG_fail;
52115 swig_obj[0] = args;
52116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52117 if (!SWIG_IsOK(res1)) {
52118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52119 }
52120 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52121 {
52122 PyThreadState* __tstate = wxPyBeginAllowThreads();
52123 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52124 wxPyEndAllowThreads(__tstate);
52125 if (PyErr_Occurred()) SWIG_fail;
52126 }
52127 resultobj = SWIG_From_int(static_cast< int >(result));
52128 return resultobj;
52129 fail:
52130 return NULL;
52131 }
52132
52133
52134 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52135 PyObject *resultobj = 0;
52136 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52137 int result;
52138 void *argp1 = 0 ;
52139 int res1 = 0 ;
52140 PyObject *swig_obj[1] ;
52141
52142 if (!args) SWIG_fail;
52143 swig_obj[0] = args;
52144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52145 if (!SWIG_IsOK(res1)) {
52146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52147 }
52148 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52149 {
52150 PyThreadState* __tstate = wxPyBeginAllowThreads();
52151 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52152 wxPyEndAllowThreads(__tstate);
52153 if (PyErr_Occurred()) SWIG_fail;
52154 }
52155 resultobj = SWIG_From_int(static_cast< int >(result));
52156 return resultobj;
52157 fail:
52158 return NULL;
52159 }
52160
52161
52162 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52163 PyObject *resultobj = 0;
52164 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52165 int result;
52166 void *argp1 = 0 ;
52167 int res1 = 0 ;
52168 PyObject *swig_obj[1] ;
52169
52170 if (!args) SWIG_fail;
52171 swig_obj[0] = args;
52172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52173 if (!SWIG_IsOK(res1)) {
52174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52175 }
52176 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52177 {
52178 PyThreadState* __tstate = wxPyBeginAllowThreads();
52179 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52180 wxPyEndAllowThreads(__tstate);
52181 if (PyErr_Occurred()) SWIG_fail;
52182 }
52183 resultobj = SWIG_From_int(static_cast< int >(result));
52184 return resultobj;
52185 fail:
52186 return NULL;
52187 }
52188
52189
52190 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52191 PyObject *resultobj = 0;
52192 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52193 bool result;
52194 void *argp1 = 0 ;
52195 int res1 = 0 ;
52196 PyObject *swig_obj[1] ;
52197
52198 if (!args) SWIG_fail;
52199 swig_obj[0] = args;
52200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52201 if (!SWIG_IsOK(res1)) {
52202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52203 }
52204 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52205 {
52206 PyThreadState* __tstate = wxPyBeginAllowThreads();
52207 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52208 wxPyEndAllowThreads(__tstate);
52209 if (PyErr_Occurred()) SWIG_fail;
52210 }
52211 {
52212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52213 }
52214 return resultobj;
52215 fail:
52216 return NULL;
52217 }
52218
52219
52220 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52221 PyObject *resultobj = 0;
52222 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52223 bool arg2 ;
52224 void *argp1 = 0 ;
52225 int res1 = 0 ;
52226 bool val2 ;
52227 int ecode2 = 0 ;
52228 PyObject * obj0 = 0 ;
52229 PyObject * obj1 = 0 ;
52230 char * kwnames[] = {
52231 (char *) "self",(char *) "d", NULL
52232 };
52233
52234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52236 if (!SWIG_IsOK(res1)) {
52237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52238 }
52239 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52240 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52241 if (!SWIG_IsOK(ecode2)) {
52242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52243 }
52244 arg2 = static_cast< bool >(val2);
52245 {
52246 PyThreadState* __tstate = wxPyBeginAllowThreads();
52247 (arg1)->SetDone(arg2);
52248 wxPyEndAllowThreads(__tstate);
52249 if (PyErr_Occurred()) SWIG_fail;
52250 }
52251 resultobj = SWIG_Py_Void();
52252 return resultobj;
52253 fail:
52254 return NULL;
52255 }
52256
52257
52258 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52259 PyObject *resultobj = 0;
52260 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52261 wxRelationship result;
52262 void *argp1 = 0 ;
52263 int res1 = 0 ;
52264 PyObject *swig_obj[1] ;
52265
52266 if (!args) SWIG_fail;
52267 swig_obj[0] = args;
52268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52269 if (!SWIG_IsOK(res1)) {
52270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52271 }
52272 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52273 {
52274 PyThreadState* __tstate = wxPyBeginAllowThreads();
52275 result = (wxRelationship)(arg1)->GetRelationship();
52276 wxPyEndAllowThreads(__tstate);
52277 if (PyErr_Occurred()) SWIG_fail;
52278 }
52279 resultobj = SWIG_From_int(static_cast< int >(result));
52280 return resultobj;
52281 fail:
52282 return NULL;
52283 }
52284
52285
52286 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52287 PyObject *resultobj = 0;
52288 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52289 wxRelationship arg2 ;
52290 void *argp1 = 0 ;
52291 int res1 = 0 ;
52292 int val2 ;
52293 int ecode2 = 0 ;
52294 PyObject * obj0 = 0 ;
52295 PyObject * obj1 = 0 ;
52296 char * kwnames[] = {
52297 (char *) "self",(char *) "r", NULL
52298 };
52299
52300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52302 if (!SWIG_IsOK(res1)) {
52303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52304 }
52305 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52306 ecode2 = SWIG_AsVal_int(obj1, &val2);
52307 if (!SWIG_IsOK(ecode2)) {
52308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52309 }
52310 arg2 = static_cast< wxRelationship >(val2);
52311 {
52312 PyThreadState* __tstate = wxPyBeginAllowThreads();
52313 (arg1)->SetRelationship(arg2);
52314 wxPyEndAllowThreads(__tstate);
52315 if (PyErr_Occurred()) SWIG_fail;
52316 }
52317 resultobj = SWIG_Py_Void();
52318 return resultobj;
52319 fail:
52320 return NULL;
52321 }
52322
52323
52324 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52325 PyObject *resultobj = 0;
52326 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52327 wxWindow *arg2 = (wxWindow *) 0 ;
52328 bool result;
52329 void *argp1 = 0 ;
52330 int res1 = 0 ;
52331 void *argp2 = 0 ;
52332 int res2 = 0 ;
52333 PyObject * obj0 = 0 ;
52334 PyObject * obj1 = 0 ;
52335 char * kwnames[] = {
52336 (char *) "self",(char *) "otherW", NULL
52337 };
52338
52339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52341 if (!SWIG_IsOK(res1)) {
52342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52343 }
52344 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52346 if (!SWIG_IsOK(res2)) {
52347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52348 }
52349 arg2 = reinterpret_cast< wxWindow * >(argp2);
52350 {
52351 PyThreadState* __tstate = wxPyBeginAllowThreads();
52352 result = (bool)(arg1)->ResetIfWin(arg2);
52353 wxPyEndAllowThreads(__tstate);
52354 if (PyErr_Occurred()) SWIG_fail;
52355 }
52356 {
52357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52358 }
52359 return resultobj;
52360 fail:
52361 return NULL;
52362 }
52363
52364
52365 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52366 PyObject *resultobj = 0;
52367 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52368 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52369 wxWindow *arg3 = (wxWindow *) 0 ;
52370 bool result;
52371 void *argp1 = 0 ;
52372 int res1 = 0 ;
52373 void *argp2 = 0 ;
52374 int res2 = 0 ;
52375 void *argp3 = 0 ;
52376 int res3 = 0 ;
52377 PyObject * obj0 = 0 ;
52378 PyObject * obj1 = 0 ;
52379 PyObject * obj2 = 0 ;
52380 char * kwnames[] = {
52381 (char *) "self",(char *) "constraints",(char *) "win", NULL
52382 };
52383
52384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52386 if (!SWIG_IsOK(res1)) {
52387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52388 }
52389 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52391 if (!SWIG_IsOK(res2)) {
52392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52393 }
52394 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52395 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52396 if (!SWIG_IsOK(res3)) {
52397 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52398 }
52399 arg3 = reinterpret_cast< wxWindow * >(argp3);
52400 {
52401 PyThreadState* __tstate = wxPyBeginAllowThreads();
52402 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52403 wxPyEndAllowThreads(__tstate);
52404 if (PyErr_Occurred()) SWIG_fail;
52405 }
52406 {
52407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52408 }
52409 return resultobj;
52410 fail:
52411 return NULL;
52412 }
52413
52414
52415 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52416 PyObject *resultobj = 0;
52417 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52418 wxEdge arg2 ;
52419 wxWindow *arg3 = (wxWindow *) 0 ;
52420 wxWindow *arg4 = (wxWindow *) 0 ;
52421 int result;
52422 void *argp1 = 0 ;
52423 int res1 = 0 ;
52424 int val2 ;
52425 int ecode2 = 0 ;
52426 void *argp3 = 0 ;
52427 int res3 = 0 ;
52428 void *argp4 = 0 ;
52429 int res4 = 0 ;
52430 PyObject * obj0 = 0 ;
52431 PyObject * obj1 = 0 ;
52432 PyObject * obj2 = 0 ;
52433 PyObject * obj3 = 0 ;
52434 char * kwnames[] = {
52435 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52436 };
52437
52438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52440 if (!SWIG_IsOK(res1)) {
52441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52442 }
52443 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52444 ecode2 = SWIG_AsVal_int(obj1, &val2);
52445 if (!SWIG_IsOK(ecode2)) {
52446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52447 }
52448 arg2 = static_cast< wxEdge >(val2);
52449 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52450 if (!SWIG_IsOK(res3)) {
52451 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52452 }
52453 arg3 = reinterpret_cast< wxWindow * >(argp3);
52454 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52455 if (!SWIG_IsOK(res4)) {
52456 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52457 }
52458 arg4 = reinterpret_cast< wxWindow * >(argp4);
52459 {
52460 PyThreadState* __tstate = wxPyBeginAllowThreads();
52461 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52462 wxPyEndAllowThreads(__tstate);
52463 if (PyErr_Occurred()) SWIG_fail;
52464 }
52465 resultobj = SWIG_From_int(static_cast< int >(result));
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52473 PyObject *obj;
52474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52475 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52476 return SWIG_Py_Void();
52477 }
52478
52479 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52480 PyObject *resultobj = 0;
52481 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52482 wxIndividualLayoutConstraint *result = 0 ;
52483 void *argp1 = 0 ;
52484 int res1 = 0 ;
52485 PyObject *swig_obj[1] ;
52486
52487 if (!args) SWIG_fail;
52488 swig_obj[0] = args;
52489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52490 if (!SWIG_IsOK(res1)) {
52491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52492 }
52493 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52494 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52496 return resultobj;
52497 fail:
52498 return NULL;
52499 }
52500
52501
52502 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52503 PyObject *resultobj = 0;
52504 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52505 wxIndividualLayoutConstraint *result = 0 ;
52506 void *argp1 = 0 ;
52507 int res1 = 0 ;
52508 PyObject *swig_obj[1] ;
52509
52510 if (!args) SWIG_fail;
52511 swig_obj[0] = args;
52512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52513 if (!SWIG_IsOK(res1)) {
52514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52515 }
52516 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52517 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52519 return resultobj;
52520 fail:
52521 return NULL;
52522 }
52523
52524
52525 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52526 PyObject *resultobj = 0;
52527 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52528 wxIndividualLayoutConstraint *result = 0 ;
52529 void *argp1 = 0 ;
52530 int res1 = 0 ;
52531 PyObject *swig_obj[1] ;
52532
52533 if (!args) SWIG_fail;
52534 swig_obj[0] = args;
52535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52536 if (!SWIG_IsOK(res1)) {
52537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52538 }
52539 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52540 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52542 return resultobj;
52543 fail:
52544 return NULL;
52545 }
52546
52547
52548 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52549 PyObject *resultobj = 0;
52550 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52551 wxIndividualLayoutConstraint *result = 0 ;
52552 void *argp1 = 0 ;
52553 int res1 = 0 ;
52554 PyObject *swig_obj[1] ;
52555
52556 if (!args) SWIG_fail;
52557 swig_obj[0] = args;
52558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52559 if (!SWIG_IsOK(res1)) {
52560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52561 }
52562 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52563 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52565 return resultobj;
52566 fail:
52567 return NULL;
52568 }
52569
52570
52571 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52572 PyObject *resultobj = 0;
52573 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52574 wxIndividualLayoutConstraint *result = 0 ;
52575 void *argp1 = 0 ;
52576 int res1 = 0 ;
52577 PyObject *swig_obj[1] ;
52578
52579 if (!args) SWIG_fail;
52580 swig_obj[0] = args;
52581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52582 if (!SWIG_IsOK(res1)) {
52583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52584 }
52585 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52586 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52588 return resultobj;
52589 fail:
52590 return NULL;
52591 }
52592
52593
52594 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52595 PyObject *resultobj = 0;
52596 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52597 wxIndividualLayoutConstraint *result = 0 ;
52598 void *argp1 = 0 ;
52599 int res1 = 0 ;
52600 PyObject *swig_obj[1] ;
52601
52602 if (!args) SWIG_fail;
52603 swig_obj[0] = args;
52604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52605 if (!SWIG_IsOK(res1)) {
52606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52607 }
52608 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52609 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52611 return resultobj;
52612 fail:
52613 return NULL;
52614 }
52615
52616
52617 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52618 PyObject *resultobj = 0;
52619 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52620 wxIndividualLayoutConstraint *result = 0 ;
52621 void *argp1 = 0 ;
52622 int res1 = 0 ;
52623 PyObject *swig_obj[1] ;
52624
52625 if (!args) SWIG_fail;
52626 swig_obj[0] = args;
52627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52628 if (!SWIG_IsOK(res1)) {
52629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52630 }
52631 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52632 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52634 return resultobj;
52635 fail:
52636 return NULL;
52637 }
52638
52639
52640 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52641 PyObject *resultobj = 0;
52642 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52643 wxIndividualLayoutConstraint *result = 0 ;
52644 void *argp1 = 0 ;
52645 int res1 = 0 ;
52646 PyObject *swig_obj[1] ;
52647
52648 if (!args) SWIG_fail;
52649 swig_obj[0] = args;
52650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52651 if (!SWIG_IsOK(res1)) {
52652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52653 }
52654 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52655 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52657 return resultobj;
52658 fail:
52659 return NULL;
52660 }
52661
52662
52663 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52664 PyObject *resultobj = 0;
52665 wxLayoutConstraints *result = 0 ;
52666
52667 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52668 {
52669 PyThreadState* __tstate = wxPyBeginAllowThreads();
52670 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52671 wxPyEndAllowThreads(__tstate);
52672 if (PyErr_Occurred()) SWIG_fail;
52673 }
52674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52675 return resultobj;
52676 fail:
52677 return NULL;
52678 }
52679
52680
52681 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52682 PyObject *resultobj = 0;
52683 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52684 void *argp1 = 0 ;
52685 int res1 = 0 ;
52686 PyObject *swig_obj[1] ;
52687
52688 if (!args) SWIG_fail;
52689 swig_obj[0] = args;
52690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52691 if (!SWIG_IsOK(res1)) {
52692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52693 }
52694 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52695 {
52696 PyThreadState* __tstate = wxPyBeginAllowThreads();
52697 delete arg1;
52698
52699 wxPyEndAllowThreads(__tstate);
52700 if (PyErr_Occurred()) SWIG_fail;
52701 }
52702 resultobj = SWIG_Py_Void();
52703 return resultobj;
52704 fail:
52705 return NULL;
52706 }
52707
52708
52709 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52710 PyObject *resultobj = 0;
52711 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52712 wxWindow *arg2 = (wxWindow *) 0 ;
52713 int *arg3 = (int *) 0 ;
52714 bool result;
52715 void *argp1 = 0 ;
52716 int res1 = 0 ;
52717 void *argp2 = 0 ;
52718 int res2 = 0 ;
52719 int temp3 ;
52720 int res3 = SWIG_TMPOBJ ;
52721 PyObject * obj0 = 0 ;
52722 PyObject * obj1 = 0 ;
52723 char * kwnames[] = {
52724 (char *) "self",(char *) "win", NULL
52725 };
52726
52727 arg3 = &temp3;
52728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52730 if (!SWIG_IsOK(res1)) {
52731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52732 }
52733 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52735 if (!SWIG_IsOK(res2)) {
52736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52737 }
52738 arg2 = reinterpret_cast< wxWindow * >(argp2);
52739 {
52740 PyThreadState* __tstate = wxPyBeginAllowThreads();
52741 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52742 wxPyEndAllowThreads(__tstate);
52743 if (PyErr_Occurred()) SWIG_fail;
52744 }
52745 {
52746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52747 }
52748 if (SWIG_IsTmpObj(res3)) {
52749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52750 } else {
52751 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52753 }
52754 return resultobj;
52755 fail:
52756 return NULL;
52757 }
52758
52759
52760 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52761 PyObject *resultobj = 0;
52762 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52763 bool result;
52764 void *argp1 = 0 ;
52765 int res1 = 0 ;
52766 PyObject *swig_obj[1] ;
52767
52768 if (!args) SWIG_fail;
52769 swig_obj[0] = args;
52770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52771 if (!SWIG_IsOK(res1)) {
52772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52773 }
52774 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52775 {
52776 PyThreadState* __tstate = wxPyBeginAllowThreads();
52777 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52778 wxPyEndAllowThreads(__tstate);
52779 if (PyErr_Occurred()) SWIG_fail;
52780 }
52781 {
52782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52783 }
52784 return resultobj;
52785 fail:
52786 return NULL;
52787 }
52788
52789
52790 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52791 PyObject *obj;
52792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52793 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52794 return SWIG_Py_Void();
52795 }
52796
52797 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52798 return SWIG_Python_InitShadowInstance(args);
52799 }
52800
52801 static PyMethodDef SwigMethods[] = {
52802 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52803 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52804 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52805 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52806 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52807 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52808 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52809 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52810 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52812 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52823 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52824 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52825 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52827 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52828 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52829 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52830 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52831 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52832 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52833 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52835 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52841 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52842 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52843 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52844 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52845 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52846 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52847 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52849 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52857 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52858 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52859 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52864 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52865 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52867 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52869 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52871 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52873 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52875 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52877 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52878 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52880 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52882 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52883 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52884 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52885 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52904 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52905 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52906 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52907 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52908 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52909 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52910 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52911 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52913 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52914 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52915 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52920 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52921 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52922 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52923 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52930 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52937 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52938 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52939 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52940 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52942 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52943 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52944 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52946 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52947 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52948 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52949 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52954 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52955 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52956 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52957 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52958 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52959 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52962 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52963 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52964 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52966 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52967 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52969 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52970 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52971 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52972 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52973 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52974 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52975 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52976 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52977 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52978 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52979 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52984 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52990 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52991 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52992 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52993 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52995 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52998 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53000 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53003 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53004 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53005 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53008 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53009 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53010 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53014 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53015 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53016 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53020 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53025 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53026 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53027 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53028 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53029 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53030 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53031 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53038 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53039 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53041 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53042 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53043 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53049 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53050 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53052 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53053 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53054 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53055 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53056 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53057 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53058 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53059 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53061 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53062 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53063 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53064 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53065 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53066 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53067 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53068 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53070 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53079 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53091 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53092 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53107 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53108 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53109 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53110 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53113 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53115 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53117 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53119 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53121 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53124 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53125 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53126 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53127 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53129 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53146 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53147 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53153 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53154 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53155 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53156 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53157 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53158 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53159 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53160 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53161 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53162 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53163 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53164 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53165 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53166 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53167 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53168 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53169 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53170 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53171 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53172 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53173 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53174 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53175 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53176 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53177 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53178 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53179 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53180 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53181 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53182 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53183 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53185 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53186 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53187 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53189 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53190 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53191 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53192 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53195 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53199 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53203 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53204 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53205 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53206 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53208 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53209 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53211 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53213 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53215 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53217 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53218 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53219 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53221 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53222 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53224 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53225 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53226 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53228 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53229 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53230 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53232 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53234 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53235 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53236 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53238 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53240 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53241 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53243 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53244 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53245 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53247 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53248 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53249 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53250 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53251 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53253 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53254 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53257 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53258 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53260 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53261 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53264 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53265 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53267 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53273 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53274 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53275 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53276 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53277 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53278 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53279 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53280 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53281 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53282 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53283 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53284 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53285 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53286 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53287 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53288 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53289 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53290 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53291 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53292 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53293 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53294 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53295 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53296 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53298 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53299 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53300 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53301 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53302 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53303 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53304 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53305 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53306 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53307 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53308 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53309 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53310 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53311 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53312 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53313 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53314 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53315 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53316 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53317 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53318 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53319 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53320 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53321 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53322 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53323 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53324 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53325 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53326 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53327 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53328 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53329 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53331 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53332 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53334 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53335 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53336 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53337 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53339 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53340 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53341 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53342 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53343 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53344 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53345 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53346 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53347 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53349 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53350 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53351 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53352 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53353 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53354 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53355 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53356 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53357 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53358 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53359 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53360 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53361 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53362 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53363 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53364 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53365 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53366 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53367 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53368 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53369 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53370 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53371 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53372 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53373 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53374 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53375 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53376 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53378 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53379 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53382 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53383 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53384 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53385 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53386 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53387 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53389 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53390 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53393 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53394 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53396 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53397 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53399 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53400 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53402 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53403 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53404 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53406 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53408 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53409 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53411 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53412 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53413 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53415 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53416 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53417 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53419 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53420 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53422 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53423 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53424 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53425 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53426 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53429 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53431 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53433 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53434 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53435 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53438 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53439 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53440 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53442 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53443 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53444 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53446 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53447 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53448 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53449 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53450 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53451 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53453 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53454 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53455 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53456 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53457 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53458 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53459 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53460 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53466 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53468 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53470 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53471 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53472 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53473 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53474 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53475 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53477 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53478 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53479 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53481 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53482 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53483 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53484 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53485 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53488 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53489 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53490 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53493 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53494 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53495 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53496 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53497 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53499 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53501 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53504 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53506 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53507 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53509 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53510 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53511 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53513 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53514 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53515 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53517 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53519 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53520 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53521 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53523 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53525 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53527 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53528 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53530 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53531 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53533 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53535 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53536 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53537 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53539 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53541 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53542 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53543 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53545 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53547 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53548 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53549 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53550 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53552 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53554 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53556 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53558 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53559 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53561 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53562 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53563 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53564 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53565 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53566 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53567 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53568 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53570 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53572 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53574 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53576 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53578 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53580 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53581 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53582 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53583 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53584 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53585 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53591 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53592 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53593 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53594 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53595 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53596 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53597 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53599 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53601 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53602 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53604 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53605 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53606 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53607 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53609 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53610 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53611 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53612 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53614 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53615 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53617 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53618 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53619 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53621 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53623 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53624 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53625 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53626 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53627 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53629 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53630 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53631 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53632 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53634 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53635 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53636 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53637 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53638 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53639 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53640 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53641 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53642 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53643 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53645 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53648 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53649 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53650 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53652 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53654 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53656 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53658 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53659 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53669 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53670 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53674 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53675 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53676 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53677 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53678 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53679 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53680 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53681 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53682 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53683 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53684 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53685 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53686 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53687 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53688 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53690 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53691 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53694 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53695 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53700 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53701 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53704 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53705 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53706 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53707 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53710 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53711 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53712 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53714 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53716 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53717 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53718 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53720 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53722 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53724 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53727 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53728 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53729 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53730 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53731 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53732 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53736 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53737 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53738 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53739 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53746 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53752 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53753 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53754 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53755 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53756 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53758 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53768 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53769 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53770 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53771 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53774 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53775 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53776 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53777 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53779 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53780 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53784 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53790 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53791 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53792 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53793 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53795 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53796 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53798 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53801 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53803 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53804 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53805 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53814 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53818 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53819 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53821 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53831 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53832 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53833 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53834 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53838 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53841 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53843 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53846 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53848 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53849 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53852 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53854 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53855 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53856 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53857 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53858 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53863 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53864 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53865 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53867 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53868 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53869 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53871 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53873 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53874 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53875 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53877 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53878 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53881 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53889 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53896 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53904 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53907 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53908 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53921 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53923 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53925 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53926 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53928 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53930 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53931 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53933 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53934 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53935 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53939 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53958 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53959 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53961 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53963 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53964 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53965 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53967 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53968 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53971 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53972 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53974 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53975 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53977 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53980 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53981 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53983 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53985 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53987 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53988 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53990 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53991 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53994 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53996 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53998 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54000 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54003 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54005 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54006 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54007 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54009 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54010 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54011 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54013 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54015 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54016 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54018 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54020 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54021 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54025 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54029 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54030 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54032 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54036 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54038 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54040 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54041 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54042 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54043 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54047 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54048 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54049 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54050 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54052 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54053 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54058 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54059 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54060 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54061 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54062 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54064 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54066 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54068 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54069 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54071 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54073 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54076 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54077 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54078 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54080 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54081 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54082 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54096 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54097 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54098 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54099 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54100 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54101 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54107 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54108 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54112 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54113 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54115 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54116 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54118 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54120 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54121 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54123 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54124 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54125 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54131 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54132 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54133 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54134 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54135 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54136 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54143 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54145 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54146 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54147 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54148 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54149 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54150 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54152 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54156 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54157 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54158 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54159 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54160 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54161 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54162 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54164 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54165 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54166 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54172 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54173 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54174 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54176 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54177 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54178 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54184 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54185 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54186 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54187 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54188 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54192 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54193 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54198 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54199 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54201 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54202 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54207 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54209 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54210 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54211 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54212 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54213 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54218 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54219 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54228 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54229 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54230 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54231 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54234 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54236 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54237 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54238 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54239 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54241 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54246 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54247 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54248 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54249 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54250 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54251 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54252 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54253 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54254 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54255 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54256 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54258 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54259 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54260 { NULL, NULL, 0, NULL }
54261 };
54262
54263
54264 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54265
54266 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54267 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54268 }
54269 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54270 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54271 }
54272 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54273 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54274 }
54275 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54276 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54277 }
54278 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54279 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54280 }
54281 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54282 return (void *)((wxSizer *) ((wxGridSizer *) x));
54283 }
54284 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54285 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54286 }
54287 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54288 return (void *)((wxSizer *) ((wxPySizer *) x));
54289 }
54290 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54291 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54292 }
54293 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54294 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54295 }
54296 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54298 }
54299 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54300 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54301 }
54302 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54303 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54304 }
54305 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54306 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54307 }
54308 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54309 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54310 }
54311 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54312 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54313 }
54314 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54315 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54316 }
54317 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54319 }
54320 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54321 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54322 }
54323 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54324 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54325 }
54326 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54327 return (void *)((wxEvent *) ((wxPyEvent *) x));
54328 }
54329 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54330 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54331 }
54332 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54334 }
54335 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54336 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54337 }
54338 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54339 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54340 }
54341 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54342 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54343 }
54344 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54345 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54346 }
54347 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54348 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54349 }
54350 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54351 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54352 }
54353 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54354 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54355 }
54356 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54357 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54358 }
54359 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54360 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54361 }
54362 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54363 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54364 }
54365 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54366 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54367 }
54368 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54369 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54370 }
54371 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54372 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54373 }
54374 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54375 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54376 }
54377 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54378 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54379 }
54380 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54381 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54382 }
54383 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54384 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54385 }
54386 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54387 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54388 }
54389 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54390 return (void *)((wxEvent *) ((wxShowEvent *) x));
54391 }
54392 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54393 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54394 }
54395 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54396 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54397 }
54398 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54399 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54400 }
54401 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54402 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54403 }
54404 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54405 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54406 }
54407 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54408 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54409 }
54410 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54411 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54412 }
54413 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54414 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54415 }
54416 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54417 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54418 }
54419 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54420 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54421 }
54422 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54423 return (void *)((wxControl *) ((wxControlWithItems *) x));
54424 }
54425 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54426 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54427 }
54428 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54429 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54430 }
54431 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54432 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54433 }
54434 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54435 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54436 }
54437 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54438 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54439 }
54440 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54441 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54442 }
54443 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54444 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54445 }
54446 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54447 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54448 }
54449 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54450 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54451 }
54452 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54453 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54454 }
54455 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54456 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54457 }
54458 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54459 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54460 }
54461 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54462 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54463 }
54464 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54465 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54466 }
54467 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54468 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54469 }
54470 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54471 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54472 }
54473 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54474 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54475 }
54476 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54477 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54478 }
54479 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54480 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54481 }
54482 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54483 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54484 }
54485 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54486 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54487 }
54488 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54489 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54490 }
54491 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54492 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54493 }
54494 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54495 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54496 }
54497 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54498 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54499 }
54500 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54501 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54502 }
54503 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54504 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54505 }
54506 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54507 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54508 }
54509 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54510 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54511 }
54512 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54513 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54514 }
54515 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54516 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54517 }
54518 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54519 return (void *)((wxObject *) ((wxSizerItem *) x));
54520 }
54521 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54522 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54523 }
54524 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54525 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54526 }
54527 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54528 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54529 }
54530 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54531 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54532 }
54533 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54534 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54535 }
54536 static void *_p_wxSizerTo_p_wxObject(void *x) {
54537 return (void *)((wxObject *) ((wxSizer *) x));
54538 }
54539 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54540 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54541 }
54542 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54543 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54544 }
54545 static void *_p_wxEventTo_p_wxObject(void *x) {
54546 return (void *)((wxObject *) ((wxEvent *) x));
54547 }
54548 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54549 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54550 }
54551 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54552 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54553 }
54554 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54555 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54556 }
54557 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54559 }
54560 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54561 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54562 }
54563 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54564 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54565 }
54566 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54567 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54568 }
54569 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54571 }
54572 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54574 }
54575 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54577 }
54578 static void *_p_wxControlTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54580 }
54581 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54583 }
54584 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) ((wxFSFile *) x));
54586 }
54587 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54589 }
54590 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54592 }
54593 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54595 }
54596 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54598 }
54599 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) ((wxMenuItem *) x));
54601 }
54602 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54604 }
54605 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54607 }
54608 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54610 }
54611 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54613 }
54614 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54616 }
54617 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54619 }
54620 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54622 }
54623 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54625 }
54626 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54628 }
54629 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54631 }
54632 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54633 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54634 }
54635 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54636 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54637 }
54638 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54639 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54640 }
54641 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54642 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54643 }
54644 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54645 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54646 }
54647 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54648 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54649 }
54650 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54651 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54652 }
54653 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54654 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54655 }
54656 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54657 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54658 }
54659 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54660 return (void *)((wxObject *) ((wxImageHandler *) x));
54661 }
54662 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54663 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54664 }
54665 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54666 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54667 }
54668 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54669 return (void *)((wxObject *) ((wxEvtHandler *) x));
54670 }
54671 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54672 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54673 }
54674 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54675 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54676 }
54677 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54678 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54679 }
54680 static void *_p_wxImageTo_p_wxObject(void *x) {
54681 return (void *)((wxObject *) ((wxImage *) x));
54682 }
54683 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54684 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54685 }
54686 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54687 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54688 }
54689 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54690 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54691 }
54692 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54693 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54694 }
54695 static void *_p_wxWindowTo_p_wxObject(void *x) {
54696 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54697 }
54698 static void *_p_wxMenuTo_p_wxObject(void *x) {
54699 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54700 }
54701 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54702 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54703 }
54704 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54705 return (void *)((wxObject *) ((wxFileSystem *) x));
54706 }
54707 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54708 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54709 }
54710 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54711 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54712 }
54713 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54714 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54715 }
54716 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54717 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54718 }
54719 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54720 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54721 }
54722 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54723 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54724 }
54725 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54726 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54727 }
54728 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54729 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54730 }
54731 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54732 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54733 }
54734 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54735 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54736 }
54737 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54738 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54739 }
54740 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54741 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54742 }
54743 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54744 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54745 }
54746 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54747 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54748 }
54749 static void *_p_wxControlTo_p_wxWindow(void *x) {
54750 return (void *)((wxWindow *) ((wxControl *) x));
54751 }
54752 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54753 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54754 }
54755 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54756 return (void *)((wxWindow *) ((wxMenuBar *) x));
54757 }
54758 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54759 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54760 }
54761 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54762 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54763 }
54764 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54765 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54766 }
54767 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54768 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54769 }
54770 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54771 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54772 }
54773 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54774 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54775 }
54776 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54777 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54778 }
54779 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54780 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54781 }
54782 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54783 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54784 }
54785 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54786 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54787 }
54788 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54789 return (void *)((wxValidator *) ((wxPyValidator *) x));
54790 }
54791 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54793 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};
54794 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54923
54924 static swig_type_info *swig_type_initial[] = {
54925 &_swigt__p_buffer,
54926 &_swigt__p_char,
54927 &_swigt__p_form_ops_t,
54928 &_swigt__p_int,
54929 &_swigt__p_long,
54930 &_swigt__p_unsigned_char,
54931 &_swigt__p_unsigned_int,
54932 &_swigt__p_unsigned_long,
54933 &_swigt__p_wxANIHandler,
54934 &_swigt__p_wxAcceleratorEntry,
54935 &_swigt__p_wxAcceleratorTable,
54936 &_swigt__p_wxActivateEvent,
54937 &_swigt__p_wxAppTraits,
54938 &_swigt__p_wxArrayString,
54939 &_swigt__p_wxBMPHandler,
54940 &_swigt__p_wxBitmap,
54941 &_swigt__p_wxBoxSizer,
54942 &_swigt__p_wxButton,
54943 &_swigt__p_wxCURHandler,
54944 &_swigt__p_wxCaret,
54945 &_swigt__p_wxChildFocusEvent,
54946 &_swigt__p_wxClipboardTextEvent,
54947 &_swigt__p_wxCloseEvent,
54948 &_swigt__p_wxColour,
54949 &_swigt__p_wxCommandEvent,
54950 &_swigt__p_wxContextMenuEvent,
54951 &_swigt__p_wxControl,
54952 &_swigt__p_wxControlWithItems,
54953 &_swigt__p_wxCursor,
54954 &_swigt__p_wxDC,
54955 &_swigt__p_wxDateEvent,
54956 &_swigt__p_wxDateTime,
54957 &_swigt__p_wxDisplayChangedEvent,
54958 &_swigt__p_wxDropFilesEvent,
54959 &_swigt__p_wxDuplexMode,
54960 &_swigt__p_wxEraseEvent,
54961 &_swigt__p_wxEvent,
54962 &_swigt__p_wxEventLoop,
54963 &_swigt__p_wxEventLoopActivator,
54964 &_swigt__p_wxEvtHandler,
54965 &_swigt__p_wxFSFile,
54966 &_swigt__p_wxFileSystem,
54967 &_swigt__p_wxFileSystemHandler,
54968 &_swigt__p_wxFlexGridSizer,
54969 &_swigt__p_wxFocusEvent,
54970 &_swigt__p_wxFont,
54971 &_swigt__p_wxFrame,
54972 &_swigt__p_wxGBPosition,
54973 &_swigt__p_wxGBSizerItem,
54974 &_swigt__p_wxGBSpan,
54975 &_swigt__p_wxGIFHandler,
54976 &_swigt__p_wxGridBagSizer,
54977 &_swigt__p_wxGridSizer,
54978 &_swigt__p_wxHelpEvent__Origin,
54979 &_swigt__p_wxICOHandler,
54980 &_swigt__p_wxIconizeEvent,
54981 &_swigt__p_wxIdleEvent,
54982 &_swigt__p_wxImage,
54983 &_swigt__p_wxImageHandler,
54984 &_swigt__p_wxImageHistogram,
54985 &_swigt__p_wxImage_HSVValue,
54986 &_swigt__p_wxImage_RGBValue,
54987 &_swigt__p_wxIndividualLayoutConstraint,
54988 &_swigt__p_wxInitDialogEvent,
54989 &_swigt__p_wxInputStream,
54990 &_swigt__p_wxInternetFSHandler,
54991 &_swigt__p_wxItemContainer,
54992 &_swigt__p_wxJPEGHandler,
54993 &_swigt__p_wxKeyEvent,
54994 &_swigt__p_wxLayoutConstraints,
54995 &_swigt__p_wxMaximizeEvent,
54996 &_swigt__p_wxMemoryFSHandler,
54997 &_swigt__p_wxMenu,
54998 &_swigt__p_wxMenuBar,
54999 &_swigt__p_wxMenuBarBase,
55000 &_swigt__p_wxMenuEvent,
55001 &_swigt__p_wxMenuItem,
55002 &_swigt__p_wxMouseCaptureChangedEvent,
55003 &_swigt__p_wxMouseCaptureLostEvent,
55004 &_swigt__p_wxMouseEvent,
55005 &_swigt__p_wxMoveEvent,
55006 &_swigt__p_wxNavigationKeyEvent,
55007 &_swigt__p_wxNcPaintEvent,
55008 &_swigt__p_wxNotifyEvent,
55009 &_swigt__p_wxObject,
55010 &_swigt__p_wxOutputStream,
55011 &_swigt__p_wxPCXHandler,
55012 &_swigt__p_wxPNGHandler,
55013 &_swigt__p_wxPNMHandler,
55014 &_swigt__p_wxPaintEvent,
55015 &_swigt__p_wxPaletteChangedEvent,
55016 &_swigt__p_wxPaperSize,
55017 &_swigt__p_wxPoint,
55018 &_swigt__p_wxPoint2D,
55019 &_swigt__p_wxPropagateOnce,
55020 &_swigt__p_wxPropagationDisabler,
55021 &_swigt__p_wxPyApp,
55022 &_swigt__p_wxPyCommandEvent,
55023 &_swigt__p_wxPyDropTarget,
55024 &_swigt__p_wxPyEvent,
55025 &_swigt__p_wxPyFileSystemHandler,
55026 &_swigt__p_wxPyImageHandler,
55027 &_swigt__p_wxPyInputStream,
55028 &_swigt__p_wxPySizer,
55029 &_swigt__p_wxPyValidator,
55030 &_swigt__p_wxQuantize,
55031 &_swigt__p_wxQueryNewPaletteEvent,
55032 &_swigt__p_wxRealPoint,
55033 &_swigt__p_wxRect,
55034 &_swigt__p_wxRegion,
55035 &_swigt__p_wxScrollEvent,
55036 &_swigt__p_wxScrollWinEvent,
55037 &_swigt__p_wxSetCursorEvent,
55038 &_swigt__p_wxShowEvent,
55039 &_swigt__p_wxSize,
55040 &_swigt__p_wxSizeEvent,
55041 &_swigt__p_wxSizer,
55042 &_swigt__p_wxSizerItem,
55043 &_swigt__p_wxStaticBox,
55044 &_swigt__p_wxStaticBoxSizer,
55045 &_swigt__p_wxStdDialogButtonSizer,
55046 &_swigt__p_wxSysColourChangedEvent,
55047 &_swigt__p_wxTIFFHandler,
55048 &_swigt__p_wxToolTip,
55049 &_swigt__p_wxUpdateUIEvent,
55050 &_swigt__p_wxValidator,
55051 &_swigt__p_wxVisualAttributes,
55052 &_swigt__p_wxWindow,
55053 &_swigt__p_wxWindowCreateEvent,
55054 &_swigt__p_wxWindowDestroyEvent,
55055 &_swigt__p_wxXPMHandler,
55056 &_swigt__p_wxZipFSHandler,
55057 };
55058
55059 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55073 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}};
55074 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55075 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}};
55076 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55077 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}};
55078 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55083 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}};
55084 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55085 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}};
55086 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55095 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}};
55096 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55098 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}};
55099 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55101 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}};
55102 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}};
55103 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55110 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55111 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}};
55112 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55113 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}};
55114 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55117 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}};
55118 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55122 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55125 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}};
55126 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55127 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55128 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55129 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55130 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55135 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55138 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55139 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55140 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55143 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}};
55144 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55145 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55152 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55153 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55154 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55170 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55171 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55172 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55175 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}};
55176 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}};
55177 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55183 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55184 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}};
55185 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55186 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}};
55187 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55191
55192 static swig_cast_info *swig_cast_initial[] = {
55193 _swigc__p_buffer,
55194 _swigc__p_char,
55195 _swigc__p_form_ops_t,
55196 _swigc__p_int,
55197 _swigc__p_long,
55198 _swigc__p_unsigned_char,
55199 _swigc__p_unsigned_int,
55200 _swigc__p_unsigned_long,
55201 _swigc__p_wxANIHandler,
55202 _swigc__p_wxAcceleratorEntry,
55203 _swigc__p_wxAcceleratorTable,
55204 _swigc__p_wxActivateEvent,
55205 _swigc__p_wxAppTraits,
55206 _swigc__p_wxArrayString,
55207 _swigc__p_wxBMPHandler,
55208 _swigc__p_wxBitmap,
55209 _swigc__p_wxBoxSizer,
55210 _swigc__p_wxButton,
55211 _swigc__p_wxCURHandler,
55212 _swigc__p_wxCaret,
55213 _swigc__p_wxChildFocusEvent,
55214 _swigc__p_wxClipboardTextEvent,
55215 _swigc__p_wxCloseEvent,
55216 _swigc__p_wxColour,
55217 _swigc__p_wxCommandEvent,
55218 _swigc__p_wxContextMenuEvent,
55219 _swigc__p_wxControl,
55220 _swigc__p_wxControlWithItems,
55221 _swigc__p_wxCursor,
55222 _swigc__p_wxDC,
55223 _swigc__p_wxDateEvent,
55224 _swigc__p_wxDateTime,
55225 _swigc__p_wxDisplayChangedEvent,
55226 _swigc__p_wxDropFilesEvent,
55227 _swigc__p_wxDuplexMode,
55228 _swigc__p_wxEraseEvent,
55229 _swigc__p_wxEvent,
55230 _swigc__p_wxEventLoop,
55231 _swigc__p_wxEventLoopActivator,
55232 _swigc__p_wxEvtHandler,
55233 _swigc__p_wxFSFile,
55234 _swigc__p_wxFileSystem,
55235 _swigc__p_wxFileSystemHandler,
55236 _swigc__p_wxFlexGridSizer,
55237 _swigc__p_wxFocusEvent,
55238 _swigc__p_wxFont,
55239 _swigc__p_wxFrame,
55240 _swigc__p_wxGBPosition,
55241 _swigc__p_wxGBSizerItem,
55242 _swigc__p_wxGBSpan,
55243 _swigc__p_wxGIFHandler,
55244 _swigc__p_wxGridBagSizer,
55245 _swigc__p_wxGridSizer,
55246 _swigc__p_wxHelpEvent__Origin,
55247 _swigc__p_wxICOHandler,
55248 _swigc__p_wxIconizeEvent,
55249 _swigc__p_wxIdleEvent,
55250 _swigc__p_wxImage,
55251 _swigc__p_wxImageHandler,
55252 _swigc__p_wxImageHistogram,
55253 _swigc__p_wxImage_HSVValue,
55254 _swigc__p_wxImage_RGBValue,
55255 _swigc__p_wxIndividualLayoutConstraint,
55256 _swigc__p_wxInitDialogEvent,
55257 _swigc__p_wxInputStream,
55258 _swigc__p_wxInternetFSHandler,
55259 _swigc__p_wxItemContainer,
55260 _swigc__p_wxJPEGHandler,
55261 _swigc__p_wxKeyEvent,
55262 _swigc__p_wxLayoutConstraints,
55263 _swigc__p_wxMaximizeEvent,
55264 _swigc__p_wxMemoryFSHandler,
55265 _swigc__p_wxMenu,
55266 _swigc__p_wxMenuBar,
55267 _swigc__p_wxMenuBarBase,
55268 _swigc__p_wxMenuEvent,
55269 _swigc__p_wxMenuItem,
55270 _swigc__p_wxMouseCaptureChangedEvent,
55271 _swigc__p_wxMouseCaptureLostEvent,
55272 _swigc__p_wxMouseEvent,
55273 _swigc__p_wxMoveEvent,
55274 _swigc__p_wxNavigationKeyEvent,
55275 _swigc__p_wxNcPaintEvent,
55276 _swigc__p_wxNotifyEvent,
55277 _swigc__p_wxObject,
55278 _swigc__p_wxOutputStream,
55279 _swigc__p_wxPCXHandler,
55280 _swigc__p_wxPNGHandler,
55281 _swigc__p_wxPNMHandler,
55282 _swigc__p_wxPaintEvent,
55283 _swigc__p_wxPaletteChangedEvent,
55284 _swigc__p_wxPaperSize,
55285 _swigc__p_wxPoint,
55286 _swigc__p_wxPoint2D,
55287 _swigc__p_wxPropagateOnce,
55288 _swigc__p_wxPropagationDisabler,
55289 _swigc__p_wxPyApp,
55290 _swigc__p_wxPyCommandEvent,
55291 _swigc__p_wxPyDropTarget,
55292 _swigc__p_wxPyEvent,
55293 _swigc__p_wxPyFileSystemHandler,
55294 _swigc__p_wxPyImageHandler,
55295 _swigc__p_wxPyInputStream,
55296 _swigc__p_wxPySizer,
55297 _swigc__p_wxPyValidator,
55298 _swigc__p_wxQuantize,
55299 _swigc__p_wxQueryNewPaletteEvent,
55300 _swigc__p_wxRealPoint,
55301 _swigc__p_wxRect,
55302 _swigc__p_wxRegion,
55303 _swigc__p_wxScrollEvent,
55304 _swigc__p_wxScrollWinEvent,
55305 _swigc__p_wxSetCursorEvent,
55306 _swigc__p_wxShowEvent,
55307 _swigc__p_wxSize,
55308 _swigc__p_wxSizeEvent,
55309 _swigc__p_wxSizer,
55310 _swigc__p_wxSizerItem,
55311 _swigc__p_wxStaticBox,
55312 _swigc__p_wxStaticBoxSizer,
55313 _swigc__p_wxStdDialogButtonSizer,
55314 _swigc__p_wxSysColourChangedEvent,
55315 _swigc__p_wxTIFFHandler,
55316 _swigc__p_wxToolTip,
55317 _swigc__p_wxUpdateUIEvent,
55318 _swigc__p_wxValidator,
55319 _swigc__p_wxVisualAttributes,
55320 _swigc__p_wxWindow,
55321 _swigc__p_wxWindowCreateEvent,
55322 _swigc__p_wxWindowDestroyEvent,
55323 _swigc__p_wxXPMHandler,
55324 _swigc__p_wxZipFSHandler,
55325 };
55326
55327
55328 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55329
55330 static swig_const_info swig_const_table[] = {
55331 {0, 0, 0, 0.0, 0, 0}};
55332
55333 #ifdef __cplusplus
55334 }
55335 #endif
55336 /* -----------------------------------------------------------------------------
55337 * Type initialization:
55338 * This problem is tough by the requirement that no dynamic
55339 * memory is used. Also, since swig_type_info structures store pointers to
55340 * swig_cast_info structures and swig_cast_info structures store pointers back
55341 * to swig_type_info structures, we need some lookup code at initialization.
55342 * The idea is that swig generates all the structures that are needed.
55343 * The runtime then collects these partially filled structures.
55344 * The SWIG_InitializeModule function takes these initial arrays out of
55345 * swig_module, and does all the lookup, filling in the swig_module.types
55346 * array with the correct data and linking the correct swig_cast_info
55347 * structures together.
55348 *
55349 * The generated swig_type_info structures are assigned staticly to an initial
55350 * array. We just loop though that array, and handle each type individually.
55351 * First we lookup if this type has been already loaded, and if so, use the
55352 * loaded structure instead of the generated one. Then we have to fill in the
55353 * cast linked list. The cast data is initially stored in something like a
55354 * two-dimensional array. Each row corresponds to a type (there are the same
55355 * number of rows as there are in the swig_type_initial array). Each entry in
55356 * a column is one of the swig_cast_info structures for that type.
55357 * The cast_initial array is actually an array of arrays, because each row has
55358 * a variable number of columns. So to actually build the cast linked list,
55359 * we find the array of casts associated with the type, and loop through it
55360 * adding the casts to the list. The one last trick we need to do is making
55361 * sure the type pointer in the swig_cast_info struct is correct.
55362 *
55363 * First off, we lookup the cast->type name to see if it is already loaded.
55364 * There are three cases to handle:
55365 * 1) If the cast->type has already been loaded AND the type we are adding
55366 * casting info to has not been loaded (it is in this module), THEN we
55367 * replace the cast->type pointer with the type pointer that has already
55368 * been loaded.
55369 * 2) If BOTH types (the one we are adding casting info to, and the
55370 * cast->type) are loaded, THEN the cast info has already been loaded by
55371 * the previous module so we just ignore it.
55372 * 3) Finally, if cast->type has not already been loaded, then we add that
55373 * swig_cast_info to the linked list (because the cast->type) pointer will
55374 * be correct.
55375 * ----------------------------------------------------------------------------- */
55376
55377 #ifdef __cplusplus
55378 extern "C" {
55379 #if 0
55380 } /* c-mode */
55381 #endif
55382 #endif
55383
55384 #if 0
55385 #define SWIGRUNTIME_DEBUG
55386 #endif
55387
55388 SWIGRUNTIME void
55389 SWIG_InitializeModule(void *clientdata) {
55390 size_t i;
55391 swig_module_info *module_head;
55392 static int init_run = 0;
55393
55394 clientdata = clientdata;
55395
55396 if (init_run) return;
55397 init_run = 1;
55398
55399 /* Initialize the swig_module */
55400 swig_module.type_initial = swig_type_initial;
55401 swig_module.cast_initial = swig_cast_initial;
55402
55403 /* Try and load any already created modules */
55404 module_head = SWIG_GetModule(clientdata);
55405 if (module_head) {
55406 swig_module.next = module_head->next;
55407 module_head->next = &swig_module;
55408 } else {
55409 /* This is the first module loaded */
55410 swig_module.next = &swig_module;
55411 SWIG_SetModule(clientdata, &swig_module);
55412 }
55413
55414 /* Now work on filling in swig_module.types */
55415 #ifdef SWIGRUNTIME_DEBUG
55416 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55417 #endif
55418 for (i = 0; i < swig_module.size; ++i) {
55419 swig_type_info *type = 0;
55420 swig_type_info *ret;
55421 swig_cast_info *cast;
55422
55423 #ifdef SWIGRUNTIME_DEBUG
55424 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55425 #endif
55426
55427 /* if there is another module already loaded */
55428 if (swig_module.next != &swig_module) {
55429 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55430 }
55431 if (type) {
55432 /* Overwrite clientdata field */
55433 #ifdef SWIGRUNTIME_DEBUG
55434 printf("SWIG_InitializeModule: found type %s\n", type->name);
55435 #endif
55436 if (swig_module.type_initial[i]->clientdata) {
55437 type->clientdata = swig_module.type_initial[i]->clientdata;
55438 #ifdef SWIGRUNTIME_DEBUG
55439 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55440 #endif
55441 }
55442 } else {
55443 type = swig_module.type_initial[i];
55444 }
55445
55446 /* Insert casting types */
55447 cast = swig_module.cast_initial[i];
55448 while (cast->type) {
55449 /* Don't need to add information already in the list */
55450 ret = 0;
55451 #ifdef SWIGRUNTIME_DEBUG
55452 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55453 #endif
55454 if (swig_module.next != &swig_module) {
55455 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55456 #ifdef SWIGRUNTIME_DEBUG
55457 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55458 #endif
55459 }
55460 if (ret) {
55461 if (type == swig_module.type_initial[i]) {
55462 #ifdef SWIGRUNTIME_DEBUG
55463 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55464 #endif
55465 cast->type = ret;
55466 ret = 0;
55467 } else {
55468 /* Check for casting already in the list */
55469 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55470 #ifdef SWIGRUNTIME_DEBUG
55471 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55472 #endif
55473 if (!ocast) ret = 0;
55474 }
55475 }
55476
55477 if (!ret) {
55478 #ifdef SWIGRUNTIME_DEBUG
55479 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55480 #endif
55481 if (type->cast) {
55482 type->cast->prev = cast;
55483 cast->next = type->cast;
55484 }
55485 type->cast = cast;
55486 }
55487 cast++;
55488 }
55489 /* Set entry in modules->types array equal to the type */
55490 swig_module.types[i] = type;
55491 }
55492 swig_module.types[i] = 0;
55493
55494 #ifdef SWIGRUNTIME_DEBUG
55495 printf("**** SWIG_InitializeModule: Cast List ******\n");
55496 for (i = 0; i < swig_module.size; ++i) {
55497 int j = 0;
55498 swig_cast_info *cast = swig_module.cast_initial[i];
55499 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55500 while (cast->type) {
55501 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55502 cast++;
55503 ++j;
55504 }
55505 printf("---- Total casts: %d\n",j);
55506 }
55507 printf("**** SWIG_InitializeModule: Cast List ******\n");
55508 #endif
55509 }
55510
55511 /* This function will propagate the clientdata field of type to
55512 * any new swig_type_info structures that have been added into the list
55513 * of equivalent types. It is like calling
55514 * SWIG_TypeClientData(type, clientdata) a second time.
55515 */
55516 SWIGRUNTIME void
55517 SWIG_PropagateClientData(void) {
55518 size_t i;
55519 swig_cast_info *equiv;
55520 static int init_run = 0;
55521
55522 if (init_run) return;
55523 init_run = 1;
55524
55525 for (i = 0; i < swig_module.size; i++) {
55526 if (swig_module.types[i]->clientdata) {
55527 equiv = swig_module.types[i]->cast;
55528 while (equiv) {
55529 if (!equiv->converter) {
55530 if (equiv->type && !equiv->type->clientdata)
55531 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55532 }
55533 equiv = equiv->next;
55534 }
55535 }
55536 }
55537 }
55538
55539 #ifdef __cplusplus
55540 #if 0
55541 {
55542 /* c-mode */
55543 #endif
55544 }
55545 #endif
55546
55547
55548
55549 #ifdef __cplusplus
55550 extern "C" {
55551 #endif
55552
55553 /* Python-specific SWIG API */
55554 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55555 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55556 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55557
55558 /* -----------------------------------------------------------------------------
55559 * global variable support code.
55560 * ----------------------------------------------------------------------------- */
55561
55562 typedef struct swig_globalvar {
55563 char *name; /* Name of global variable */
55564 PyObject *(*get_attr)(void); /* Return the current value */
55565 int (*set_attr)(PyObject *); /* Set the value */
55566 struct swig_globalvar *next;
55567 } swig_globalvar;
55568
55569 typedef struct swig_varlinkobject {
55570 PyObject_HEAD
55571 swig_globalvar *vars;
55572 } swig_varlinkobject;
55573
55574 SWIGINTERN PyObject *
55575 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55576 return PyString_FromString("<Swig global variables>");
55577 }
55578
55579 SWIGINTERN PyObject *
55580 swig_varlink_str(swig_varlinkobject *v) {
55581 PyObject *str = PyString_FromString("(");
55582 swig_globalvar *var;
55583 for (var = v->vars; var; var=var->next) {
55584 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55585 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55586 }
55587 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55588 return str;
55589 }
55590
55591 SWIGINTERN int
55592 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55593 PyObject *str = swig_varlink_str(v);
55594 fprintf(fp,"Swig global variables ");
55595 fprintf(fp,"%s\n", PyString_AsString(str));
55596 Py_DECREF(str);
55597 return 0;
55598 }
55599
55600 SWIGINTERN void
55601 swig_varlink_dealloc(swig_varlinkobject *v) {
55602 swig_globalvar *var = v->vars;
55603 while (var) {
55604 swig_globalvar *n = var->next;
55605 free(var->name);
55606 free(var);
55607 var = n;
55608 }
55609 }
55610
55611 SWIGINTERN PyObject *
55612 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55613 PyObject *res = NULL;
55614 swig_globalvar *var = v->vars;
55615 while (var) {
55616 if (strcmp(var->name,n) == 0) {
55617 res = (*var->get_attr)();
55618 break;
55619 }
55620 var = var->next;
55621 }
55622 if (res == NULL && !PyErr_Occurred()) {
55623 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55624 }
55625 return res;
55626 }
55627
55628 SWIGINTERN int
55629 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55630 int res = 1;
55631 swig_globalvar *var = v->vars;
55632 while (var) {
55633 if (strcmp(var->name,n) == 0) {
55634 res = (*var->set_attr)(p);
55635 break;
55636 }
55637 var = var->next;
55638 }
55639 if (res == 1 && !PyErr_Occurred()) {
55640 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55641 }
55642 return res;
55643 }
55644
55645 SWIGINTERN PyTypeObject*
55646 swig_varlink_type(void) {
55647 static char varlink__doc__[] = "Swig var link object";
55648 static PyTypeObject varlink_type;
55649 static int type_init = 0;
55650 if (!type_init) {
55651 const PyTypeObject tmp
55652 = {
55653 PyObject_HEAD_INIT(NULL)
55654 0, /* Number of items in variable part (ob_size) */
55655 (char *)"swigvarlink", /* Type name (tp_name) */
55656 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55657 0, /* Itemsize (tp_itemsize) */
55658 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55659 (printfunc) swig_varlink_print, /* Print (tp_print) */
55660 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55661 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55662 0, /* tp_compare */
55663 (reprfunc) swig_varlink_repr, /* tp_repr */
55664 0, /* tp_as_number */
55665 0, /* tp_as_sequence */
55666 0, /* tp_as_mapping */
55667 0, /* tp_hash */
55668 0, /* tp_call */
55669 (reprfunc)swig_varlink_str, /* tp_str */
55670 0, /* tp_getattro */
55671 0, /* tp_setattro */
55672 0, /* tp_as_buffer */
55673 0, /* tp_flags */
55674 varlink__doc__, /* tp_doc */
55675 0, /* tp_traverse */
55676 0, /* tp_clear */
55677 0, /* tp_richcompare */
55678 0, /* tp_weaklistoffset */
55679 #if PY_VERSION_HEX >= 0x02020000
55680 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55681 #endif
55682 #if PY_VERSION_HEX >= 0x02030000
55683 0, /* tp_del */
55684 #endif
55685 #ifdef COUNT_ALLOCS
55686 0,0,0,0 /* tp_alloc -> tp_next */
55687 #endif
55688 };
55689 varlink_type = tmp;
55690 varlink_type.ob_type = &PyType_Type;
55691 type_init = 1;
55692 }
55693 return &varlink_type;
55694 }
55695
55696 /* Create a variable linking object for use later */
55697 SWIGINTERN PyObject *
55698 SWIG_Python_newvarlink(void) {
55699 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55700 if (result) {
55701 result->vars = 0;
55702 }
55703 return ((PyObject*) result);
55704 }
55705
55706 SWIGINTERN void
55707 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55708 swig_varlinkobject *v = (swig_varlinkobject *) p;
55709 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55710 if (gv) {
55711 size_t size = strlen(name)+1;
55712 gv->name = (char *)malloc(size);
55713 if (gv->name) {
55714 strncpy(gv->name,name,size);
55715 gv->get_attr = get_attr;
55716 gv->set_attr = set_attr;
55717 gv->next = v->vars;
55718 }
55719 }
55720 v->vars = gv;
55721 }
55722
55723 SWIGINTERN PyObject *
55724 SWIG_globals() {
55725 static PyObject *_SWIG_globals = 0;
55726 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55727 return _SWIG_globals;
55728 }
55729
55730 /* -----------------------------------------------------------------------------
55731 * constants/methods manipulation
55732 * ----------------------------------------------------------------------------- */
55733
55734 /* Install Constants */
55735 SWIGINTERN void
55736 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55737 PyObject *obj = 0;
55738 size_t i;
55739 for (i = 0; constants[i].type; ++i) {
55740 switch(constants[i].type) {
55741 case SWIG_PY_POINTER:
55742 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55743 break;
55744 case SWIG_PY_BINARY:
55745 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55746 break;
55747 default:
55748 obj = 0;
55749 break;
55750 }
55751 if (obj) {
55752 PyDict_SetItemString(d, constants[i].name, obj);
55753 Py_DECREF(obj);
55754 }
55755 }
55756 }
55757
55758 /* -----------------------------------------------------------------------------*/
55759 /* Fix SwigMethods to carry the callback ptrs when needed */
55760 /* -----------------------------------------------------------------------------*/
55761
55762 SWIGINTERN void
55763 SWIG_Python_FixMethods(PyMethodDef *methods,
55764 swig_const_info *const_table,
55765 swig_type_info **types,
55766 swig_type_info **types_initial) {
55767 size_t i;
55768 for (i = 0; methods[i].ml_name; ++i) {
55769 const char *c = methods[i].ml_doc;
55770 if (c && (c = strstr(c, "swig_ptr: "))) {
55771 int j;
55772 swig_const_info *ci = 0;
55773 const char *name = c + 10;
55774 for (j = 0; const_table[j].type; ++j) {
55775 if (strncmp(const_table[j].name, name,
55776 strlen(const_table[j].name)) == 0) {
55777 ci = &(const_table[j]);
55778 break;
55779 }
55780 }
55781 if (ci) {
55782 size_t shift = (ci->ptype) - types;
55783 swig_type_info *ty = types_initial[shift];
55784 size_t ldoc = (c - methods[i].ml_doc);
55785 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55786 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55787 if (ndoc) {
55788 char *buff = ndoc;
55789 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55790 if (ptr) {
55791 strncpy(buff, methods[i].ml_doc, ldoc);
55792 buff += ldoc;
55793 strncpy(buff, "swig_ptr: ", 10);
55794 buff += 10;
55795 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55796 methods[i].ml_doc = ndoc;
55797 }
55798 }
55799 }
55800 }
55801 }
55802 }
55803
55804 #ifdef __cplusplus
55805 }
55806 #endif
55807
55808 /* -----------------------------------------------------------------------------*
55809 * Partial Init method
55810 * -----------------------------------------------------------------------------*/
55811
55812 #ifdef __cplusplus
55813 extern "C"
55814 #endif
55815 SWIGEXPORT void SWIG_init(void) {
55816 PyObject *m, *d;
55817
55818 /* Fix SwigMethods to carry the callback ptrs when needed */
55819 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55820
55821 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55822 d = PyModule_GetDict(m);
55823
55824 SWIG_InitializeModule(0);
55825 SWIG_InstallConstants(d,swig_const_table);
55826
55827
55828
55829 #ifndef wxPyUSE_EXPORT
55830 // Make our API structure a CObject so other modules can import it
55831 // from this module.
55832 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55833 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55834 Py_XDECREF(cobj);
55835 #endif
55836
55837 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55838 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55839 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55840 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55841 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55842 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55843 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55844 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55845 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55846 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55847 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55848 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55849 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55850 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55851 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55852 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55853 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55854 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55855 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55856 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55857 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55858 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55859 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55860 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55861 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55862 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55863 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55864 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55865 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55866 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55867 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55868 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55869 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55870 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55871 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55872 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55873 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55874 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55875 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55876 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55877 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55878 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55879 SWIG_Python_SetConstant(d, "CB_FILENAME",SWIG_From_int(static_cast< int >(wxCB_FILENAME)));
55880 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55881 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55882 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55883 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55884 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55885 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55886 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55887 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55888 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55889 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55890 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55891 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55892 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55893 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55894 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55895 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55896 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55897 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55898 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55899 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55900 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55901 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55902 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55903 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55904 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55905 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55906 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55907 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55908 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55909 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55910 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55911 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55912 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55913 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55914 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55915 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55916 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55917 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55918 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55919 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55920 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55921 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55922 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55923 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55924 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55925 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55926 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55927 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55928 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55929 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55930 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55931 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55932 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55933 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55934 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55935 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55936 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55937 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55938 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55939 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55940 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55941 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55942 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55943 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55944 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55945 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55946 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55947 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55948 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55949 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55950 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55951 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55952 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55953 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55954 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55955 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55956 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55957 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55958 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55959 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55960 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55961 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55962 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55963 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55964 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55965 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55966 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55967 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55968 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55969 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55970 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55971 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55972 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55973 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55974 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55975 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55976 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55977 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55978 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55979 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55980 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55981 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55982 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55983 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55984 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55985 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55986 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55987 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55988 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55989 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55990 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55991 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55992 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55993 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55994 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55995 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55996 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55997 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55998 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55999 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56000 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56001 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56002 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56003 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56004 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56005 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56006 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56007 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56008 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56009 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56010 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56011 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56012 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56013 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56014 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56015 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56016 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56017 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56018 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56019 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56020 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56021 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56022 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56023 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56024 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56025 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56026 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56027 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56028 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56029 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56030 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56031 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56032 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56033 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56034 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56035 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56036 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56037 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56038 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56039 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56040 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56041 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56042 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56043 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56044 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56045 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56046 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56047 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56048 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56049 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56050 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56051 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56052 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56053 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56054 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56055 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56056 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56057 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56058 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56059 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56060 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56061 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56062 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56063 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56064 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56065 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56066 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56067 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56068 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56069 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56070 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56071 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56072 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56073 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56074 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56075 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56076 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56077 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56078 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56079 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56080 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56081 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56082 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56083 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56084 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56085 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56086 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56087 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56088 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56089 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56090 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56091 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56092 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56093 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56094 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56095 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56096 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56097 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56098 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56099 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56100 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56101 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56102 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56103 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56104 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56105 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56106 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56107 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56108 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56109 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56110 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56111 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56112 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56113 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56114 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56115 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56116 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56117 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56118 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56119 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56120 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56121 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56122 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56123 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56124 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56125 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56126 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56127 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56128 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56129 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56130 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56131 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56132 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56133 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56134 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56135 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56136 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56137 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56138 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56139 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56140 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56141 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56142 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56143 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56144 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56145 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56146 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56147 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56148 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56149 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56150 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56151 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56152 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56153 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56154 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56155 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56156 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56157 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56158 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56159 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56160 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56161 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56162 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56163 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56164 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56165 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56166 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56167 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56168 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56169 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56170 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56171 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56172 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56173 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56174 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56175 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56176 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56177 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56178 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56179 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56180 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56181 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56182 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56183 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56184 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56185 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56186 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56187 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56188 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56189 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56190 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56191 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56192 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56193 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56194 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56195 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56196 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56197 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56198 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56199 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56200 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56201 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56202 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56203 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56204 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56205 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56206 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56207 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56208 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56209 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56210 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56211 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56212 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56213 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56214 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56215 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56216 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56217 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56218 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56219 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56220 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56221 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56222 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56223 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56224 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56225 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56226 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56227 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56228 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56229 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56230 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56231 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56232 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56233 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56234 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56235 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56236 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56237 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56238 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56239 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56240 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56241 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56242 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56243 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56244 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56245 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56246 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56247 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56248 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56249 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56250 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56251 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56252 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56253 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56254 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56255 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56256 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56257 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56258 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56259 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56260 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56261 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56262 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56263 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56264 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56265 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56266 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56267 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56268 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56269 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56270 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56271 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56272 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56273 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56274 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56275 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56276 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56277 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56278 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56279 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56280 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56281 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56282 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56283 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56284 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56285 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56286 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56287 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56288 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56289 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56290 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56291 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56292 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56293 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56294 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56295 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56296 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56297 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56298 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56299 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56300 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56301 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56302 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56303 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56304 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56305 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56306 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56307 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56308 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56309 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56310 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56311 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56312 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56313 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56314 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56315 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56316 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56317 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56318 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56319 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56320 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56321 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56322 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56323 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56324 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56325 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56326 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56327 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56328 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56329 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56330 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56331 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56332 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56333 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56334 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56335 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56336 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56337 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56338 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56339 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56340 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56341 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56342 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56343 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56344 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56345 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56346 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56347 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56348 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56349 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56350 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56351 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56352 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56353 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56354 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56355 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56356 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56357 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56358 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56359 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56360 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56361 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56362 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56363 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56364 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56365 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56366 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56367 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56368 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56369 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56370 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56371 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56372 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56373 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56374 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56375 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56376 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56377 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56378 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56379 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56380 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56381 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56382 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56383 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56384 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56385 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56386 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56387 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56388 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56389 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56390 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56391 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56392 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56393 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56394 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56395 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56396 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56397 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56398 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56399 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56400 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56401 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56402 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56403 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56405 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56406 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56407 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56408 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56409 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56410 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56411 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56412 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56413 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56414 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56415 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56416 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56417 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56418 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56419 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56420 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56421 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56422 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56423 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56424 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56425 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56426 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56427 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56428 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56429 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56430 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56431 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56432 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56433 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56434 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56435 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56436 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56437 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56438 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56439 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56440 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56441 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56442 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56443 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56444 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56445 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56446 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56447 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56448 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56449 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56450 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56451 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56452 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56453 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56454 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56455 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56456 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56457 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56458 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56459 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56460 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56461 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56462 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56463 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56464 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56465 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56466 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56467 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56468 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56469 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56470 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56471 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56472 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56473 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56474 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56475 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56476 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56477 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56478 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56479 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56480 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56481 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56482 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56483 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56484 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56485 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56486 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56487 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56488 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56489 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56490 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56491 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56492 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56493 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56494 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56495 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56496 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56497 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56498 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56499 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56500 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56501 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56502 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56503
56504 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56505
56506
56507 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56508
56509 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56510 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56511 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56512 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56513 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56514 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56515 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56516 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56517 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56518 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56519 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56520 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56521 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56522 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56523 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56524 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56525 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56526 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56527 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56528 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56529 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56530 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56531 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56532 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56533 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56534 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56535 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56536 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56537 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56538 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56539 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56540 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56541 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56542 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56543 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56544 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56545 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56546 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56547 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56548 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56549 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56550 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56551 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56552 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56553 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56554 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56555 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56556 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56557 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56558 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56559 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56560 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56561 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56564 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56565 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56566 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56567 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56568 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56569 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56570 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56571 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56572 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56573 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56574 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56575 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56576 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56577 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56578 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56579 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56580 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56581 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56582 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56583 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56584 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56585 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56586 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56587 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56588 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56589 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56590 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56591 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56592 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56593 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56594 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56595 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56596 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56597 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56598 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56599 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56600 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56601 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56602 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56603 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56604 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56605 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56606 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56607 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56608 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56609 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56610 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56611 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56612 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56613 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56614 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56615 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56616 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56617 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56618 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56619 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56620 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56621 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56622 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56623 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56624 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56625 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56626 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56627 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56628 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56629 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56630 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56631 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56632 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56633 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56634 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56635 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56636 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56637 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56638 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56639 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56640 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56641 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56642 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56643 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56644 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56645 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56646 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56647 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56648 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56649 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56650 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56651 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56652 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56653 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56654 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56655 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56656 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56657 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56658 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56659 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56660 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56661 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56662 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56663 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56664 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56665 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56666 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56667 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56668 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56669 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56670 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56671 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56672 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56673 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56674 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56675 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56676 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56677 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56678 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56679 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56680 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56681 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56682 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56683 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56684 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56685 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56686 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56687 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56688 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56689 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56690 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56691 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56692 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56693 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56694 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56695 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56696 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56697 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56698 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56699 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56700 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56701 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56702 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56703 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56704 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56705 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56706 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56707 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56708 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56709 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56710 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56711 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56712 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56713 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56714 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56715 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56716
56717 // Initialize threading, some globals and such
56718 __wxPyPreStart(d);
56719
56720
56721 // Although these are defined in __version__ they need to be here too so
56722 // that an assert can be done to ensure that the wxPython and the wxWindows
56723 // versions match.
56724 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56725 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56726 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56727
56728 }
56729
wxWidgets (Impactor)