]> 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
added more properties
[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 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 float arg2 ;
4874 float arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 float val2 ;
4878 int ecode2 = 0 ;
4879 float val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_float(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4897 }
4898 arg2 = static_cast< float >(val2);
4899 ecode3 = SWIG_AsVal_float(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4902 }
4903 arg3 = static_cast< float >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->Scale(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "w",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->Set(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 int arg2 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 int val2 ;
4971 int ecode2 = 0 ;
4972 PyObject * obj0 = 0 ;
4973 PyObject * obj1 = 0 ;
4974 char * kwnames[] = {
4975 (char *) "self",(char *) "w", NULL
4976 };
4977
4978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 ecode2 = SWIG_AsVal_int(obj1, &val2);
4985 if (!SWIG_IsOK(ecode2)) {
4986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4987 }
4988 arg2 = static_cast< int >(val2);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetWidth(arg2);
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_Py_Void();
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 int arg2 ;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 int val2 ;
5009 int ecode2 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "h", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5020 }
5021 arg1 = reinterpret_cast< wxSize * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 (arg1)->SetHeight(arg2);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5041 PyObject *resultobj = 0;
5042 wxSize *arg1 = (wxSize *) 0 ;
5043 int result;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 PyObject *swig_obj[1] ;
5047
5048 if (!args) SWIG_fail;
5049 swig_obj[0] = args;
5050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (int)((wxSize const *)arg1)->GetWidth();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_From_int(static_cast< int >(result));
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 int result;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (int)((wxSize const *)arg1)->GetHeight();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_From_int(static_cast< int >(result));
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 bool result;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 PyObject *swig_obj[1] ;
5103
5104 if (!args) SWIG_fail;
5105 swig_obj[0] = args;
5106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 wxSize *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 wxSize temp2 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "size", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 {
5146 arg2 = &temp2;
5147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetDefaults((wxSize const &)*arg2);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 PyObject *result = 0 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (PyObject *)wxSize_Get(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = result;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *obj;
5192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5193 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5194 return SWIG_Py_Void();
5195 }
5196
5197 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 return SWIG_Python_InitShadowInstance(args);
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double arg2 ;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 double val2 ;
5208 int ecode2 = 0 ;
5209 PyObject *swig_obj[2] ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5215 }
5216 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5218 if (!SWIG_IsOK(ecode2)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5220 }
5221 arg2 = static_cast< double >(val2);
5222 if (arg1) (arg1)->x = arg2;
5223
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232 PyObject *resultobj = 0;
5233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5234 double result;
5235 void *argp1 = 0 ;
5236 int res1 = 0 ;
5237 PyObject *swig_obj[1] ;
5238
5239 if (!args) SWIG_fail;
5240 swig_obj[0] = args;
5241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5244 }
5245 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5246 result = (double) ((arg1)->x);
5247 resultobj = SWIG_From_double(static_cast< double >(result));
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 double arg2 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 double val2 ;
5261 int ecode2 = 0 ;
5262 PyObject *swig_obj[2] ;
5263
5264 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5271 if (!SWIG_IsOK(ecode2)) {
5272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5273 }
5274 arg2 = static_cast< double >(val2);
5275 if (arg1) (arg1)->y = arg2;
5276
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 double result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject *swig_obj[1] ;
5291
5292 if (!args) SWIG_fail;
5293 swig_obj[0] = args;
5294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5295 if (!SWIG_IsOK(res1)) {
5296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5297 }
5298 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5299 result = (double) ((arg1)->y);
5300 resultobj = SWIG_From_double(static_cast< double >(result));
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 double arg1 = (double) 0.0 ;
5310 double arg2 = (double) 0.0 ;
5311 wxRealPoint *result = 0 ;
5312 double val1 ;
5313 int ecode1 = 0 ;
5314 double val2 ;
5315 int ecode2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "x",(char *) "y", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5323 if (obj0) {
5324 ecode1 = SWIG_AsVal_double(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5327 }
5328 arg1 = static_cast< double >(val1);
5329 }
5330 if (obj1) {
5331 ecode2 = SWIG_AsVal_double(obj1, &val2);
5332 if (!SWIG_IsOK(ecode2)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5334 }
5335 arg2 = static_cast< double >(val2);
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 PyObject *swig_obj[1] ;
5356
5357 if (!args) SWIG_fail;
5358 swig_obj[0] = args;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 delete arg1;
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 PyObject *arg2 = (PyObject *) 0 ;
5382 bool result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "other", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 arg2 = obj1;
5398 {
5399 result = (bool)wxRealPoint___eq__(arg1,arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5404 }
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj = 0;
5413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5414 PyObject *arg2 = (PyObject *) 0 ;
5415 bool result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "other", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 arg2 = obj1;
5431 {
5432 result = (bool)wxRealPoint___ne__(arg1,arg2);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 wxRealPoint *arg2 = 0 ;
5448 wxRealPoint result;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 wxRealPoint temp2 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "pt", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 {
5465 arg2 = &temp2;
5466 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 wxRealPoint *arg2 = 0 ;
5485 wxRealPoint result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 wxRealPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "pt", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 arg2 = &temp2;
5503 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 double arg2 ;
5522 double arg3 ;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 double val2 ;
5526 int ecode2 = 0 ;
5527 double val3 ;
5528 int ecode3 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "x",(char *) "y", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_double(obj1, &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5545 }
5546 arg2 = static_cast< double >(val2);
5547 ecode3 = SWIG_AsVal_double(obj2, &val3);
5548 if (!SWIG_IsOK(ecode3)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5550 }
5551 arg3 = static_cast< double >(val3);
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 wxRealPoint_Set(arg1,arg2,arg3);
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 resultobj = SWIG_Py_Void();
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 PyObject *resultobj = 0;
5567 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5568 PyObject *result = 0 ;
5569 void *argp1 = 0 ;
5570 int res1 = 0 ;
5571 PyObject *swig_obj[1] ;
5572
5573 if (!args) SWIG_fail;
5574 swig_obj[0] = args;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (PyObject *)wxRealPoint_Get(arg1);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = result;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *obj;
5595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5596 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5597 return SWIG_Py_Void();
5598 }
5599
5600 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 return SWIG_Python_InitShadowInstance(args);
5602 }
5603
5604 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int arg2 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject *swig_obj[2] ;
5613
5614 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 if (arg1) (arg1)->x = arg2;
5626
5627 resultobj = SWIG_Py_Void();
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxPoint *arg1 = (wxPoint *) 0 ;
5637 int result;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5647 }
5648 arg1 = reinterpret_cast< wxPoint * >(argp1);
5649 result = (int) ((arg1)->x);
5650 resultobj = SWIG_From_int(static_cast< int >(result));
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 int arg2 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 int val2 ;
5664 int ecode2 = 0 ;
5665 PyObject *swig_obj[2] ;
5666
5667 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 if (arg1) (arg1)->y = arg2;
5679
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 int result;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxPoint * >(argp1);
5702 result = (int) ((arg1)->y);
5703 resultobj = SWIG_From_int(static_cast< int >(result));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 int arg1 = (int) 0 ;
5713 int arg2 = (int) 0 ;
5714 wxPoint *result = 0 ;
5715 int val1 ;
5716 int ecode1 = 0 ;
5717 int val2 ;
5718 int ecode2 = 0 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 char * kwnames[] = {
5722 (char *) "x",(char *) "y", NULL
5723 };
5724
5725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5726 if (obj0) {
5727 ecode1 = SWIG_AsVal_int(obj0, &val1);
5728 if (!SWIG_IsOK(ecode1)) {
5729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5730 }
5731 arg1 = static_cast< int >(val1);
5732 }
5733 if (obj1) {
5734 ecode2 = SWIG_AsVal_int(obj1, &val2);
5735 if (!SWIG_IsOK(ecode2)) {
5736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5737 }
5738 arg2 = static_cast< int >(val2);
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxPoint *)new wxPoint(arg1,arg2);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 PyObject *swig_obj[1] ;
5759
5760 if (!args) SWIG_fail;
5761 swig_obj[0] = args;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 delete arg1;
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 PyObject *arg2 = (PyObject *) 0 ;
5785 bool result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "other", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 arg2 = obj1;
5801 {
5802 result = (bool)wxPoint___eq__(arg1,arg2);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 PyObject *arg2 = (PyObject *) 0 ;
5818 bool result;
5819 void *argp1 = 0 ;
5820 int res1 = 0 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "other", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 arg2 = obj1;
5834 {
5835 result = (bool)wxPoint___ne__(arg1,arg2);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 wxPoint *arg2 = 0 ;
5851 wxPoint result;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 wxPoint temp2 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "pt", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (arg1)->operator +((wxPoint const &)*arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint result;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = (arg1)->operator -((wxPoint const &)*arg2);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj = 0;
5923 wxPoint *arg1 = (wxPoint *) 0 ;
5924 wxPoint *arg2 = 0 ;
5925 wxPoint *result = 0 ;
5926 void *argp1 = 0 ;
5927 int res1 = 0 ;
5928 wxPoint temp2 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "self",(char *) "pt", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5937 if (!SWIG_IsOK(res1)) {
5938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5939 }
5940 arg1 = reinterpret_cast< wxPoint * >(argp1);
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 {
5948 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5949 result = (wxPoint *) &_result_ref;
5950 }
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 wxPoint *arg2 = 0 ;
5965 wxPoint *result = 0 ;
5966 void *argp1 = 0 ;
5967 int res1 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5977 if (!SWIG_IsOK(res1)) {
5978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5979 }
5980 arg1 = reinterpret_cast< wxPoint * >(argp1);
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5989 result = (wxPoint *) &_result_ref;
5990 }
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 long arg2 ;
6005 long arg3 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 long val2 ;
6009 int ecode2 = 0 ;
6010 long val3 ;
6011 int ecode3 = 0 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6023 }
6024 arg1 = reinterpret_cast< wxPoint * >(argp1);
6025 ecode2 = SWIG_AsVal_long(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6028 }
6029 arg2 = static_cast< long >(val2);
6030 ecode3 = SWIG_AsVal_long(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6033 }
6034 arg3 = static_cast< long >(val3);
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxPoint_Set(arg1,arg2,arg3);
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_Py_Void();
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 PyObject *result = 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055
6056 if (!args) SWIG_fail;
6057 swig_obj[0] = args;
6058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6059 if (!SWIG_IsOK(res1)) {
6060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6061 }
6062 arg1 = reinterpret_cast< wxPoint * >(argp1);
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (PyObject *)wxPoint_Get(arg1);
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = result;
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6077 PyObject *obj;
6078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6080 return SWIG_Py_Void();
6081 }
6082
6083 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 return SWIG_Python_InitShadowInstance(args);
6085 }
6086
6087 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 int arg1 = (int) 0 ;
6090 int arg2 = (int) 0 ;
6091 int arg3 = (int) 0 ;
6092 int arg4 = (int) 0 ;
6093 wxRect *result = 0 ;
6094 int val1 ;
6095 int ecode1 = 0 ;
6096 int val2 ;
6097 int ecode2 = 0 ;
6098 int val3 ;
6099 int ecode3 = 0 ;
6100 int val4 ;
6101 int ecode4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 if (obj0) {
6112 ecode1 = SWIG_AsVal_int(obj0, &val1);
6113 if (!SWIG_IsOK(ecode1)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6115 }
6116 arg1 = static_cast< int >(val1);
6117 }
6118 if (obj1) {
6119 ecode2 = SWIG_AsVal_int(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6122 }
6123 arg2 = static_cast< int >(val2);
6124 }
6125 if (obj2) {
6126 ecode3 = SWIG_AsVal_int(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6129 }
6130 arg3 = static_cast< int >(val3);
6131 }
6132 if (obj3) {
6133 ecode4 = SWIG_AsVal_int(obj3, &val4);
6134 if (!SWIG_IsOK(ecode4)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6136 }
6137 arg4 = static_cast< int >(val4);
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxPoint *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxPoint temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "topLeft",(char *) "bottomRight", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxPoint *arg1 = 0 ;
6190 wxSize *arg2 = 0 ;
6191 wxRect *result = 0 ;
6192 wxPoint temp1 ;
6193 wxSize temp2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "pos",(char *) "size", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6201 {
6202 arg1 = &temp1;
6203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxSize *arg1 = 0 ;
6225 wxRect *result = 0 ;
6226 wxSize temp1 ;
6227 PyObject * obj0 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "size", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6233 {
6234 arg1 = &temp1;
6235 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 PyObject *swig_obj[1] ;
6285
6286 if (!args) SWIG_fail;
6287 swig_obj[0] = args;
6288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6291 }
6292 arg1 = reinterpret_cast< wxRect * >(argp1);
6293 {
6294 PyThreadState* __tstate = wxPyBeginAllowThreads();
6295 result = (int)((wxRect const *)arg1)->GetX();
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 resultobj = SWIG_From_int(static_cast< int >(result));
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj = 0;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 ;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 char * kwnames[] = {
6317 (char *) "self",(char *) "x", NULL
6318 };
6319
6320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6322 if (!SWIG_IsOK(res1)) {
6323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6324 }
6325 arg1 = reinterpret_cast< wxRect * >(argp1);
6326 ecode2 = SWIG_AsVal_int(obj1, &val2);
6327 if (!SWIG_IsOK(ecode2)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6329 }
6330 arg2 = static_cast< int >(val2);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetX(arg2);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_Py_Void();
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (int)(arg1)->GetY();
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_From_int(static_cast< int >(result));
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 int val2 ;
6379 int ecode2 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "y", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6390 }
6391 arg1 = reinterpret_cast< wxRect * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->SetY(arg2);
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_Py_Void();
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int result;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 PyObject *swig_obj[1] ;
6417
6418 if (!args) SWIG_fail;
6419 swig_obj[0] = args;
6420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6421 if (!SWIG_IsOK(res1)) {
6422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6423 }
6424 arg1 = reinterpret_cast< wxRect * >(argp1);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (int)((wxRect const *)arg1)->GetWidth();
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int(static_cast< int >(result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int arg2 ;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 int val2 ;
6445 int ecode2 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 PyObject * obj1 = 0 ;
6448 char * kwnames[] = {
6449 (char *) "self",(char *) "w", NULL
6450 };
6451
6452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6454 if (!SWIG_IsOK(res1)) {
6455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6456 }
6457 arg1 = reinterpret_cast< wxRect * >(argp1);
6458 ecode2 = SWIG_AsVal_int(obj1, &val2);
6459 if (!SWIG_IsOK(ecode2)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6461 }
6462 arg2 = static_cast< int >(val2);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 (arg1)->SetWidth(arg2);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_Py_Void();
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int result;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (int)((wxRect const *)arg1)->GetHeight();
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int(static_cast< int >(result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 ;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 int val2 ;
6511 int ecode2 = 0 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char * kwnames[] = {
6515 (char *) "self",(char *) "h", NULL
6516 };
6517
6518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6520 if (!SWIG_IsOK(res1)) {
6521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6522 }
6523 arg1 = reinterpret_cast< wxRect * >(argp1);
6524 ecode2 = SWIG_AsVal_int(obj1, &val2);
6525 if (!SWIG_IsOK(ecode2)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6527 }
6528 arg2 = static_cast< int >(val2);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->SetHeight(arg2);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_Py_Void();
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxRect const *)arg1)->GetPosition();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxPoint *arg2 = 0 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 wxPoint temp2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "p", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 arg2 = &temp2;
6591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetPosition((wxPoint const &)*arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxSize result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetSize();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxSize *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxSize temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "s", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetSize((wxSize const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 bool result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxRect const *)arg1)->IsEmpty();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxPoint result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetTopLeft();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxPoint temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "p", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = ((wxRect const *)arg1)->GetBottomRight();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxPoint *arg2 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 wxPoint temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "p", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 arg2 = &temp2;
6813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6814 }
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 int result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = (int)((wxRect const *)arg1)->GetLeft();
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_From_int(static_cast< int >(result));
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 int result;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 PyObject *swig_obj[1] ;
6863
6864 if (!args) SWIG_fail;
6865 swig_obj[0] = args;
6866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxRect * >(argp1);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 result = (int)((wxRect const *)arg1)->GetTop();
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_From_int(static_cast< int >(result));
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 int result;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6897 }
6898 arg1 = reinterpret_cast< wxRect * >(argp1);
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (int)((wxRect const *)arg1)->GetBottom();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_From_int(static_cast< int >(result));
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxRect *arg1 = (wxRect *) 0 ;
6915 int result;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (int)((wxRect const *)arg1)->GetRight();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_From_int(static_cast< int >(result));
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 int arg2 ;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 int val2 ;
6947 int ecode2 = 0 ;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 char * kwnames[] = {
6951 (char *) "self",(char *) "left", NULL
6952 };
6953
6954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6956 if (!SWIG_IsOK(res1)) {
6957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6958 }
6959 arg1 = reinterpret_cast< wxRect * >(argp1);
6960 ecode2 = SWIG_AsVal_int(obj1, &val2);
6961 if (!SWIG_IsOK(ecode2)) {
6962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6963 }
6964 arg2 = static_cast< int >(val2);
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 (arg1)->SetLeft(arg2);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 int arg2 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 int val2 ;
6985 int ecode2 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "self",(char *) "right", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6996 }
6997 arg1 = reinterpret_cast< wxRect * >(argp1);
6998 ecode2 = SWIG_AsVal_int(obj1, &val2);
6999 if (!SWIG_IsOK(ecode2)) {
7000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7001 }
7002 arg2 = static_cast< int >(val2);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 (arg1)->SetRight(arg2);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 int arg2 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "top", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 (arg1)->SetTop(arg2);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj = 0;
7056 wxRect *arg1 = (wxRect *) 0 ;
7057 int arg2 ;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 int val2 ;
7061 int ecode2 = 0 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "bottom", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 ecode2 = SWIG_AsVal_int(obj1, &val2);
7075 if (!SWIG_IsOK(ecode2)) {
7076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7077 }
7078 arg2 = static_cast< int >(val2);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 (arg1)->SetBottom(arg2);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int arg2 ;
7096 int arg3 ;
7097 wxRect *result = 0 ;
7098 void *argp1 = 0 ;
7099 int res1 = 0 ;
7100 int val2 ;
7101 int ecode2 = 0 ;
7102 int val3 ;
7103 int ecode3 = 0 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 PyObject * obj2 = 0 ;
7107 char * kwnames[] = {
7108 (char *) "self",(char *) "dx",(char *) "dy", NULL
7109 };
7110
7111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 ecode2 = SWIG_AsVal_int(obj1, &val2);
7118 if (!SWIG_IsOK(ecode2)) {
7119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7120 }
7121 arg2 = static_cast< int >(val2);
7122 ecode3 = SWIG_AsVal_int(obj2, &val3);
7123 if (!SWIG_IsOK(ecode3)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7125 }
7126 arg3 = static_cast< int >(val3);
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 {
7130 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7131 result = (wxRect *) &_result_ref;
7132 }
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 int arg2 ;
7147 int arg3 ;
7148 wxRect *result = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 int val2 ;
7152 int ecode2 = 0 ;
7153 int val3 ;
7154 int ecode3 = 0 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 PyObject * obj2 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "dx",(char *) "dy", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 ecode3 = SWIG_AsVal_int(obj2, &val3);
7174 if (!SWIG_IsOK(ecode3)) {
7175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7176 }
7177 arg3 = static_cast< int >(val3);
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 {
7181 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7182 result = (wxRect *) &_result_ref;
7183 }
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 int arg2 ;
7198 int arg3 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 int val2 ;
7202 int ecode2 = 0 ;
7203 int val3 ;
7204 int ecode3 = 0 ;
7205 PyObject * obj0 = 0 ;
7206 PyObject * obj1 = 0 ;
7207 PyObject * obj2 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "dx",(char *) "dy", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 ecode2 = SWIG_AsVal_int(obj1, &val2);
7219 if (!SWIG_IsOK(ecode2)) {
7220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7221 }
7222 arg2 = static_cast< int >(val2);
7223 ecode3 = SWIG_AsVal_int(obj2, &val3);
7224 if (!SWIG_IsOK(ecode3)) {
7225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7226 }
7227 arg3 = static_cast< int >(val3);
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Offset(arg2,arg3);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 resultobj = SWIG_Py_Void();
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj = 0;
7243 wxRect *arg1 = (wxRect *) 0 ;
7244 wxPoint *arg2 = 0 ;
7245 void *argp1 = 0 ;
7246 int res1 = 0 ;
7247 wxPoint temp2 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "pt", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 {
7261 arg2 = &temp2;
7262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->Offset((wxPoint const &)*arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 wxRect *arg2 = 0 ;
7281 wxRect result;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 wxRect temp2 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "rect", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 {
7298 arg2 = &temp2;
7299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7300 }
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 result = (arg1)->Intersect((wxRect const &)*arg2);
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = 0;
7316 wxRect *arg1 = (wxRect *) 0 ;
7317 wxRect *arg2 = 0 ;
7318 wxRect result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 wxRect temp2 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char * kwnames[] = {
7325 (char *) "self",(char *) "rect", NULL
7326 };
7327
7328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7332 }
7333 arg1 = reinterpret_cast< wxRect * >(argp1);
7334 {
7335 arg2 = &temp2;
7336 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7337 }
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (arg1)->Union((wxRect const &)*arg2);
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 wxRect *arg2 = 0 ;
7355 wxRect result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 wxRect temp2 ;
7359 PyObject * obj0 = 0 ;
7360 PyObject * obj1 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "rect", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 {
7372 arg2 = &temp2;
7373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = 0;
7390 wxRect *arg1 = (wxRect *) 0 ;
7391 wxRect *arg2 = 0 ;
7392 wxRect *result = 0 ;
7393 void *argp1 = 0 ;
7394 int res1 = 0 ;
7395 wxRect temp2 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "rect", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 {
7409 arg2 = &temp2;
7410 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 {
7415 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7416 result = (wxRect *) &_result_ref;
7417 }
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj = 0;
7430 wxRect *arg1 = (wxRect *) 0 ;
7431 PyObject *arg2 = (PyObject *) 0 ;
7432 bool result;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "other", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 arg2 = obj1;
7448 {
7449 result = (bool)wxRect___eq__(arg1,arg2);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 PyObject *arg2 = (PyObject *) 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 char * kwnames[] = {
7471 (char *) "self",(char *) "other", NULL
7472 };
7473
7474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7478 }
7479 arg1 = reinterpret_cast< wxRect * >(argp1);
7480 arg2 = obj1;
7481 {
7482 result = (bool)wxRect___ne__(arg1,arg2);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxRect *arg1 = (wxRect *) 0 ;
7497 int arg2 ;
7498 int arg3 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 int val3 ;
7505 int ecode3 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "x",(char *) "y", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 ecode2 = SWIG_AsVal_int(obj1, &val2);
7520 if (!SWIG_IsOK(ecode2)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7522 }
7523 arg2 = static_cast< int >(val2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxPoint *arg2 = 0 ;
7548 bool result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxPoint temp2 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "pt", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7562 }
7563 arg1 = reinterpret_cast< wxRect * >(argp1);
7564 {
7565 arg2 = &temp2;
7566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 wxRect *arg2 = 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 wxRect temp2 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "rect", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 {
7604 arg2 = &temp2;
7605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 wxRect *arg2 = 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 wxRect temp2 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "rect", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7640 }
7641 arg1 = reinterpret_cast< wxRect * >(argp1);
7642 {
7643 arg2 = &temp2;
7644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7645 }
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxRect *arg1 = (wxRect *) 0 ;
7664 wxRect *arg2 = 0 ;
7665 int arg3 = (int) wxBOTH ;
7666 wxRect result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 wxRect temp2 ;
7670 int val3 ;
7671 int ecode3 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 PyObject * obj2 = 0 ;
7675 char * kwnames[] = {
7676 (char *) "self",(char *) "r",(char *) "dir", NULL
7677 };
7678
7679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 {
7686 arg2 = &temp2;
7687 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7688 }
7689 if (obj2) {
7690 ecode3 = SWIG_AsVal_int(obj2, &val3);
7691 if (!SWIG_IsOK(ecode3)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7693 }
7694 arg3 = static_cast< int >(val3);
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7710 PyObject *resultobj = 0;
7711 wxRect *arg1 = (wxRect *) 0 ;
7712 int arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 int val2 ;
7716 int ecode2 = 0 ;
7717 PyObject *swig_obj[2] ;
7718
7719 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 if (arg1) (arg1)->x = arg2;
7731
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 int result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 PyObject *swig_obj[1] ;
7746
7747 if (!args) SWIG_fail;
7748 swig_obj[0] = args;
7749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 result = (int) ((arg1)->x);
7755 resultobj = SWIG_From_int(static_cast< int >(result));
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 int arg2 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 int val2 ;
7769 int ecode2 = 0 ;
7770 PyObject *swig_obj[2] ;
7771
7772 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7781 }
7782 arg2 = static_cast< int >(val2);
7783 if (arg1) (arg1)->y = arg2;
7784
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxRect *arg1 = (wxRect *) 0 ;
7795 int result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 PyObject *swig_obj[1] ;
7799
7800 if (!args) SWIG_fail;
7801 swig_obj[0] = args;
7802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7803 if (!SWIG_IsOK(res1)) {
7804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7805 }
7806 arg1 = reinterpret_cast< wxRect * >(argp1);
7807 result = (int) ((arg1)->y);
7808 resultobj = SWIG_From_int(static_cast< int >(result));
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 int val2 ;
7822 int ecode2 = 0 ;
7823 PyObject *swig_obj[2] ;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7834 }
7835 arg2 = static_cast< int >(val2);
7836 if (arg1) (arg1)->width = arg2;
7837
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 PyObject *swig_obj[1] ;
7852
7853 if (!args) SWIG_fail;
7854 swig_obj[0] = args;
7855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7856 if (!SWIG_IsOK(res1)) {
7857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7858 }
7859 arg1 = reinterpret_cast< wxRect * >(argp1);
7860 result = (int) ((arg1)->width);
7861 resultobj = SWIG_From_int(static_cast< int >(result));
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 int arg2 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 int val2 ;
7875 int ecode2 = 0 ;
7876 PyObject *swig_obj[2] ;
7877
7878 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7882 }
7883 arg1 = reinterpret_cast< wxRect * >(argp1);
7884 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7887 }
7888 arg2 = static_cast< int >(val2);
7889 if (arg1) (arg1)->height = arg2;
7890
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int result;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7911 }
7912 arg1 = reinterpret_cast< wxRect * >(argp1);
7913 result = (int) ((arg1)->height);
7914 resultobj = SWIG_From_int(static_cast< int >(result));
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = 0;
7923 wxRect *arg1 = (wxRect *) 0 ;
7924 int arg2 = (int) 0 ;
7925 int arg3 = (int) 0 ;
7926 int arg4 = (int) 0 ;
7927 int arg5 = (int) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 int val2 ;
7931 int ecode2 = 0 ;
7932 int val3 ;
7933 int ecode3 = 0 ;
7934 int val4 ;
7935 int ecode4 = 0 ;
7936 int val5 ;
7937 int ecode5 = 0 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 PyObject * obj2 = 0 ;
7941 PyObject * obj3 = 0 ;
7942 PyObject * obj4 = 0 ;
7943 char * kwnames[] = {
7944 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7945 };
7946
7947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7949 if (!SWIG_IsOK(res1)) {
7950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7951 }
7952 arg1 = reinterpret_cast< wxRect * >(argp1);
7953 if (obj1) {
7954 ecode2 = SWIG_AsVal_int(obj1, &val2);
7955 if (!SWIG_IsOK(ecode2)) {
7956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7957 }
7958 arg2 = static_cast< int >(val2);
7959 }
7960 if (obj2) {
7961 ecode3 = SWIG_AsVal_int(obj2, &val3);
7962 if (!SWIG_IsOK(ecode3)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7964 }
7965 arg3 = static_cast< int >(val3);
7966 }
7967 if (obj3) {
7968 ecode4 = SWIG_AsVal_int(obj3, &val4);
7969 if (!SWIG_IsOK(ecode4)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7971 }
7972 arg4 = static_cast< int >(val4);
7973 }
7974 if (obj4) {
7975 ecode5 = SWIG_AsVal_int(obj4, &val5);
7976 if (!SWIG_IsOK(ecode5)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7978 }
7979 arg5 = static_cast< int >(val5);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 PyObject *result = 0 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 PyObject *swig_obj[1] ;
8001
8002 if (!args) SWIG_fail;
8003 swig_obj[0] = args;
8004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8007 }
8008 arg1 = reinterpret_cast< wxRect * >(argp1);
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (PyObject *)wxRect_Get(arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = result;
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *obj;
8024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8025 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8026 return SWIG_Py_Void();
8027 }
8028
8029 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 return SWIG_Python_InitShadowInstance(args);
8031 }
8032
8033 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxRect *arg1 = (wxRect *) 0 ;
8036 wxRect *arg2 = (wxRect *) 0 ;
8037 PyObject *result = 0 ;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 void *argp2 = 0 ;
8041 int res2 = 0 ;
8042 PyObject * obj0 = 0 ;
8043 PyObject * obj1 = 0 ;
8044 char * kwnames[] = {
8045 (char *) "r1",(char *) "r2", NULL
8046 };
8047
8048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8055 if (!SWIG_IsOK(res2)) {
8056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8057 }
8058 arg2 = reinterpret_cast< wxRect * >(argp2);
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 result = (PyObject *)wxIntersectRect(arg1,arg2);
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = result;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 double arg1 = (double) 0.0 ;
8076 double arg2 = (double) 0.0 ;
8077 wxPoint2D *result = 0 ;
8078 double val1 ;
8079 int ecode1 = 0 ;
8080 double val2 ;
8081 int ecode2 = 0 ;
8082 PyObject * obj0 = 0 ;
8083 PyObject * obj1 = 0 ;
8084 char * kwnames[] = {
8085 (char *) "x",(char *) "y", NULL
8086 };
8087
8088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8089 if (obj0) {
8090 ecode1 = SWIG_AsVal_double(obj0, &val1);
8091 if (!SWIG_IsOK(ecode1)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8093 }
8094 arg1 = static_cast< double >(val1);
8095 }
8096 if (obj1) {
8097 ecode2 = SWIG_AsVal_double(obj1, &val2);
8098 if (!SWIG_IsOK(ecode2)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8100 }
8101 arg2 = static_cast< double >(val2);
8102 }
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj = 0;
8118 wxPoint2D *arg1 = 0 ;
8119 wxPoint2D *result = 0 ;
8120 wxPoint2D temp1 ;
8121 PyObject * obj0 = 0 ;
8122 char * kwnames[] = {
8123 (char *) "pt", NULL
8124 };
8125
8126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8127 {
8128 arg1 = &temp1;
8129 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8130 }
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxPoint *arg1 = 0 ;
8147 wxPoint2D *result = 0 ;
8148 wxPoint temp1 ;
8149 PyObject * obj0 = 0 ;
8150 char * kwnames[] = {
8151 (char *) "pt", NULL
8152 };
8153
8154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8155 {
8156 arg1 = &temp1;
8157 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8158 }
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 int *arg2 = (int *) 0 ;
8176 int *arg3 = (int *) 0 ;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 int temp2 ;
8180 int res2 = SWIG_TMPOBJ ;
8181 int temp3 ;
8182 int res3 = SWIG_TMPOBJ ;
8183 PyObject *swig_obj[1] ;
8184
8185 arg2 = &temp2;
8186 arg3 = &temp3;
8187 if (!args) SWIG_fail;
8188 swig_obj[0] = args;
8189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8190 if (!SWIG_IsOK(res1)) {
8191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8192 }
8193 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_Py_Void();
8201 if (SWIG_IsTmpObj(res2)) {
8202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8203 } else {
8204 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8206 }
8207 if (SWIG_IsTmpObj(res3)) {
8208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8209 } else {
8210 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8220 PyObject *resultobj = 0;
8221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8222 int *arg2 = (int *) 0 ;
8223 int *arg3 = (int *) 0 ;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 int temp2 ;
8227 int res2 = SWIG_TMPOBJ ;
8228 int temp3 ;
8229 int res3 = SWIG_TMPOBJ ;
8230 PyObject *swig_obj[1] ;
8231
8232 arg2 = &temp2;
8233 arg3 = &temp3;
8234 if (!args) SWIG_fail;
8235 swig_obj[0] = args;
8236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8237 if (!SWIG_IsOK(res1)) {
8238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8239 }
8240 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 if (SWIG_IsTmpObj(res2)) {
8249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8250 } else {
8251 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8253 }
8254 if (SWIG_IsTmpObj(res3)) {
8255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8256 } else {
8257 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8259 }
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *resultobj = 0;
8268 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8269 double result;
8270 void *argp1 = 0 ;
8271 int res1 = 0 ;
8272 PyObject *swig_obj[1] ;
8273
8274 if (!args) SWIG_fail;
8275 swig_obj[0] = args;
8276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8277 if (!SWIG_IsOK(res1)) {
8278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8279 }
8280 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = SWIG_From_double(static_cast< double >(result));
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8295 PyObject *resultobj = 0;
8296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8297 double result;
8298 void *argp1 = 0 ;
8299 int res1 = 0 ;
8300 PyObject *swig_obj[1] ;
8301
8302 if (!args) SWIG_fail;
8303 swig_obj[0] = args;
8304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8305 if (!SWIG_IsOK(res1)) {
8306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8307 }
8308 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_From_double(static_cast< double >(result));
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8325 double arg2 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 double val2 ;
8329 int ecode2 = 0 ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 char * kwnames[] = {
8333 (char *) "self",(char *) "length", NULL
8334 };
8335
8336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8338 if (!SWIG_IsOK(res1)) {
8339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8340 }
8341 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8342 ecode2 = SWIG_AsVal_double(obj1, &val2);
8343 if (!SWIG_IsOK(ecode2)) {
8344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8345 }
8346 arg2 = static_cast< double >(val2);
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 (arg1)->SetVectorLength(arg2);
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_Py_Void();
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8363 double arg2 ;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 double val2 ;
8367 int ecode2 = 0 ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "degrees", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8378 }
8379 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8380 ecode2 = SWIG_AsVal_double(obj1, &val2);
8381 if (!SWIG_IsOK(ecode2)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8383 }
8384 arg2 = static_cast< double >(val2);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 (arg1)->SetVectorAngle(arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "pt", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D *arg2 = 0 ;
8439 double result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 wxPoint2D temp2 ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char * kwnames[] = {
8446 (char *) "self",(char *) "pt", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 arg2 = &temp2;
8457 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_From_double(static_cast< double >(result));
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D *arg2 = 0 ;
8476 double result;
8477 void *argp1 = 0 ;
8478 int res1 = 0 ;
8479 wxPoint2D temp2 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "vec", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 arg2 = &temp2;
8494 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8495 }
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_From_double(static_cast< double >(result));
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = 0;
8511 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8512 wxPoint2D *arg2 = 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 wxPoint2D temp2 ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char * kwnames[] = {
8520 (char *) "self",(char *) "vec", NULL
8521 };
8522
8523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8527 }
8528 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8529 {
8530 arg2 = &temp2;
8531 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 wxPoint2D result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (arg1)->operator -();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 wxPoint2D *arg2 = 0 ;
8618 wxPoint2D *result = 0 ;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 wxPoint2D temp2 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "pt", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 {
8635 arg2 = &temp2;
8636 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8637 }
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 {
8641 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8642 result = (wxPoint2D *) &_result_ref;
8643 }
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8657 wxPoint2D *arg2 = 0 ;
8658 wxPoint2D *result = 0 ;
8659 void *argp1 = 0 ;
8660 int res1 = 0 ;
8661 wxPoint2D temp2 ;
8662 PyObject * obj0 = 0 ;
8663 PyObject * obj1 = 0 ;
8664 char * kwnames[] = {
8665 (char *) "self",(char *) "pt", NULL
8666 };
8667
8668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8670 if (!SWIG_IsOK(res1)) {
8671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8672 }
8673 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8674 {
8675 arg2 = &temp2;
8676 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 {
8681 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8682 result = (wxPoint2D *) &_result_ref;
8683 }
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D *arg2 = 0 ;
8698 wxPoint2D *result = 0 ;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 wxPoint2D temp2 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "pt", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 {
8715 arg2 = &temp2;
8716 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8717 }
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 {
8721 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8722 result = (wxPoint2D *) &_result_ref;
8723 }
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8737 PyObject *arg2 = (PyObject *) 0 ;
8738 bool result;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 char * kwnames[] = {
8744 (char *) "self",(char *) "other", NULL
8745 };
8746
8747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 arg2 = obj1;
8754 {
8755 result = (bool)wxPoint2D___eq__(arg1,arg2);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 {
8759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8760 }
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 PyObject *arg2 = (PyObject *) 0 ;
8771 bool result;
8772 void *argp1 = 0 ;
8773 int res1 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "other", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 arg2 = obj1;
8787 {
8788 result = (bool)wxPoint2D___ne__(arg1,arg2);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 double arg2 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 PyObject *swig_obj[2] ;
8809
8810 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8817 if (!SWIG_IsOK(ecode2)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8819 }
8820 arg2 = static_cast< double >(val2);
8821 if (arg1) (arg1)->m_x = arg2;
8822
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 double result;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 PyObject *swig_obj[1] ;
8837
8838 if (!args) SWIG_fail;
8839 swig_obj[0] = args;
8840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 result = (double) ((arg1)->m_x);
8846 resultobj = SWIG_From_double(static_cast< double >(result));
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 double arg2 ;
8857 void *argp1 = 0 ;
8858 int res1 = 0 ;
8859 double val2 ;
8860 int ecode2 = 0 ;
8861 PyObject *swig_obj[2] ;
8862
8863 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8867 }
8868 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8869 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8872 }
8873 arg2 = static_cast< double >(val2);
8874 if (arg1) (arg1)->m_y = arg2;
8875
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 double result;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject *swig_obj[1] ;
8890
8891 if (!args) SWIG_fail;
8892 swig_obj[0] = args;
8893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 result = (double) ((arg1)->m_y);
8899 resultobj = SWIG_From_double(static_cast< double >(result));
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 double arg2 = (double) 0 ;
8910 double arg3 = (double) 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 double val2 ;
8914 int ecode2 = 0 ;
8915 double val3 ;
8916 int ecode3 = 0 ;
8917 PyObject * obj0 = 0 ;
8918 PyObject * obj1 = 0 ;
8919 PyObject * obj2 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "self",(char *) "x",(char *) "y", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8928 }
8929 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8930 if (obj1) {
8931 ecode2 = SWIG_AsVal_double(obj1, &val2);
8932 if (!SWIG_IsOK(ecode2)) {
8933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8934 }
8935 arg2 = static_cast< double >(val2);
8936 }
8937 if (obj2) {
8938 ecode3 = SWIG_AsVal_double(obj2, &val3);
8939 if (!SWIG_IsOK(ecode3)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8941 }
8942 arg3 = static_cast< double >(val3);
8943 }
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxPoint2D_Set(arg1,arg2,arg3);
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_Py_Void();
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958 PyObject *resultobj = 0;
8959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8960 PyObject *result = 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (PyObject *)wxPoint2D_Get(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = result;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN int DefaultPosition_set(PyObject *) {
8997 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8998 return 1;
8999 }
9000
9001
9002 SWIGINTERN PyObject *DefaultPosition_get(void) {
9003 PyObject *pyobj = 0;
9004
9005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9006 return pyobj;
9007 }
9008
9009
9010 SWIGINTERN int DefaultSize_set(PyObject *) {
9011 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9012 return 1;
9013 }
9014
9015
9016 SWIGINTERN PyObject *DefaultSize_get(void) {
9017 PyObject *pyobj = 0;
9018
9019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9020 return pyobj;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj = 0;
9026 PyObject *arg1 = (PyObject *) 0 ;
9027 wxPyInputStream *result = 0 ;
9028 PyObject * obj0 = 0 ;
9029 char * kwnames[] = {
9030 (char *) "p", NULL
9031 };
9032
9033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9034 arg1 = obj0;
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject *swig_obj[1] ;
9054
9055 if (!args) SWIG_fail;
9056 swig_obj[0] = args;
9057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 delete arg1;
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 resultobj = SWIG_Py_Void();
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 PyObject *resultobj = 0;
9078 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 PyObject *swig_obj[1] ;
9082
9083 if (!args) SWIG_fail;
9084 swig_obj[0] = args;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 (arg1)->close();
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 resultobj = SWIG_Py_Void();
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 PyObject *swig_obj[1] ;
9109
9110 if (!args) SWIG_fail;
9111 swig_obj[0] = args;
9112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9113 if (!SWIG_IsOK(res1)) {
9114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9115 }
9116 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 (arg1)->flush();
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_Py_Void();
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *resultobj = 0;
9132 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9133 bool result;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 PyObject *swig_obj[1] ;
9137
9138 if (!args) SWIG_fail;
9139 swig_obj[0] = args;
9140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)(arg1)->eof();
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 {
9152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = 0;
9162 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9163 int arg2 = (int) -1 ;
9164 PyObject *result = 0 ;
9165 void *argp1 = 0 ;
9166 int res1 = 0 ;
9167 int val2 ;
9168 int ecode2 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "size", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_int(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9185 }
9186 arg2 = static_cast< int >(val2);
9187 }
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (PyObject *)(arg1)->read(arg2);
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 resultobj = result;
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = 0;
9203 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9204 int arg2 = (int) -1 ;
9205 PyObject *result = 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 int val2 ;
9209 int ecode2 = 0 ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 char * kwnames[] = {
9213 (char *) "self",(char *) "size", NULL
9214 };
9215
9216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9218 if (!SWIG_IsOK(res1)) {
9219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9220 }
9221 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_int(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9226 }
9227 arg2 = static_cast< int >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (PyObject *)(arg1)->readline(arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = result;
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 int arg2 = (int) -1 ;
9246 PyObject *result = 0 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 int val2 ;
9250 int ecode2 = 0 ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "sizehint", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9261 }
9262 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9263 if (obj1) {
9264 ecode2 = SWIG_AsVal_int(obj1, &val2);
9265 if (!SWIG_IsOK(ecode2)) {
9266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9267 }
9268 arg2 = static_cast< int >(val2);
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (PyObject *)(arg1)->readlines(arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = result;
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9286 int arg2 ;
9287 int arg3 = (int) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 int val2 ;
9291 int ecode2 = 0 ;
9292 int val3 ;
9293 int ecode3 = 0 ;
9294 PyObject * obj0 = 0 ;
9295 PyObject * obj1 = 0 ;
9296 PyObject * obj2 = 0 ;
9297 char * kwnames[] = {
9298 (char *) "self",(char *) "offset",(char *) "whence", NULL
9299 };
9300
9301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9303 if (!SWIG_IsOK(res1)) {
9304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9305 }
9306 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9307 ecode2 = SWIG_AsVal_int(obj1, &val2);
9308 if (!SWIG_IsOK(ecode2)) {
9309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9310 }
9311 arg2 = static_cast< int >(val2);
9312 if (obj2) {
9313 ecode3 = SWIG_AsVal_int(obj2, &val3);
9314 if (!SWIG_IsOK(ecode3)) {
9315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9316 }
9317 arg3 = static_cast< int >(val3);
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->seek(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *resultobj = 0;
9334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9335 int result;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 PyObject *swig_obj[1] ;
9339
9340 if (!args) SWIG_fail;
9341 swig_obj[0] = args;
9342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9345 }
9346 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 result = (int)(arg1)->tell();
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_From_int(static_cast< int >(result));
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9363 char result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9373 }
9374 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (char)(arg1)->Peek();
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 resultobj = SWIG_From_char(static_cast< char >(result));
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 PyObject *swig_obj[1] ;
9395
9396 if (!args) SWIG_fail;
9397 swig_obj[0] = args;
9398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (char)(arg1)->GetC();
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 resultobj = SWIG_From_char(static_cast< char >(result));
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 size_t 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_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (size_t)(arg1)->LastRead();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 bool result;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 PyObject *swig_obj[1] ;
9451
9452 if (!args) SWIG_fail;
9453 swig_obj[0] = args;
9454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)(arg1)->CanRead();
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 {
9466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9467 }
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9477 bool result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9487 }
9488 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (bool)(arg1)->Eof();
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 {
9496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9497 }
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9507 char arg2 ;
9508 bool result;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 char val2 ;
9512 int ecode2 = 0 ;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 char * kwnames[] = {
9516 (char *) "self",(char *) "c", NULL
9517 };
9518
9519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9521 if (!SWIG_IsOK(res1)) {
9522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9523 }
9524 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9525 ecode2 = SWIG_AsVal_char(obj1, &val2);
9526 if (!SWIG_IsOK(ecode2)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9528 }
9529 arg2 = static_cast< char >(val2);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (bool)(arg1)->Ungetch(arg2);
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 {
9537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9538 }
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj = 0;
9547 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9548 long arg2 ;
9549 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9550 long result;
9551 void *argp1 = 0 ;
9552 int res1 = 0 ;
9553 long val2 ;
9554 int ecode2 = 0 ;
9555 int val3 ;
9556 int ecode3 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "pos",(char *) "mode", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9568 }
9569 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9570 ecode2 = SWIG_AsVal_long(obj1, &val2);
9571 if (!SWIG_IsOK(ecode2)) {
9572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9573 }
9574 arg2 = static_cast< long >(val2);
9575 if (obj2) {
9576 ecode3 = SWIG_AsVal_int(obj2, &val3);
9577 if (!SWIG_IsOK(ecode3)) {
9578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9579 }
9580 arg3 = static_cast< wxSeekMode >(val3);
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (long)(arg1)->SeekI(arg2,arg3);
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_long(static_cast< long >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9596 PyObject *resultobj = 0;
9597 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9598 long result;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 PyObject *swig_obj[1] ;
9602
9603 if (!args) SWIG_fail;
9604 swig_obj[0] = args;
9605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9608 }
9609 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (long)(arg1)->TellI();
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_From_long(static_cast< long >(result));
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9624 PyObject *obj;
9625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9627 return SWIG_Py_Void();
9628 }
9629
9630 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9631 return SWIG_Python_InitShadowInstance(args);
9632 }
9633
9634 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9637 PyObject *arg2 = (PyObject *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "obj", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9652 arg2 = obj1;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 wxOutputStream_write(arg1,arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9669 size_t result;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9679 }
9680 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *obj;
9696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9697 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9698 return SWIG_Py_Void();
9699 }
9700
9701 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxInputStream *arg1 = (wxInputStream *) 0 ;
9704 wxString *arg2 = 0 ;
9705 wxString *arg3 = 0 ;
9706 wxString *arg4 = 0 ;
9707 wxDateTime arg5 ;
9708 wxFSFile *result = 0 ;
9709 wxPyInputStream *temp1 ;
9710 bool temp2 = false ;
9711 bool temp3 = false ;
9712 bool temp4 = false ;
9713 void *argp5 ;
9714 int res5 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 PyObject * obj2 = 0 ;
9718 PyObject * obj3 = 0 ;
9719 PyObject * obj4 = 0 ;
9720 char * kwnames[] = {
9721 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9722 };
9723
9724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9725 {
9726 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9727 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9728 } else {
9729 PyErr_Clear(); // clear the failure of the wxPyConvert above
9730 arg1 = wxPyCBInputStream_create(obj0, true);
9731 if (arg1 == NULL) {
9732 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9733 SWIG_fail;
9734 }
9735 }
9736 }
9737 {
9738 arg2 = wxString_in_helper(obj1);
9739 if (arg2 == NULL) SWIG_fail;
9740 temp2 = true;
9741 }
9742 {
9743 arg3 = wxString_in_helper(obj2);
9744 if (arg3 == NULL) SWIG_fail;
9745 temp3 = true;
9746 }
9747 {
9748 arg4 = wxString_in_helper(obj3);
9749 if (arg4 == NULL) SWIG_fail;
9750 temp4 = true;
9751 }
9752 {
9753 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9754 if (!SWIG_IsOK(res5)) {
9755 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9756 }
9757 if (!argp5) {
9758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9759 } else {
9760 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9761 arg5 = *temp;
9762 if (SWIG_IsNewObj(res5)) delete temp;
9763 }
9764 }
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9772 {
9773 if (temp2)
9774 delete arg2;
9775 }
9776 {
9777 if (temp3)
9778 delete arg3;
9779 }
9780 {
9781 if (temp4)
9782 delete arg4;
9783 }
9784 return resultobj;
9785 fail:
9786 {
9787 if (temp2)
9788 delete arg2;
9789 }
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 {
9795 if (temp4)
9796 delete arg4;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9803 PyObject *resultobj = 0;
9804 wxFSFile *arg1 = (wxFSFile *) 0 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 PyObject *swig_obj[1] ;
9808
9809 if (!args) SWIG_fail;
9810 swig_obj[0] = args;
9811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9812 if (!SWIG_IsOK(res1)) {
9813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9814 }
9815 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 delete arg1;
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 resultobj = SWIG_Py_Void();
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9831 PyObject *resultobj = 0;
9832 wxFSFile *arg1 = (wxFSFile *) 0 ;
9833 wxInputStream *result = 0 ;
9834 void *argp1 = 0 ;
9835 int res1 = 0 ;
9836 PyObject *swig_obj[1] ;
9837
9838 if (!args) SWIG_fail;
9839 swig_obj[0] = args;
9840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9841 if (!SWIG_IsOK(res1)) {
9842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9843 }
9844 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxInputStream *)(arg1)->GetStream();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 wxPyInputStream * _ptr = NULL;
9853
9854 if (result) {
9855 _ptr = new wxPyInputStream(result);
9856 }
9857 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 (arg1)->DetachStream();
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_Py_Void();
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9893 PyObject *resultobj = 0;
9894 wxFSFile *arg1 = (wxFSFile *) 0 ;
9895 wxString *result = 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 PyObject *swig_obj[1] ;
9899
9900 if (!args) SWIG_fail;
9901 swig_obj[0] = args;
9902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9903 if (!SWIG_IsOK(res1)) {
9904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9905 }
9906 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 {
9910 wxString const &_result_ref = (arg1)->GetMimeType();
9911 result = (wxString *) &_result_ref;
9912 }
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *resultobj = 0;
9931 wxFSFile *arg1 = (wxFSFile *) 0 ;
9932 wxString *result = 0 ;
9933 void *argp1 = 0 ;
9934 int res1 = 0 ;
9935 PyObject *swig_obj[1] ;
9936
9937 if (!args) SWIG_fail;
9938 swig_obj[0] = args;
9939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9940 if (!SWIG_IsOK(res1)) {
9941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9942 }
9943 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 {
9947 wxString const &_result_ref = (arg1)->GetLocation();
9948 result = (wxString *) &_result_ref;
9949 }
9950 wxPyEndAllowThreads(__tstate);
9951 if (PyErr_Occurred()) SWIG_fail;
9952 }
9953 {
9954 #if wxUSE_UNICODE
9955 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9956 #else
9957 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9958 #endif
9959 }
9960 return resultobj;
9961 fail:
9962 return NULL;
9963 }
9964
9965
9966 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9967 PyObject *resultobj = 0;
9968 wxFSFile *arg1 = (wxFSFile *) 0 ;
9969 wxString *result = 0 ;
9970 void *argp1 = 0 ;
9971 int res1 = 0 ;
9972 PyObject *swig_obj[1] ;
9973
9974 if (!args) SWIG_fail;
9975 swig_obj[0] = args;
9976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9977 if (!SWIG_IsOK(res1)) {
9978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9979 }
9980 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 {
9984 wxString const &_result_ref = (arg1)->GetAnchor();
9985 result = (wxString *) &_result_ref;
9986 }
9987 wxPyEndAllowThreads(__tstate);
9988 if (PyErr_Occurred()) SWIG_fail;
9989 }
9990 {
9991 #if wxUSE_UNICODE
9992 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9993 #else
9994 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9995 #endif
9996 }
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *resultobj = 0;
10005 wxFSFile *arg1 = (wxFSFile *) 0 ;
10006 wxDateTime result;
10007 void *argp1 = 0 ;
10008 int res1 = 0 ;
10009 PyObject *swig_obj[1] ;
10010
10011 if (!args) SWIG_fail;
10012 swig_obj[0] = args;
10013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10014 if (!SWIG_IsOK(res1)) {
10015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10016 }
10017 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 result = (arg1)->GetModificationTime();
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10025 return resultobj;
10026 fail:
10027 return NULL;
10028 }
10029
10030
10031 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10032 PyObject *obj;
10033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10034 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10035 return SWIG_Py_Void();
10036 }
10037
10038 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10039 return SWIG_Python_InitShadowInstance(args);
10040 }
10041
10042 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *resultobj = 0;
10044 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10045 void *argp1 = 0 ;
10046 int res1 = 0 ;
10047 PyObject *swig_obj[1] ;
10048
10049 if (!args) SWIG_fail;
10050 swig_obj[0] = args;
10051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10052 if (!SWIG_IsOK(res1)) {
10053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10054 }
10055 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 delete arg1;
10059
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 resultobj = SWIG_Py_Void();
10064 return resultobj;
10065 fail:
10066 return NULL;
10067 }
10068
10069
10070 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10071 PyObject *obj;
10072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10073 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10074 return SWIG_Py_Void();
10075 }
10076
10077 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10078 PyObject *resultobj = 0;
10079 wxPyFileSystemHandler *result = 0 ;
10080
10081 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10089 return resultobj;
10090 fail:
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj = 0;
10097 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10098 PyObject *arg2 = (PyObject *) 0 ;
10099 PyObject *arg3 = (PyObject *) 0 ;
10100 void *argp1 = 0 ;
10101 int res1 = 0 ;
10102 PyObject * obj0 = 0 ;
10103 PyObject * obj1 = 0 ;
10104 PyObject * obj2 = 0 ;
10105 char * kwnames[] = {
10106 (char *) "self",(char *) "self",(char *) "_class", NULL
10107 };
10108
10109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10113 }
10114 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10115 arg2 = obj1;
10116 arg3 = obj2;
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 (arg1)->_setCallbackInfo(arg2,arg3);
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 resultobj = SWIG_Py_Void();
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj = 0;
10132 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10133 wxString *arg2 = 0 ;
10134 bool result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 bool temp2 = false ;
10138 PyObject * obj0 = 0 ;
10139 PyObject * obj1 = 0 ;
10140 char * kwnames[] = {
10141 (char *) "self",(char *) "location", NULL
10142 };
10143
10144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10146 if (!SWIG_IsOK(res1)) {
10147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10148 }
10149 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10150 {
10151 arg2 = wxString_in_helper(obj1);
10152 if (arg2 == NULL) SWIG_fail;
10153 temp2 = true;
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 {
10162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10163 }
10164 {
10165 if (temp2)
10166 delete arg2;
10167 }
10168 return resultobj;
10169 fail:
10170 {
10171 if (temp2)
10172 delete arg2;
10173 }
10174 return NULL;
10175 }
10176
10177
10178 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj = 0;
10180 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10181 wxFileSystem *arg2 = 0 ;
10182 wxString *arg3 = 0 ;
10183 wxFSFile *result = 0 ;
10184 void *argp1 = 0 ;
10185 int res1 = 0 ;
10186 void *argp2 = 0 ;
10187 int res2 = 0 ;
10188 bool temp3 = false ;
10189 PyObject * obj0 = 0 ;
10190 PyObject * obj1 = 0 ;
10191 PyObject * obj2 = 0 ;
10192 char * kwnames[] = {
10193 (char *) "self",(char *) "fs",(char *) "location", NULL
10194 };
10195
10196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10200 }
10201 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10203 if (!SWIG_IsOK(res2)) {
10204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10205 }
10206 if (!argp2) {
10207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10208 }
10209 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10210 {
10211 arg3 = wxString_in_helper(obj2);
10212 if (arg3 == NULL) SWIG_fail;
10213 temp3 = true;
10214 }
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10223 }
10224 {
10225 if (temp3)
10226 delete arg3;
10227 }
10228 return resultobj;
10229 fail:
10230 {
10231 if (temp3)
10232 delete arg3;
10233 }
10234 return NULL;
10235 }
10236
10237
10238 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj = 0;
10240 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10241 wxString *arg2 = 0 ;
10242 int arg3 = (int) 0 ;
10243 wxString result;
10244 void *argp1 = 0 ;
10245 int res1 = 0 ;
10246 bool temp2 = false ;
10247 int val3 ;
10248 int ecode3 = 0 ;
10249 PyObject * obj0 = 0 ;
10250 PyObject * obj1 = 0 ;
10251 PyObject * obj2 = 0 ;
10252 char * kwnames[] = {
10253 (char *) "self",(char *) "spec",(char *) "flags", NULL
10254 };
10255
10256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10258 if (!SWIG_IsOK(res1)) {
10259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10260 }
10261 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10262 {
10263 arg2 = wxString_in_helper(obj1);
10264 if (arg2 == NULL) SWIG_fail;
10265 temp2 = true;
10266 }
10267 if (obj2) {
10268 ecode3 = SWIG_AsVal_int(obj2, &val3);
10269 if (!SWIG_IsOK(ecode3)) {
10270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10271 }
10272 arg3 = static_cast< int >(val3);
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString result;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 PyObject *swig_obj[1] ;
10308
10309 if (!args) SWIG_fail;
10310 swig_obj[0] = args;
10311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10312 if (!SWIG_IsOK(res1)) {
10313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10314 }
10315 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 result = (arg1)->FindNext();
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 {
10323 #if wxUSE_UNICODE
10324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10325 #else
10326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10327 #endif
10328 }
10329 return resultobj;
10330 fail:
10331 return NULL;
10332 }
10333
10334
10335 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10336 PyObject *resultobj = 0;
10337 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10338 wxString *arg2 = 0 ;
10339 wxString result;
10340 void *argp1 = 0 ;
10341 int res1 = 0 ;
10342 bool temp2 = false ;
10343 PyObject * obj0 = 0 ;
10344 PyObject * obj1 = 0 ;
10345 char * kwnames[] = {
10346 (char *) "self",(char *) "location", NULL
10347 };
10348
10349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10351 if (!SWIG_IsOK(res1)) {
10352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10353 }
10354 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10355 {
10356 arg2 = wxString_in_helper(obj1);
10357 if (arg2 == NULL) SWIG_fail;
10358 temp2 = true;
10359 }
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 result = (arg1)->GetProtocol((wxString const &)*arg2);
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 #if wxUSE_UNICODE
10368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10369 #else
10370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10371 #endif
10372 }
10373 {
10374 if (temp2)
10375 delete arg2;
10376 }
10377 return resultobj;
10378 fail:
10379 {
10380 if (temp2)
10381 delete arg2;
10382 }
10383 return NULL;
10384 }
10385
10386
10387 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10388 PyObject *resultobj = 0;
10389 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10390 wxString *arg2 = 0 ;
10391 wxString result;
10392 void *argp1 = 0 ;
10393 int res1 = 0 ;
10394 bool temp2 = false ;
10395 PyObject * obj0 = 0 ;
10396 PyObject * obj1 = 0 ;
10397 char * kwnames[] = {
10398 (char *) "self",(char *) "location", NULL
10399 };
10400
10401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10403 if (!SWIG_IsOK(res1)) {
10404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10405 }
10406 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10407 {
10408 arg2 = wxString_in_helper(obj1);
10409 if (arg2 == NULL) SWIG_fail;
10410 temp2 = true;
10411 }
10412 {
10413 PyThreadState* __tstate = wxPyBeginAllowThreads();
10414 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 {
10419 #if wxUSE_UNICODE
10420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10421 #else
10422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10423 #endif
10424 }
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return resultobj;
10430 fail:
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return NULL;
10436 }
10437
10438
10439 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj = 0;
10441 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10442 wxString *arg2 = 0 ;
10443 wxString result;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 bool temp2 = false ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 char * kwnames[] = {
10450 (char *) "self",(char *) "location", NULL
10451 };
10452
10453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10457 }
10458 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10459 {
10460 arg2 = wxString_in_helper(obj1);
10461 if (arg2 == NULL) SWIG_fail;
10462 temp2 = true;
10463 }
10464 {
10465 PyThreadState* __tstate = wxPyBeginAllowThreads();
10466 result = (arg1)->GetAnchor((wxString const &)*arg2);
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 #if wxUSE_UNICODE
10472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10473 #else
10474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10475 #endif
10476 }
10477 {
10478 if (temp2)
10479 delete arg2;
10480 }
10481 return resultobj;
10482 fail:
10483 {
10484 if (temp2)
10485 delete arg2;
10486 }
10487 return NULL;
10488 }
10489
10490
10491 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10492 PyObject *resultobj = 0;
10493 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10494 wxString *arg2 = 0 ;
10495 wxString result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 bool temp2 = false ;
10499 PyObject * obj0 = 0 ;
10500 PyObject * obj1 = 0 ;
10501 char * kwnames[] = {
10502 (char *) "self",(char *) "location", NULL
10503 };
10504
10505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10507 if (!SWIG_IsOK(res1)) {
10508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10509 }
10510 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10511 {
10512 arg2 = wxString_in_helper(obj1);
10513 if (arg2 == NULL) SWIG_fail;
10514 temp2 = true;
10515 }
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10519 wxPyEndAllowThreads(__tstate);
10520 if (PyErr_Occurred()) SWIG_fail;
10521 }
10522 {
10523 #if wxUSE_UNICODE
10524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10525 #else
10526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10527 #endif
10528 }
10529 {
10530 if (temp2)
10531 delete arg2;
10532 }
10533 return resultobj;
10534 fail:
10535 {
10536 if (temp2)
10537 delete arg2;
10538 }
10539 return NULL;
10540 }
10541
10542
10543 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10544 PyObject *resultobj = 0;
10545 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10546 wxString *arg2 = 0 ;
10547 wxString result;
10548 void *argp1 = 0 ;
10549 int res1 = 0 ;
10550 bool temp2 = false ;
10551 PyObject * obj0 = 0 ;
10552 PyObject * obj1 = 0 ;
10553 char * kwnames[] = {
10554 (char *) "self",(char *) "location", NULL
10555 };
10556
10557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10563 {
10564 arg2 = wxString_in_helper(obj1);
10565 if (arg2 == NULL) SWIG_fail;
10566 temp2 = true;
10567 }
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 #if wxUSE_UNICODE
10576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10577 #else
10578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10579 #endif
10580 }
10581 {
10582 if (temp2)
10583 delete arg2;
10584 }
10585 return resultobj;
10586 fail:
10587 {
10588 if (temp2)
10589 delete arg2;
10590 }
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10596 PyObject *obj;
10597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10598 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10599 return SWIG_Py_Void();
10600 }
10601
10602 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10603 return SWIG_Python_InitShadowInstance(args);
10604 }
10605
10606 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10607 PyObject *resultobj = 0;
10608 wxFileSystem *result = 0 ;
10609
10610 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (wxFileSystem *)new wxFileSystem();
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10619 }
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10627 PyObject *resultobj = 0;
10628 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
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, SWIG_POINTER_DISOWN | 0 );
10636 if (!SWIG_IsOK(res1)) {
10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10638 }
10639 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 delete arg1;
10643
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 resultobj = SWIG_Py_Void();
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj = 0;
10656 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10657 wxString *arg2 = 0 ;
10658 bool arg3 = (bool) false ;
10659 void *argp1 = 0 ;
10660 int res1 = 0 ;
10661 bool temp2 = false ;
10662 bool val3 ;
10663 int ecode3 = 0 ;
10664 PyObject * obj0 = 0 ;
10665 PyObject * obj1 = 0 ;
10666 PyObject * obj2 = 0 ;
10667 char * kwnames[] = {
10668 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10669 };
10670
10671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10673 if (!SWIG_IsOK(res1)) {
10674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10675 }
10676 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10677 {
10678 arg2 = wxString_in_helper(obj1);
10679 if (arg2 == NULL) SWIG_fail;
10680 temp2 = true;
10681 }
10682 if (obj2) {
10683 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10684 if (!SWIG_IsOK(ecode3)) {
10685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10686 }
10687 arg3 = static_cast< bool >(val3);
10688 }
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 resultobj = SWIG_Py_Void();
10696 {
10697 if (temp2)
10698 delete arg2;
10699 }
10700 return resultobj;
10701 fail:
10702 {
10703 if (temp2)
10704 delete arg2;
10705 }
10706 return NULL;
10707 }
10708
10709
10710 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10711 PyObject *resultobj = 0;
10712 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10713 wxString result;
10714 void *argp1 = 0 ;
10715 int res1 = 0 ;
10716 PyObject *swig_obj[1] ;
10717
10718 if (!args) SWIG_fail;
10719 swig_obj[0] = args;
10720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10721 if (!SWIG_IsOK(res1)) {
10722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10723 }
10724 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (arg1)->GetPath();
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 {
10732 #if wxUSE_UNICODE
10733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10734 #else
10735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10736 #endif
10737 }
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj = 0;
10746 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10747 wxString *arg2 = 0 ;
10748 wxFSFile *result = 0 ;
10749 void *argp1 = 0 ;
10750 int res1 = 0 ;
10751 bool temp2 = false ;
10752 PyObject * obj0 = 0 ;
10753 PyObject * obj1 = 0 ;
10754 char * kwnames[] = {
10755 (char *) "self",(char *) "location", NULL
10756 };
10757
10758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10760 if (!SWIG_IsOK(res1)) {
10761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10762 }
10763 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10764 {
10765 arg2 = wxString_in_helper(obj1);
10766 if (arg2 == NULL) SWIG_fail;
10767 temp2 = true;
10768 }
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 {
10776 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10777 }
10778 {
10779 if (temp2)
10780 delete arg2;
10781 }
10782 return resultobj;
10783 fail:
10784 {
10785 if (temp2)
10786 delete arg2;
10787 }
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10795 wxString *arg2 = 0 ;
10796 int arg3 = (int) 0 ;
10797 wxString result;
10798 void *argp1 = 0 ;
10799 int res1 = 0 ;
10800 bool temp2 = false ;
10801 int val3 ;
10802 int ecode3 = 0 ;
10803 PyObject * obj0 = 0 ;
10804 PyObject * obj1 = 0 ;
10805 PyObject * obj2 = 0 ;
10806 char * kwnames[] = {
10807 (char *) "self",(char *) "spec",(char *) "flags", NULL
10808 };
10809
10810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10812 if (!SWIG_IsOK(res1)) {
10813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10814 }
10815 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10816 {
10817 arg2 = wxString_in_helper(obj1);
10818 if (arg2 == NULL) SWIG_fail;
10819 temp2 = true;
10820 }
10821 if (obj2) {
10822 ecode3 = SWIG_AsVal_int(obj2, &val3);
10823 if (!SWIG_IsOK(ecode3)) {
10824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10825 }
10826 arg3 = static_cast< int >(val3);
10827 }
10828 {
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10831 wxPyEndAllowThreads(__tstate);
10832 if (PyErr_Occurred()) SWIG_fail;
10833 }
10834 {
10835 #if wxUSE_UNICODE
10836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10837 #else
10838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10839 #endif
10840 }
10841 {
10842 if (temp2)
10843 delete arg2;
10844 }
10845 return resultobj;
10846 fail:
10847 {
10848 if (temp2)
10849 delete arg2;
10850 }
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10856 PyObject *resultobj = 0;
10857 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10858 wxString result;
10859 void *argp1 = 0 ;
10860 int res1 = 0 ;
10861 PyObject *swig_obj[1] ;
10862
10863 if (!args) SWIG_fail;
10864 swig_obj[0] = args;
10865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10866 if (!SWIG_IsOK(res1)) {
10867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10868 }
10869 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = (arg1)->FindNext();
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 {
10877 #if wxUSE_UNICODE
10878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10879 #else
10880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10881 #endif
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj = 0;
10891 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10892 int res1 = 0 ;
10893 PyObject * obj0 = 0 ;
10894 char * kwnames[] = {
10895 (char *) "handler", NULL
10896 };
10897
10898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10899 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10900 if (!SWIG_IsOK(res1)) {
10901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10902 }
10903 {
10904 PyThreadState* __tstate = wxPyBeginAllowThreads();
10905 wxFileSystem::AddHandler(arg1);
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_Py_Void();
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj = 0;
10918 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10919 wxFileSystemHandler *result = 0 ;
10920 void *argp1 = 0 ;
10921 int res1 = 0 ;
10922 PyObject * obj0 = 0 ;
10923 char * kwnames[] = {
10924 (char *) "handler", NULL
10925 };
10926
10927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10929 if (!SWIG_IsOK(res1)) {
10930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10931 }
10932 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10947 PyObject *resultobj = 0;
10948
10949 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10950 {
10951 PyThreadState* __tstate = wxPyBeginAllowThreads();
10952 wxFileSystem::CleanUpHandlers();
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 resultobj = SWIG_Py_Void();
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = 0;
10965 wxString *arg1 = 0 ;
10966 wxString result;
10967 bool temp1 = false ;
10968 PyObject * obj0 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "filename", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10974 {
10975 arg1 = wxString_in_helper(obj0);
10976 if (arg1 == NULL) SWIG_fail;
10977 temp1 = true;
10978 }
10979 {
10980 PyThreadState* __tstate = wxPyBeginAllowThreads();
10981 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10982 wxPyEndAllowThreads(__tstate);
10983 if (PyErr_Occurred()) SWIG_fail;
10984 }
10985 {
10986 #if wxUSE_UNICODE
10987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10988 #else
10989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10990 #endif
10991 }
10992 {
10993 if (temp1)
10994 delete arg1;
10995 }
10996 return resultobj;
10997 fail:
10998 {
10999 if (temp1)
11000 delete arg1;
11001 }
11002 return NULL;
11003 }
11004
11005
11006 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11007 PyObject *resultobj = 0;
11008 wxString *arg1 = 0 ;
11009 wxString result;
11010 bool temp1 = false ;
11011 PyObject * obj0 = 0 ;
11012 char * kwnames[] = {
11013 (char *) "url", NULL
11014 };
11015
11016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11017 {
11018 arg1 = wxString_in_helper(obj0);
11019 if (arg1 == NULL) SWIG_fail;
11020 temp1 = true;
11021 }
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 {
11029 #if wxUSE_UNICODE
11030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11031 #else
11032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11033 #endif
11034 }
11035 {
11036 if (temp1)
11037 delete arg1;
11038 }
11039 return resultobj;
11040 fail:
11041 {
11042 if (temp1)
11043 delete arg1;
11044 }
11045 return NULL;
11046 }
11047
11048
11049 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11050 PyObject *obj;
11051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11052 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11053 return SWIG_Py_Void();
11054 }
11055
11056 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 return SWIG_Python_InitShadowInstance(args);
11058 }
11059
11060 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11061 PyObject *resultobj = 0;
11062 wxInternetFSHandler *result = 0 ;
11063
11064 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11068 wxPyEndAllowThreads(__tstate);
11069 if (PyErr_Occurred()) SWIG_fail;
11070 }
11071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11079 PyObject *resultobj = 0;
11080 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11081 wxString *arg2 = 0 ;
11082 bool result;
11083 void *argp1 = 0 ;
11084 int res1 = 0 ;
11085 bool temp2 = false ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 char * kwnames[] = {
11089 (char *) "self",(char *) "location", NULL
11090 };
11091
11092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11094 if (!SWIG_IsOK(res1)) {
11095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11096 }
11097 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11098 {
11099 arg2 = wxString_in_helper(obj1);
11100 if (arg2 == NULL) SWIG_fail;
11101 temp2 = true;
11102 }
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 {
11110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11111 }
11112 {
11113 if (temp2)
11114 delete arg2;
11115 }
11116 return resultobj;
11117 fail:
11118 {
11119 if (temp2)
11120 delete arg2;
11121 }
11122 return NULL;
11123 }
11124
11125
11126 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11127 PyObject *resultobj = 0;
11128 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11129 wxFileSystem *arg2 = 0 ;
11130 wxString *arg3 = 0 ;
11131 wxFSFile *result = 0 ;
11132 void *argp1 = 0 ;
11133 int res1 = 0 ;
11134 void *argp2 = 0 ;
11135 int res2 = 0 ;
11136 bool temp3 = false ;
11137 PyObject * obj0 = 0 ;
11138 PyObject * obj1 = 0 ;
11139 PyObject * obj2 = 0 ;
11140 char * kwnames[] = {
11141 (char *) "self",(char *) "fs",(char *) "location", NULL
11142 };
11143
11144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11146 if (!SWIG_IsOK(res1)) {
11147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11148 }
11149 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11151 if (!SWIG_IsOK(res2)) {
11152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11153 }
11154 if (!argp2) {
11155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11156 }
11157 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11158 {
11159 arg3 = wxString_in_helper(obj2);
11160 if (arg3 == NULL) SWIG_fail;
11161 temp3 = true;
11162 }
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11166 wxPyEndAllowThreads(__tstate);
11167 if (PyErr_Occurred()) SWIG_fail;
11168 }
11169 {
11170 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11171 }
11172 {
11173 if (temp3)
11174 delete arg3;
11175 }
11176 return resultobj;
11177 fail:
11178 {
11179 if (temp3)
11180 delete arg3;
11181 }
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187 PyObject *obj;
11188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11189 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11190 return SWIG_Py_Void();
11191 }
11192
11193 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11194 return SWIG_Python_InitShadowInstance(args);
11195 }
11196
11197 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11198 PyObject *resultobj = 0;
11199 wxZipFSHandler *result = 0 ;
11200
11201 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 result = (wxZipFSHandler *)new wxZipFSHandler();
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj = 0;
11217 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11218 wxString *arg2 = 0 ;
11219 bool result;
11220 void *argp1 = 0 ;
11221 int res1 = 0 ;
11222 bool temp2 = false ;
11223 PyObject * obj0 = 0 ;
11224 PyObject * obj1 = 0 ;
11225 char * kwnames[] = {
11226 (char *) "self",(char *) "location", NULL
11227 };
11228
11229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11231 if (!SWIG_IsOK(res1)) {
11232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11233 }
11234 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11235 {
11236 arg2 = wxString_in_helper(obj1);
11237 if (arg2 == NULL) SWIG_fail;
11238 temp2 = true;
11239 }
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 {
11247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11248 }
11249 {
11250 if (temp2)
11251 delete arg2;
11252 }
11253 return resultobj;
11254 fail:
11255 {
11256 if (temp2)
11257 delete arg2;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = 0;
11265 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11266 wxFileSystem *arg2 = 0 ;
11267 wxString *arg3 = 0 ;
11268 wxFSFile *result = 0 ;
11269 void *argp1 = 0 ;
11270 int res1 = 0 ;
11271 void *argp2 = 0 ;
11272 int res2 = 0 ;
11273 bool temp3 = false ;
11274 PyObject * obj0 = 0 ;
11275 PyObject * obj1 = 0 ;
11276 PyObject * obj2 = 0 ;
11277 char * kwnames[] = {
11278 (char *) "self",(char *) "fs",(char *) "location", NULL
11279 };
11280
11281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11285 }
11286 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11288 if (!SWIG_IsOK(res2)) {
11289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11290 }
11291 if (!argp2) {
11292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11293 }
11294 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11295 {
11296 arg3 = wxString_in_helper(obj2);
11297 if (arg3 == NULL) SWIG_fail;
11298 temp3 = true;
11299 }
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 {
11307 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11308 }
11309 {
11310 if (temp3)
11311 delete arg3;
11312 }
11313 return resultobj;
11314 fail:
11315 {
11316 if (temp3)
11317 delete arg3;
11318 }
11319 return NULL;
11320 }
11321
11322
11323 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11324 PyObject *resultobj = 0;
11325 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11326 wxString *arg2 = 0 ;
11327 int arg3 = (int) 0 ;
11328 wxString result;
11329 void *argp1 = 0 ;
11330 int res1 = 0 ;
11331 bool temp2 = false ;
11332 int val3 ;
11333 int ecode3 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 char * kwnames[] = {
11338 (char *) "self",(char *) "spec",(char *) "flags", NULL
11339 };
11340
11341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11343 if (!SWIG_IsOK(res1)) {
11344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11345 }
11346 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11347 {
11348 arg2 = wxString_in_helper(obj1);
11349 if (arg2 == NULL) SWIG_fail;
11350 temp2 = true;
11351 }
11352 if (obj2) {
11353 ecode3 = SWIG_AsVal_int(obj2, &val3);
11354 if (!SWIG_IsOK(ecode3)) {
11355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11356 }
11357 arg3 = static_cast< int >(val3);
11358 }
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 {
11366 #if wxUSE_UNICODE
11367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11368 #else
11369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11370 #endif
11371 }
11372 {
11373 if (temp2)
11374 delete arg2;
11375 }
11376 return resultobj;
11377 fail:
11378 {
11379 if (temp2)
11380 delete arg2;
11381 }
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11387 PyObject *resultobj = 0;
11388 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11389 wxString result;
11390 void *argp1 = 0 ;
11391 int res1 = 0 ;
11392 PyObject *swig_obj[1] ;
11393
11394 if (!args) SWIG_fail;
11395 swig_obj[0] = args;
11396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11397 if (!SWIG_IsOK(res1)) {
11398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11399 }
11400 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (arg1)->FindNext();
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 {
11408 #if wxUSE_UNICODE
11409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11410 #else
11411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11412 #endif
11413 }
11414 return resultobj;
11415 fail:
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *obj;
11422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11423 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11424 return SWIG_Py_Void();
11425 }
11426
11427 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11428 return SWIG_Python_InitShadowInstance(args);
11429 }
11430
11431 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 wxImage *arg2 = 0 ;
11435 long arg3 ;
11436 bool temp1 = false ;
11437 void *argp2 = 0 ;
11438 int res2 = 0 ;
11439 long val3 ;
11440 int ecode3 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 PyObject * obj2 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "filename",(char *) "image",(char *) "type", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11455 if (!SWIG_IsOK(res2)) {
11456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11457 }
11458 if (!argp2) {
11459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11460 }
11461 arg2 = reinterpret_cast< wxImage * >(argp2);
11462 ecode3 = SWIG_AsVal_long(obj2, &val3);
11463 if (!SWIG_IsOK(ecode3)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11465 }
11466 arg3 = static_cast< long >(val3);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 {
11475 if (temp1)
11476 delete arg1;
11477 }
11478 return resultobj;
11479 fail:
11480 {
11481 if (temp1)
11482 delete arg1;
11483 }
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11489 PyObject *resultobj = 0;
11490 wxString *arg1 = 0 ;
11491 wxBitmap *arg2 = 0 ;
11492 long arg3 ;
11493 bool temp1 = false ;
11494 void *argp2 = 0 ;
11495 int res2 = 0 ;
11496 long val3 ;
11497 int ecode3 = 0 ;
11498 PyObject * obj0 = 0 ;
11499 PyObject * obj1 = 0 ;
11500 PyObject * obj2 = 0 ;
11501 char * kwnames[] = {
11502 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11503 };
11504
11505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11506 {
11507 arg1 = wxString_in_helper(obj0);
11508 if (arg1 == NULL) SWIG_fail;
11509 temp1 = true;
11510 }
11511 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11512 if (!SWIG_IsOK(res2)) {
11513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11514 }
11515 if (!argp2) {
11516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11517 }
11518 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11519 ecode3 = SWIG_AsVal_long(obj2, &val3);
11520 if (!SWIG_IsOK(ecode3)) {
11521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11522 }
11523 arg3 = static_cast< long >(val3);
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_Py_Void();
11531 {
11532 if (temp1)
11533 delete arg1;
11534 }
11535 return resultobj;
11536 fail:
11537 {
11538 if (temp1)
11539 delete arg1;
11540 }
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxString *arg1 = 0 ;
11548 PyObject *arg2 = (PyObject *) 0 ;
11549 bool temp1 = false ;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 char * kwnames[] = {
11553 (char *) "filename",(char *) "data", NULL
11554 };
11555
11556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11557 {
11558 arg1 = wxString_in_helper(obj0);
11559 if (arg1 == NULL) SWIG_fail;
11560 temp1 = true;
11561 }
11562 arg2 = obj1;
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 resultobj = SWIG_Py_Void();
11570 {
11571 if (temp1)
11572 delete arg1;
11573 }
11574 return resultobj;
11575 fail:
11576 {
11577 if (temp1)
11578 delete arg1;
11579 }
11580 return NULL;
11581 }
11582
11583
11584 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11585 PyObject *resultobj = 0;
11586 wxMemoryFSHandler *result = 0 ;
11587
11588 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj = 0;
11604 wxString *arg1 = 0 ;
11605 bool temp1 = false ;
11606 PyObject * obj0 = 0 ;
11607 char * kwnames[] = {
11608 (char *) "filename", NULL
11609 };
11610
11611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11612 {
11613 arg1 = wxString_in_helper(obj0);
11614 if (arg1 == NULL) SWIG_fail;
11615 temp1 = true;
11616 }
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 resultobj = SWIG_Py_Void();
11624 {
11625 if (temp1)
11626 delete arg1;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp1)
11632 delete arg1;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11639 PyObject *resultobj = 0;
11640 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11641 wxString *arg2 = 0 ;
11642 bool result;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 bool temp2 = false ;
11646 PyObject * obj0 = 0 ;
11647 PyObject * obj1 = 0 ;
11648 char * kwnames[] = {
11649 (char *) "self",(char *) "location", NULL
11650 };
11651
11652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11656 }
11657 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11658 {
11659 arg2 = wxString_in_helper(obj1);
11660 if (arg2 == NULL) SWIG_fail;
11661 temp2 = true;
11662 }
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 {
11670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11671 }
11672 {
11673 if (temp2)
11674 delete arg2;
11675 }
11676 return resultobj;
11677 fail:
11678 {
11679 if (temp2)
11680 delete arg2;
11681 }
11682 return NULL;
11683 }
11684
11685
11686 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11687 PyObject *resultobj = 0;
11688 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11689 wxFileSystem *arg2 = 0 ;
11690 wxString *arg3 = 0 ;
11691 wxFSFile *result = 0 ;
11692 void *argp1 = 0 ;
11693 int res1 = 0 ;
11694 void *argp2 = 0 ;
11695 int res2 = 0 ;
11696 bool temp3 = false ;
11697 PyObject * obj0 = 0 ;
11698 PyObject * obj1 = 0 ;
11699 PyObject * obj2 = 0 ;
11700 char * kwnames[] = {
11701 (char *) "self",(char *) "fs",(char *) "location", NULL
11702 };
11703
11704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11706 if (!SWIG_IsOK(res1)) {
11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11708 }
11709 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11711 if (!SWIG_IsOK(res2)) {
11712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11713 }
11714 if (!argp2) {
11715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11716 }
11717 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11718 {
11719 arg3 = wxString_in_helper(obj2);
11720 if (arg3 == NULL) SWIG_fail;
11721 temp3 = true;
11722 }
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 {
11730 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11731 }
11732 {
11733 if (temp3)
11734 delete arg3;
11735 }
11736 return resultobj;
11737 fail:
11738 {
11739 if (temp3)
11740 delete arg3;
11741 }
11742 return NULL;
11743 }
11744
11745
11746 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11747 PyObject *resultobj = 0;
11748 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11749 wxString *arg2 = 0 ;
11750 int arg3 = (int) 0 ;
11751 wxString result;
11752 void *argp1 = 0 ;
11753 int res1 = 0 ;
11754 bool temp2 = false ;
11755 int val3 ;
11756 int ecode3 = 0 ;
11757 PyObject * obj0 = 0 ;
11758 PyObject * obj1 = 0 ;
11759 PyObject * obj2 = 0 ;
11760 char * kwnames[] = {
11761 (char *) "self",(char *) "spec",(char *) "flags", NULL
11762 };
11763
11764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11768 }
11769 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11770 {
11771 arg2 = wxString_in_helper(obj1);
11772 if (arg2 == NULL) SWIG_fail;
11773 temp2 = true;
11774 }
11775 if (obj2) {
11776 ecode3 = SWIG_AsVal_int(obj2, &val3);
11777 if (!SWIG_IsOK(ecode3)) {
11778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11779 }
11780 arg3 = static_cast< int >(val3);
11781 }
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 {
11789 #if wxUSE_UNICODE
11790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11791 #else
11792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11793 #endif
11794 }
11795 {
11796 if (temp2)
11797 delete arg2;
11798 }
11799 return resultobj;
11800 fail:
11801 {
11802 if (temp2)
11803 delete arg2;
11804 }
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11810 PyObject *resultobj = 0;
11811 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11812 wxString result;
11813 void *argp1 = 0 ;
11814 int res1 = 0 ;
11815 PyObject *swig_obj[1] ;
11816
11817 if (!args) SWIG_fail;
11818 swig_obj[0] = args;
11819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11820 if (!SWIG_IsOK(res1)) {
11821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11822 }
11823 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (arg1)->FindNext();
11827 wxPyEndAllowThreads(__tstate);
11828 if (PyErr_Occurred()) SWIG_fail;
11829 }
11830 {
11831 #if wxUSE_UNICODE
11832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11833 #else
11834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11835 #endif
11836 }
11837 return resultobj;
11838 fail:
11839 return NULL;
11840 }
11841
11842
11843 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11844 PyObject *obj;
11845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11846 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11847 return SWIG_Py_Void();
11848 }
11849
11850 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11851 return SWIG_Python_InitShadowInstance(args);
11852 }
11853
11854 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11855 PyObject *resultobj = 0;
11856 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11857 wxString result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 PyObject *swig_obj[1] ;
11861
11862 if (!args) SWIG_fail;
11863 swig_obj[0] = args;
11864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11865 if (!SWIG_IsOK(res1)) {
11866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11867 }
11868 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 result = (arg1)->GetName();
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 #if wxUSE_UNICODE
11877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11878 #else
11879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11880 #endif
11881 }
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11889 PyObject *resultobj = 0;
11890 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11891 wxString result;
11892 void *argp1 = 0 ;
11893 int res1 = 0 ;
11894 PyObject *swig_obj[1] ;
11895
11896 if (!args) SWIG_fail;
11897 swig_obj[0] = args;
11898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11899 if (!SWIG_IsOK(res1)) {
11900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11901 }
11902 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (arg1)->GetExtension();
11906 wxPyEndAllowThreads(__tstate);
11907 if (PyErr_Occurred()) SWIG_fail;
11908 }
11909 {
11910 #if wxUSE_UNICODE
11911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11912 #else
11913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11914 #endif
11915 }
11916 return resultobj;
11917 fail:
11918 return NULL;
11919 }
11920
11921
11922 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11923 PyObject *resultobj = 0;
11924 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11925 long result;
11926 void *argp1 = 0 ;
11927 int res1 = 0 ;
11928 PyObject *swig_obj[1] ;
11929
11930 if (!args) SWIG_fail;
11931 swig_obj[0] = args;
11932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11933 if (!SWIG_IsOK(res1)) {
11934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11935 }
11936 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11937 {
11938 PyThreadState* __tstate = wxPyBeginAllowThreads();
11939 result = (long)(arg1)->GetType();
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 resultobj = SWIG_From_long(static_cast< long >(result));
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11951 PyObject *resultobj = 0;
11952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11953 wxString result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 PyObject *swig_obj[1] ;
11957
11958 if (!args) SWIG_fail;
11959 swig_obj[0] = args;
11960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11963 }
11964 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (arg1)->GetMimeType();
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 {
11972 #if wxUSE_UNICODE
11973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11974 #else
11975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11976 #endif
11977 }
11978 return resultobj;
11979 fail:
11980 return NULL;
11981 }
11982
11983
11984 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11985 PyObject *resultobj = 0;
11986 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11987 wxString *arg2 = 0 ;
11988 bool result;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 bool temp2 = false ;
11992 PyObject * obj0 = 0 ;
11993 PyObject * obj1 = 0 ;
11994 char * kwnames[] = {
11995 (char *) "self",(char *) "name", NULL
11996 };
11997
11998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12002 }
12003 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12004 {
12005 arg2 = wxString_in_helper(obj1);
12006 if (arg2 == NULL) SWIG_fail;
12007 temp2 = true;
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12017 }
12018 {
12019 if (temp2)
12020 delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (temp2)
12026 delete arg2;
12027 }
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12033 PyObject *resultobj = 0;
12034 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12035 wxInputStream *arg2 = 0 ;
12036 bool result;
12037 void *argp1 = 0 ;
12038 int res1 = 0 ;
12039 wxPyInputStream *temp2 ;
12040 bool created2 ;
12041 PyObject * obj0 = 0 ;
12042 PyObject * obj1 = 0 ;
12043 char * kwnames[] = {
12044 (char *) "self",(char *) "stream", NULL
12045 };
12046
12047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12049 if (!SWIG_IsOK(res1)) {
12050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12051 }
12052 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12053 {
12054 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12055 arg2 = temp2->m_wxis;
12056 created2 = false;
12057 } else {
12058 PyErr_Clear(); // clear the failure of the wxPyConvert above
12059 arg2 = wxPyCBInputStream_create(obj1, false);
12060 if (arg2 == NULL) {
12061 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12062 SWIG_fail;
12063 }
12064 created2 = true;
12065 }
12066 }
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = (bool)(arg1)->CanRead(*arg2);
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 {
12074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12075 }
12076 {
12077 if (created2) delete arg2;
12078 }
12079 return resultobj;
12080 fail:
12081 {
12082 if (created2) delete arg2;
12083 }
12084 return NULL;
12085 }
12086
12087
12088 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj = 0;
12090 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12091 wxString *arg2 = 0 ;
12092 void *argp1 = 0 ;
12093 int res1 = 0 ;
12094 bool temp2 = false ;
12095 PyObject * obj0 = 0 ;
12096 PyObject * obj1 = 0 ;
12097 char * kwnames[] = {
12098 (char *) "self",(char *) "name", NULL
12099 };
12100
12101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12103 if (!SWIG_IsOK(res1)) {
12104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12105 }
12106 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12107 {
12108 arg2 = wxString_in_helper(obj1);
12109 if (arg2 == NULL) SWIG_fail;
12110 temp2 = true;
12111 }
12112 {
12113 PyThreadState* __tstate = wxPyBeginAllowThreads();
12114 (arg1)->SetName((wxString const &)*arg2);
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 resultobj = SWIG_Py_Void();
12119 {
12120 if (temp2)
12121 delete arg2;
12122 }
12123 return resultobj;
12124 fail:
12125 {
12126 if (temp2)
12127 delete arg2;
12128 }
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj = 0;
12135 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12136 wxString *arg2 = 0 ;
12137 void *argp1 = 0 ;
12138 int res1 = 0 ;
12139 bool temp2 = false ;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 char * kwnames[] = {
12143 (char *) "self",(char *) "extension", NULL
12144 };
12145
12146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12148 if (!SWIG_IsOK(res1)) {
12149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12150 }
12151 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12152 {
12153 arg2 = wxString_in_helper(obj1);
12154 if (arg2 == NULL) SWIG_fail;
12155 temp2 = true;
12156 }
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 (arg1)->SetExtension((wxString const &)*arg2);
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_Py_Void();
12164 {
12165 if (temp2)
12166 delete arg2;
12167 }
12168 return resultobj;
12169 fail:
12170 {
12171 if (temp2)
12172 delete arg2;
12173 }
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12181 long arg2 ;
12182 void *argp1 = 0 ;
12183 int res1 = 0 ;
12184 long val2 ;
12185 int ecode2 = 0 ;
12186 PyObject * obj0 = 0 ;
12187 PyObject * obj1 = 0 ;
12188 char * kwnames[] = {
12189 (char *) "self",(char *) "type", NULL
12190 };
12191
12192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12194 if (!SWIG_IsOK(res1)) {
12195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12196 }
12197 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12198 ecode2 = SWIG_AsVal_long(obj1, &val2);
12199 if (!SWIG_IsOK(ecode2)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12201 }
12202 arg2 = static_cast< long >(val2);
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 (arg1)->SetType(arg2);
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_Py_Void();
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12219 wxString *arg2 = 0 ;
12220 void *argp1 = 0 ;
12221 int res1 = 0 ;
12222 bool temp2 = false ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 char * kwnames[] = {
12226 (char *) "self",(char *) "mimetype", NULL
12227 };
12228
12229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12233 }
12234 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12235 {
12236 arg2 = wxString_in_helper(obj1);
12237 if (arg2 == NULL) SWIG_fail;
12238 temp2 = true;
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 (arg1)->SetMimeType((wxString const &)*arg2);
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 resultobj = SWIG_Py_Void();
12247 {
12248 if (temp2)
12249 delete arg2;
12250 }
12251 return resultobj;
12252 fail:
12253 {
12254 if (temp2)
12255 delete arg2;
12256 }
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12262 PyObject *obj;
12263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12264 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12265 return SWIG_Py_Void();
12266 }
12267
12268 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 PyObject *resultobj = 0;
12270 wxPyImageHandler *result = 0 ;
12271
12272 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12273 {
12274 PyThreadState* __tstate = wxPyBeginAllowThreads();
12275 result = (wxPyImageHandler *)new wxPyImageHandler();
12276 wxPyEndAllowThreads(__tstate);
12277 if (PyErr_Occurred()) SWIG_fail;
12278 }
12279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj = 0;
12288 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12289 PyObject *arg2 = (PyObject *) 0 ;
12290 void *argp1 = 0 ;
12291 int res1 = 0 ;
12292 PyObject * obj0 = 0 ;
12293 PyObject * obj1 = 0 ;
12294 char * kwnames[] = {
12295 (char *) "self",(char *) "self", NULL
12296 };
12297
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12300 if (!SWIG_IsOK(res1)) {
12301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12302 }
12303 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12304 arg2 = obj1;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 (arg1)->_SetSelf(arg2);
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 resultobj = SWIG_Py_Void();
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12319 PyObject *obj;
12320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12321 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12322 return SWIG_Py_Void();
12323 }
12324
12325 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12326 return SWIG_Python_InitShadowInstance(args);
12327 }
12328
12329 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12330 PyObject *resultobj = 0;
12331 wxImageHistogram *result = 0 ;
12332
12333 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 result = (wxImageHistogram *)new wxImageHistogram();
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12348 PyObject *resultobj = 0;
12349 byte arg1 ;
12350 byte arg2 ;
12351 byte arg3 ;
12352 unsigned long result;
12353 unsigned char val1 ;
12354 int ecode1 = 0 ;
12355 unsigned char val2 ;
12356 int ecode2 = 0 ;
12357 unsigned char val3 ;
12358 int ecode3 = 0 ;
12359 PyObject * obj0 = 0 ;
12360 PyObject * obj1 = 0 ;
12361 PyObject * obj2 = 0 ;
12362 char * kwnames[] = {
12363 (char *) "r",(char *) "g",(char *) "b", NULL
12364 };
12365
12366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12367 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12368 if (!SWIG_IsOK(ecode1)) {
12369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12370 }
12371 arg1 = static_cast< byte >(val1);
12372 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12373 if (!SWIG_IsOK(ecode2)) {
12374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12375 }
12376 arg2 = static_cast< byte >(val2);
12377 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12378 if (!SWIG_IsOK(ecode3)) {
12379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12380 }
12381 arg3 = static_cast< byte >(val3);
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj = 0;
12397 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12398 byte *arg2 = (byte *) 0 ;
12399 byte *arg3 = (byte *) 0 ;
12400 byte *arg4 = (byte *) 0 ;
12401 byte arg5 = (byte) 1 ;
12402 byte arg6 = (byte) 0 ;
12403 byte arg7 = (byte) 0 ;
12404 bool result;
12405 void *argp1 = 0 ;
12406 int res1 = 0 ;
12407 byte temp2 ;
12408 int res2 = SWIG_TMPOBJ ;
12409 byte temp3 ;
12410 int res3 = SWIG_TMPOBJ ;
12411 byte temp4 ;
12412 int res4 = SWIG_TMPOBJ ;
12413 unsigned char val5 ;
12414 int ecode5 = 0 ;
12415 unsigned char val6 ;
12416 int ecode6 = 0 ;
12417 unsigned char val7 ;
12418 int ecode7 = 0 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 PyObject * obj2 = 0 ;
12422 PyObject * obj3 = 0 ;
12423 char * kwnames[] = {
12424 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12425 };
12426
12427 arg2 = &temp2;
12428 arg3 = &temp3;
12429 arg4 = &temp4;
12430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12432 if (!SWIG_IsOK(res1)) {
12433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12434 }
12435 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12436 if (obj1) {
12437 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12438 if (!SWIG_IsOK(ecode5)) {
12439 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12440 }
12441 arg5 = static_cast< byte >(val5);
12442 }
12443 if (obj2) {
12444 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12445 if (!SWIG_IsOK(ecode6)) {
12446 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12447 }
12448 arg6 = static_cast< byte >(val6);
12449 }
12450 if (obj3) {
12451 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12452 if (!SWIG_IsOK(ecode7)) {
12453 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12454 }
12455 arg7 = static_cast< byte >(val7);
12456 }
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 {
12464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12465 }
12466 if (SWIG_IsTmpObj(res2)) {
12467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12468 } else {
12469 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12471 }
12472 if (SWIG_IsTmpObj(res3)) {
12473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12474 } else {
12475 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12477 }
12478 if (SWIG_IsTmpObj(res4)) {
12479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12480 } else {
12481 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12483 }
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12491 PyObject *resultobj = 0;
12492 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12493 unsigned long arg2 ;
12494 unsigned long result;
12495 void *argp1 = 0 ;
12496 int res1 = 0 ;
12497 unsigned long val2 ;
12498 int ecode2 = 0 ;
12499 PyObject * obj0 = 0 ;
12500 PyObject * obj1 = 0 ;
12501 char * kwnames[] = {
12502 (char *) "self",(char *) "key", NULL
12503 };
12504
12505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12507 if (!SWIG_IsOK(res1)) {
12508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12509 }
12510 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12511 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12512 if (!SWIG_IsOK(ecode2)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12514 }
12515 arg2 = static_cast< unsigned long >(val2);
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12519 wxPyEndAllowThreads(__tstate);
12520 if (PyErr_Occurred()) SWIG_fail;
12521 }
12522 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12532 byte arg2 ;
12533 byte arg3 ;
12534 byte arg4 ;
12535 unsigned long result;
12536 void *argp1 = 0 ;
12537 int res1 = 0 ;
12538 unsigned char val2 ;
12539 int ecode2 = 0 ;
12540 unsigned char val3 ;
12541 int ecode3 = 0 ;
12542 unsigned char val4 ;
12543 int ecode4 = 0 ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 PyObject * obj2 = 0 ;
12547 PyObject * obj3 = 0 ;
12548 char * kwnames[] = {
12549 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12550 };
12551
12552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12554 if (!SWIG_IsOK(res1)) {
12555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12556 }
12557 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12558 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12559 if (!SWIG_IsOK(ecode2)) {
12560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12561 }
12562 arg2 = static_cast< byte >(val2);
12563 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12564 if (!SWIG_IsOK(ecode3)) {
12565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12566 }
12567 arg3 = static_cast< byte >(val3);
12568 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12569 if (!SWIG_IsOK(ecode4)) {
12570 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12571 }
12572 arg4 = static_cast< byte >(val4);
12573 {
12574 PyThreadState* __tstate = wxPyBeginAllowThreads();
12575 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12576 wxPyEndAllowThreads(__tstate);
12577 if (PyErr_Occurred()) SWIG_fail;
12578 }
12579 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12580 return resultobj;
12581 fail:
12582 return NULL;
12583 }
12584
12585
12586 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12587 PyObject *resultobj = 0;
12588 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12589 wxColour *arg2 = 0 ;
12590 unsigned long result;
12591 void *argp1 = 0 ;
12592 int res1 = 0 ;
12593 wxColour temp2 ;
12594 PyObject * obj0 = 0 ;
12595 PyObject * obj1 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "self",(char *) "colour", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12602 if (!SWIG_IsOK(res1)) {
12603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12604 }
12605 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12606 {
12607 arg2 = &temp2;
12608 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12617 return resultobj;
12618 fail:
12619 return NULL;
12620 }
12621
12622
12623 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12624 PyObject *obj;
12625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12626 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12627 return SWIG_Py_Void();
12628 }
12629
12630 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 return SWIG_Python_InitShadowInstance(args);
12632 }
12633
12634 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj = 0;
12636 byte arg1 = (byte) 0 ;
12637 byte arg2 = (byte) 0 ;
12638 byte arg3 = (byte) 0 ;
12639 wxImage_RGBValue *result = 0 ;
12640 unsigned char val1 ;
12641 int ecode1 = 0 ;
12642 unsigned char val2 ;
12643 int ecode2 = 0 ;
12644 unsigned char val3 ;
12645 int ecode3 = 0 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 PyObject * obj2 = 0 ;
12649 char * kwnames[] = {
12650 (char *) "r",(char *) "g",(char *) "b", NULL
12651 };
12652
12653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12654 if (obj0) {
12655 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12656 if (!SWIG_IsOK(ecode1)) {
12657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12658 }
12659 arg1 = static_cast< byte >(val1);
12660 }
12661 if (obj1) {
12662 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12663 if (!SWIG_IsOK(ecode2)) {
12664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12665 }
12666 arg2 = static_cast< byte >(val2);
12667 }
12668 if (obj2) {
12669 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12670 if (!SWIG_IsOK(ecode3)) {
12671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12672 }
12673 arg3 = static_cast< byte >(val3);
12674 }
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12689 PyObject *resultobj = 0;
12690 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12691 byte arg2 ;
12692 void *argp1 = 0 ;
12693 int res1 = 0 ;
12694 unsigned char val2 ;
12695 int ecode2 = 0 ;
12696 PyObject *swig_obj[2] ;
12697
12698 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12700 if (!SWIG_IsOK(res1)) {
12701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12702 }
12703 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12704 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12705 if (!SWIG_IsOK(ecode2)) {
12706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12707 }
12708 arg2 = static_cast< byte >(val2);
12709 if (arg1) (arg1)->red = arg2;
12710
12711 resultobj = SWIG_Py_Void();
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12719 PyObject *resultobj = 0;
12720 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12721 byte result;
12722 void *argp1 = 0 ;
12723 int res1 = 0 ;
12724 PyObject *swig_obj[1] ;
12725
12726 if (!args) SWIG_fail;
12727 swig_obj[0] = args;
12728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12729 if (!SWIG_IsOK(res1)) {
12730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12731 }
12732 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12733 result = (byte) ((arg1)->red);
12734 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12742 PyObject *resultobj = 0;
12743 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12744 byte arg2 ;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 unsigned char val2 ;
12748 int ecode2 = 0 ;
12749 PyObject *swig_obj[2] ;
12750
12751 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12753 if (!SWIG_IsOK(res1)) {
12754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12755 }
12756 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12757 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12758 if (!SWIG_IsOK(ecode2)) {
12759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12760 }
12761 arg2 = static_cast< byte >(val2);
12762 if (arg1) (arg1)->green = arg2;
12763
12764 resultobj = SWIG_Py_Void();
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12772 PyObject *resultobj = 0;
12773 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12774 byte result;
12775 void *argp1 = 0 ;
12776 int res1 = 0 ;
12777 PyObject *swig_obj[1] ;
12778
12779 if (!args) SWIG_fail;
12780 swig_obj[0] = args;
12781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12782 if (!SWIG_IsOK(res1)) {
12783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12784 }
12785 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12786 result = (byte) ((arg1)->green);
12787 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12788 return resultobj;
12789 fail:
12790 return NULL;
12791 }
12792
12793
12794 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12795 PyObject *resultobj = 0;
12796 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12797 byte arg2 ;
12798 void *argp1 = 0 ;
12799 int res1 = 0 ;
12800 unsigned char val2 ;
12801 int ecode2 = 0 ;
12802 PyObject *swig_obj[2] ;
12803
12804 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12806 if (!SWIG_IsOK(res1)) {
12807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12808 }
12809 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12810 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12811 if (!SWIG_IsOK(ecode2)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12813 }
12814 arg2 = static_cast< byte >(val2);
12815 if (arg1) (arg1)->blue = arg2;
12816
12817 resultobj = SWIG_Py_Void();
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12825 PyObject *resultobj = 0;
12826 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12827 byte result;
12828 void *argp1 = 0 ;
12829 int res1 = 0 ;
12830 PyObject *swig_obj[1] ;
12831
12832 if (!args) SWIG_fail;
12833 swig_obj[0] = args;
12834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12835 if (!SWIG_IsOK(res1)) {
12836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12837 }
12838 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12839 result = (byte) ((arg1)->blue);
12840 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12848 PyObject *obj;
12849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12850 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12851 return SWIG_Py_Void();
12852 }
12853
12854 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 return SWIG_Python_InitShadowInstance(args);
12856 }
12857
12858 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj = 0;
12860 double arg1 = (double) 0.0 ;
12861 double arg2 = (double) 0.0 ;
12862 double arg3 = (double) 0.0 ;
12863 wxImage_HSVValue *result = 0 ;
12864 double val1 ;
12865 int ecode1 = 0 ;
12866 double val2 ;
12867 int ecode2 = 0 ;
12868 double val3 ;
12869 int ecode3 = 0 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 char * kwnames[] = {
12874 (char *) "h",(char *) "s",(char *) "v", NULL
12875 };
12876
12877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12878 if (obj0) {
12879 ecode1 = SWIG_AsVal_double(obj0, &val1);
12880 if (!SWIG_IsOK(ecode1)) {
12881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12882 }
12883 arg1 = static_cast< double >(val1);
12884 }
12885 if (obj1) {
12886 ecode2 = SWIG_AsVal_double(obj1, &val2);
12887 if (!SWIG_IsOK(ecode2)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12889 }
12890 arg2 = static_cast< double >(val2);
12891 }
12892 if (obj2) {
12893 ecode3 = SWIG_AsVal_double(obj2, &val3);
12894 if (!SWIG_IsOK(ecode3)) {
12895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12896 }
12897 arg3 = static_cast< double >(val3);
12898 }
12899 {
12900 PyThreadState* __tstate = wxPyBeginAllowThreads();
12901 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 PyObject *resultobj = 0;
12914 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12915 double arg2 ;
12916 void *argp1 = 0 ;
12917 int res1 = 0 ;
12918 double val2 ;
12919 int ecode2 = 0 ;
12920 PyObject *swig_obj[2] ;
12921
12922 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12924 if (!SWIG_IsOK(res1)) {
12925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12926 }
12927 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12928 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12929 if (!SWIG_IsOK(ecode2)) {
12930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12931 }
12932 arg2 = static_cast< double >(val2);
12933 if (arg1) (arg1)->hue = arg2;
12934
12935 resultobj = SWIG_Py_Void();
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12943 PyObject *resultobj = 0;
12944 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12945 double result;
12946 void *argp1 = 0 ;
12947 int res1 = 0 ;
12948 PyObject *swig_obj[1] ;
12949
12950 if (!args) SWIG_fail;
12951 swig_obj[0] = args;
12952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12953 if (!SWIG_IsOK(res1)) {
12954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12955 }
12956 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12957 result = (double) ((arg1)->hue);
12958 resultobj = SWIG_From_double(static_cast< double >(result));
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12966 PyObject *resultobj = 0;
12967 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12968 double arg2 ;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 double val2 ;
12972 int ecode2 = 0 ;
12973 PyObject *swig_obj[2] ;
12974
12975 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12977 if (!SWIG_IsOK(res1)) {
12978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12979 }
12980 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12981 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12982 if (!SWIG_IsOK(ecode2)) {
12983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12984 }
12985 arg2 = static_cast< double >(val2);
12986 if (arg1) (arg1)->saturation = arg2;
12987
12988 resultobj = SWIG_Py_Void();
12989 return resultobj;
12990 fail:
12991 return NULL;
12992 }
12993
12994
12995 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12996 PyObject *resultobj = 0;
12997 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12998 double result;
12999 void *argp1 = 0 ;
13000 int res1 = 0 ;
13001 PyObject *swig_obj[1] ;
13002
13003 if (!args) SWIG_fail;
13004 swig_obj[0] = args;
13005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13006 if (!SWIG_IsOK(res1)) {
13007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13008 }
13009 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13010 result = (double) ((arg1)->saturation);
13011 resultobj = SWIG_From_double(static_cast< double >(result));
13012 return resultobj;
13013 fail:
13014 return NULL;
13015 }
13016
13017
13018 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13019 PyObject *resultobj = 0;
13020 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13021 double arg2 ;
13022 void *argp1 = 0 ;
13023 int res1 = 0 ;
13024 double val2 ;
13025 int ecode2 = 0 ;
13026 PyObject *swig_obj[2] ;
13027
13028 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13030 if (!SWIG_IsOK(res1)) {
13031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13032 }
13033 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13034 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13035 if (!SWIG_IsOK(ecode2)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13037 }
13038 arg2 = static_cast< double >(val2);
13039 if (arg1) (arg1)->value = arg2;
13040
13041 resultobj = SWIG_Py_Void();
13042 return resultobj;
13043 fail:
13044 return NULL;
13045 }
13046
13047
13048 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13049 PyObject *resultobj = 0;
13050 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13051 double result;
13052 void *argp1 = 0 ;
13053 int res1 = 0 ;
13054 PyObject *swig_obj[1] ;
13055
13056 if (!args) SWIG_fail;
13057 swig_obj[0] = args;
13058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13059 if (!SWIG_IsOK(res1)) {
13060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13061 }
13062 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13063 result = (double) ((arg1)->value);
13064 resultobj = SWIG_From_double(static_cast< double >(result));
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 PyObject *obj;
13073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13074 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13075 return SWIG_Py_Void();
13076 }
13077
13078 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 return SWIG_Python_InitShadowInstance(args);
13080 }
13081
13082 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13083 PyObject *resultobj = 0;
13084 wxString *arg1 = 0 ;
13085 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13086 int arg3 = (int) -1 ;
13087 wxImage *result = 0 ;
13088 bool temp1 = false ;
13089 long val2 ;
13090 int ecode2 = 0 ;
13091 int val3 ;
13092 int ecode3 = 0 ;
13093 PyObject * obj0 = 0 ;
13094 PyObject * obj1 = 0 ;
13095 PyObject * obj2 = 0 ;
13096 char * kwnames[] = {
13097 (char *) "name",(char *) "type",(char *) "index", NULL
13098 };
13099
13100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13101 {
13102 arg1 = wxString_in_helper(obj0);
13103 if (arg1 == NULL) SWIG_fail;
13104 temp1 = true;
13105 }
13106 if (obj1) {
13107 ecode2 = SWIG_AsVal_long(obj1, &val2);
13108 if (!SWIG_IsOK(ecode2)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13110 }
13111 arg2 = static_cast< long >(val2);
13112 }
13113 if (obj2) {
13114 ecode3 = SWIG_AsVal_int(obj2, &val3);
13115 if (!SWIG_IsOK(ecode3)) {
13116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13117 }
13118 arg3 = static_cast< int >(val3);
13119 }
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13127 {
13128 if (temp1)
13129 delete arg1;
13130 }
13131 return resultobj;
13132 fail:
13133 {
13134 if (temp1)
13135 delete arg1;
13136 }
13137 return NULL;
13138 }
13139
13140
13141 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13142 PyObject *resultobj = 0;
13143 wxImage *arg1 = (wxImage *) 0 ;
13144 void *argp1 = 0 ;
13145 int res1 = 0 ;
13146 PyObject *swig_obj[1] ;
13147
13148 if (!args) SWIG_fail;
13149 swig_obj[0] = args;
13150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13151 if (!SWIG_IsOK(res1)) {
13152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13153 }
13154 arg1 = reinterpret_cast< wxImage * >(argp1);
13155 {
13156 PyThreadState* __tstate = wxPyBeginAllowThreads();
13157 delete arg1;
13158
13159 wxPyEndAllowThreads(__tstate);
13160 if (PyErr_Occurred()) SWIG_fail;
13161 }
13162 resultobj = SWIG_Py_Void();
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = 0;
13171 wxString *arg1 = 0 ;
13172 wxString *arg2 = 0 ;
13173 int arg3 = (int) -1 ;
13174 wxImage *result = 0 ;
13175 bool temp1 = false ;
13176 bool temp2 = false ;
13177 int val3 ;
13178 int ecode3 = 0 ;
13179 PyObject * obj0 = 0 ;
13180 PyObject * obj1 = 0 ;
13181 PyObject * obj2 = 0 ;
13182 char * kwnames[] = {
13183 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13184 };
13185
13186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13187 {
13188 arg1 = wxString_in_helper(obj0);
13189 if (arg1 == NULL) SWIG_fail;
13190 temp1 = true;
13191 }
13192 {
13193 arg2 = wxString_in_helper(obj1);
13194 if (arg2 == NULL) SWIG_fail;
13195 temp2 = true;
13196 }
13197 if (obj2) {
13198 ecode3 = SWIG_AsVal_int(obj2, &val3);
13199 if (!SWIG_IsOK(ecode3)) {
13200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13201 }
13202 arg3 = static_cast< int >(val3);
13203 }
13204 {
13205 PyThreadState* __tstate = wxPyBeginAllowThreads();
13206 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13207 wxPyEndAllowThreads(__tstate);
13208 if (PyErr_Occurred()) SWIG_fail;
13209 }
13210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13211 {
13212 if (temp1)
13213 delete arg1;
13214 }
13215 {
13216 if (temp2)
13217 delete arg2;
13218 }
13219 return resultobj;
13220 fail:
13221 {
13222 if (temp1)
13223 delete arg1;
13224 }
13225 {
13226 if (temp2)
13227 delete arg2;
13228 }
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 wxInputStream *arg1 = 0 ;
13236 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13237 int arg3 = (int) -1 ;
13238 wxImage *result = 0 ;
13239 wxPyInputStream *temp1 ;
13240 bool created1 ;
13241 long val2 ;
13242 int ecode2 = 0 ;
13243 int val3 ;
13244 int ecode3 = 0 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 PyObject * obj2 = 0 ;
13248 char * kwnames[] = {
13249 (char *) "stream",(char *) "type",(char *) "index", NULL
13250 };
13251
13252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13253 {
13254 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13255 arg1 = temp1->m_wxis;
13256 created1 = false;
13257 } else {
13258 PyErr_Clear(); // clear the failure of the wxPyConvert above
13259 arg1 = wxPyCBInputStream_create(obj0, false);
13260 if (arg1 == NULL) {
13261 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13262 SWIG_fail;
13263 }
13264 created1 = true;
13265 }
13266 }
13267 if (obj1) {
13268 ecode2 = SWIG_AsVal_long(obj1, &val2);
13269 if (!SWIG_IsOK(ecode2)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13271 }
13272 arg2 = static_cast< long >(val2);
13273 }
13274 if (obj2) {
13275 ecode3 = SWIG_AsVal_int(obj2, &val3);
13276 if (!SWIG_IsOK(ecode3)) {
13277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13278 }
13279 arg3 = static_cast< int >(val3);
13280 }
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13288 {
13289 if (created1) delete arg1;
13290 }
13291 return resultobj;
13292 fail:
13293 {
13294 if (created1) delete arg1;
13295 }
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13301 PyObject *resultobj = 0;
13302 wxInputStream *arg1 = 0 ;
13303 wxString *arg2 = 0 ;
13304 int arg3 = (int) -1 ;
13305 wxImage *result = 0 ;
13306 wxPyInputStream *temp1 ;
13307 bool created1 ;
13308 bool temp2 = false ;
13309 int val3 ;
13310 int ecode3 = 0 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13319 {
13320 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13321 arg1 = temp1->m_wxis;
13322 created1 = false;
13323 } else {
13324 PyErr_Clear(); // clear the failure of the wxPyConvert above
13325 arg1 = wxPyCBInputStream_create(obj0, false);
13326 if (arg1 == NULL) {
13327 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13328 SWIG_fail;
13329 }
13330 created1 = true;
13331 }
13332 }
13333 {
13334 arg2 = wxString_in_helper(obj1);
13335 if (arg2 == NULL) SWIG_fail;
13336 temp2 = true;
13337 }
13338 if (obj2) {
13339 ecode3 = SWIG_AsVal_int(obj2, &val3);
13340 if (!SWIG_IsOK(ecode3)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13342 }
13343 arg3 = static_cast< int >(val3);
13344 }
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13352 {
13353 if (created1) delete arg1;
13354 }
13355 {
13356 if (temp2)
13357 delete arg2;
13358 }
13359 return resultobj;
13360 fail:
13361 {
13362 if (created1) delete arg1;
13363 }
13364 {
13365 if (temp2)
13366 delete arg2;
13367 }
13368 return NULL;
13369 }
13370
13371
13372 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj = 0;
13374 int arg1 = (int) 0 ;
13375 int arg2 = (int) 0 ;
13376 bool arg3 = (bool) true ;
13377 wxImage *result = 0 ;
13378 int val1 ;
13379 int ecode1 = 0 ;
13380 int val2 ;
13381 int ecode2 = 0 ;
13382 bool val3 ;
13383 int ecode3 = 0 ;
13384 PyObject * obj0 = 0 ;
13385 PyObject * obj1 = 0 ;
13386 PyObject * obj2 = 0 ;
13387 char * kwnames[] = {
13388 (char *) "width",(char *) "height",(char *) "clear", NULL
13389 };
13390
13391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13392 if (obj0) {
13393 ecode1 = SWIG_AsVal_int(obj0, &val1);
13394 if (!SWIG_IsOK(ecode1)) {
13395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13396 }
13397 arg1 = static_cast< int >(val1);
13398 }
13399 if (obj1) {
13400 ecode2 = SWIG_AsVal_int(obj1, &val2);
13401 if (!SWIG_IsOK(ecode2)) {
13402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13403 }
13404 arg2 = static_cast< int >(val2);
13405 }
13406 if (obj2) {
13407 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13408 if (!SWIG_IsOK(ecode3)) {
13409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13410 }
13411 arg3 = static_cast< bool >(val3);
13412 }
13413 {
13414 PyThreadState* __tstate = wxPyBeginAllowThreads();
13415 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13416 wxPyEndAllowThreads(__tstate);
13417 if (PyErr_Occurred()) SWIG_fail;
13418 }
13419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj = 0;
13428 wxBitmap *arg1 = 0 ;
13429 wxImage *result = 0 ;
13430 void *argp1 = 0 ;
13431 int res1 = 0 ;
13432 PyObject * obj0 = 0 ;
13433 char * kwnames[] = {
13434 (char *) "bitmap", NULL
13435 };
13436
13437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13438 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13439 if (!SWIG_IsOK(res1)) {
13440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13441 }
13442 if (!argp1) {
13443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13444 }
13445 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13446 {
13447 if (!wxPyCheckForApp()) SWIG_fail;
13448 PyThreadState* __tstate = wxPyBeginAllowThreads();
13449 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13454 return resultobj;
13455 fail:
13456 return NULL;
13457 }
13458
13459
13460 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13461 PyObject *resultobj = 0;
13462 int arg1 ;
13463 int arg2 ;
13464 buffer arg3 ;
13465 int arg4 ;
13466 wxImage *result = 0 ;
13467 int val1 ;
13468 int ecode1 = 0 ;
13469 int val2 ;
13470 int ecode2 = 0 ;
13471 Py_ssize_t temp3 ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 PyObject * obj2 = 0 ;
13475 char * kwnames[] = {
13476 (char *) "width",(char *) "height",(char *) "data", NULL
13477 };
13478
13479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13480 ecode1 = SWIG_AsVal_int(obj0, &val1);
13481 if (!SWIG_IsOK(ecode1)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13483 }
13484 arg1 = static_cast< int >(val1);
13485 ecode2 = SWIG_AsVal_int(obj1, &val2);
13486 if (!SWIG_IsOK(ecode2)) {
13487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13488 }
13489 arg2 = static_cast< int >(val2);
13490 {
13491 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13492 arg4 = (int)temp3;
13493 }
13494 {
13495 PyThreadState* __tstate = wxPyBeginAllowThreads();
13496 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13497 wxPyEndAllowThreads(__tstate);
13498 if (PyErr_Occurred()) SWIG_fail;
13499 }
13500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13501 return resultobj;
13502 fail:
13503 return NULL;
13504 }
13505
13506
13507 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13508 PyObject *resultobj = 0;
13509 int arg1 ;
13510 int arg2 ;
13511 buffer arg3 ;
13512 int arg4 ;
13513 buffer arg5 ;
13514 int arg6 ;
13515 wxImage *result = 0 ;
13516 int val1 ;
13517 int ecode1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 Py_ssize_t temp3 ;
13521 Py_ssize_t temp5 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 PyObject * obj3 = 0 ;
13526 char * kwnames[] = {
13527 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13528 };
13529
13530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13531 ecode1 = SWIG_AsVal_int(obj0, &val1);
13532 if (!SWIG_IsOK(ecode1)) {
13533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13534 }
13535 arg1 = static_cast< int >(val1);
13536 ecode2 = SWIG_AsVal_int(obj1, &val2);
13537 if (!SWIG_IsOK(ecode2)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13539 }
13540 arg2 = static_cast< int >(val2);
13541 {
13542 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13543 arg4 = (int)temp3;
13544 }
13545 {
13546 if (obj3 != Py_None) {
13547 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13548 arg6 = (int)temp5;
13549 }
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13558 return resultobj;
13559 fail:
13560 return NULL;
13561 }
13562
13563
13564 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13565 PyObject *resultobj = 0;
13566 wxImage *arg1 = (wxImage *) 0 ;
13567 int arg2 ;
13568 int arg3 ;
13569 bool arg4 = (bool) true ;
13570 void *argp1 = 0 ;
13571 int res1 = 0 ;
13572 int val2 ;
13573 int ecode2 = 0 ;
13574 int val3 ;
13575 int ecode3 = 0 ;
13576 bool val4 ;
13577 int ecode4 = 0 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 PyObject * obj2 = 0 ;
13581 PyObject * obj3 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13588 if (!SWIG_IsOK(res1)) {
13589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13590 }
13591 arg1 = reinterpret_cast< wxImage * >(argp1);
13592 ecode2 = SWIG_AsVal_int(obj1, &val2);
13593 if (!SWIG_IsOK(ecode2)) {
13594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13595 }
13596 arg2 = static_cast< int >(val2);
13597 ecode3 = SWIG_AsVal_int(obj2, &val3);
13598 if (!SWIG_IsOK(ecode3)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13600 }
13601 arg3 = static_cast< int >(val3);
13602 if (obj3) {
13603 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13604 if (!SWIG_IsOK(ecode4)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13606 }
13607 arg4 = static_cast< bool >(val4);
13608 }
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 (arg1)->Create(arg2,arg3,arg4);
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_Py_Void();
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 PyObject *swig_obj[1] ;
13628
13629 if (!args) SWIG_fail;
13630 swig_obj[0] = args;
13631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13634 }
13635 arg1 = reinterpret_cast< wxImage * >(argp1);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 (arg1)->Destroy();
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_Py_Void();
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxImage *arg1 = (wxImage *) 0 ;
13652 int arg2 ;
13653 int arg3 ;
13654 SwigValueWrapper<wxImage > result;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 int val2 ;
13658 int ecode2 = 0 ;
13659 int val3 ;
13660 int ecode3 = 0 ;
13661 PyObject * obj0 = 0 ;
13662 PyObject * obj1 = 0 ;
13663 PyObject * obj2 = 0 ;
13664 char * kwnames[] = {
13665 (char *) "self",(char *) "width",(char *) "height", NULL
13666 };
13667
13668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13670 if (!SWIG_IsOK(res1)) {
13671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13672 }
13673 arg1 = reinterpret_cast< wxImage * >(argp1);
13674 ecode2 = SWIG_AsVal_int(obj1, &val2);
13675 if (!SWIG_IsOK(ecode2)) {
13676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13677 }
13678 arg2 = static_cast< int >(val2);
13679 ecode3 = SWIG_AsVal_int(obj2, &val3);
13680 if (!SWIG_IsOK(ecode3)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13682 }
13683 arg3 = static_cast< int >(val3);
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 result = (arg1)->Scale(arg2,arg3);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13691 return resultobj;
13692 fail:
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxImage *arg1 = (wxImage *) 0 ;
13700 int arg2 ;
13701 int arg3 ;
13702 SwigValueWrapper<wxImage > result;
13703 void *argp1 = 0 ;
13704 int res1 = 0 ;
13705 int val2 ;
13706 int ecode2 = 0 ;
13707 int val3 ;
13708 int ecode3 = 0 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 PyObject * obj2 = 0 ;
13712 char * kwnames[] = {
13713 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13714 };
13715
13716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13718 if (!SWIG_IsOK(res1)) {
13719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13720 }
13721 arg1 = reinterpret_cast< wxImage * >(argp1);
13722 ecode2 = SWIG_AsVal_int(obj1, &val2);
13723 if (!SWIG_IsOK(ecode2)) {
13724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13725 }
13726 arg2 = static_cast< int >(val2);
13727 ecode3 = SWIG_AsVal_int(obj2, &val3);
13728 if (!SWIG_IsOK(ecode3)) {
13729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13730 }
13731 arg3 = static_cast< int >(val3);
13732 {
13733 PyThreadState* __tstate = wxPyBeginAllowThreads();
13734 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13735 wxPyEndAllowThreads(__tstate);
13736 if (PyErr_Occurred()) SWIG_fail;
13737 }
13738 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13739 return resultobj;
13740 fail:
13741 return NULL;
13742 }
13743
13744
13745 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13746 PyObject *resultobj = 0;
13747 wxImage *arg1 = (wxImage *) 0 ;
13748 int arg2 ;
13749 int arg3 ;
13750 wxImage *result = 0 ;
13751 void *argp1 = 0 ;
13752 int res1 = 0 ;
13753 int val2 ;
13754 int ecode2 = 0 ;
13755 int val3 ;
13756 int ecode3 = 0 ;
13757 PyObject * obj0 = 0 ;
13758 PyObject * obj1 = 0 ;
13759 PyObject * obj2 = 0 ;
13760 char * kwnames[] = {
13761 (char *) "self",(char *) "width",(char *) "height", NULL
13762 };
13763
13764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13766 if (!SWIG_IsOK(res1)) {
13767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13768 }
13769 arg1 = reinterpret_cast< wxImage * >(argp1);
13770 ecode2 = SWIG_AsVal_int(obj1, &val2);
13771 if (!SWIG_IsOK(ecode2)) {
13772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13773 }
13774 arg2 = static_cast< int >(val2);
13775 ecode3 = SWIG_AsVal_int(obj2, &val3);
13776 if (!SWIG_IsOK(ecode3)) {
13777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13778 }
13779 arg3 = static_cast< int >(val3);
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 {
13783 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13784 result = (wxImage *) &_result_ref;
13785 }
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13790 return resultobj;
13791 fail:
13792 return NULL;
13793 }
13794
13795
13796 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13797 PyObject *resultobj = 0;
13798 wxImage *arg1 = (wxImage *) 0 ;
13799 wxSize *arg2 = 0 ;
13800 wxPoint *arg3 = 0 ;
13801 int arg4 = (int) -1 ;
13802 int arg5 = (int) -1 ;
13803 int arg6 = (int) -1 ;
13804 wxImage *result = 0 ;
13805 void *argp1 = 0 ;
13806 int res1 = 0 ;
13807 wxSize temp2 ;
13808 wxPoint temp3 ;
13809 int val4 ;
13810 int ecode4 = 0 ;
13811 int val5 ;
13812 int ecode5 = 0 ;
13813 int val6 ;
13814 int ecode6 = 0 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 PyObject * obj3 = 0 ;
13819 PyObject * obj4 = 0 ;
13820 PyObject * obj5 = 0 ;
13821 char * kwnames[] = {
13822 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13823 };
13824
13825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13827 if (!SWIG_IsOK(res1)) {
13828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13829 }
13830 arg1 = reinterpret_cast< wxImage * >(argp1);
13831 {
13832 arg2 = &temp2;
13833 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13834 }
13835 {
13836 arg3 = &temp3;
13837 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13838 }
13839 if (obj3) {
13840 ecode4 = SWIG_AsVal_int(obj3, &val4);
13841 if (!SWIG_IsOK(ecode4)) {
13842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13843 }
13844 arg4 = static_cast< int >(val4);
13845 }
13846 if (obj4) {
13847 ecode5 = SWIG_AsVal_int(obj4, &val5);
13848 if (!SWIG_IsOK(ecode5)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13850 }
13851 arg5 = static_cast< int >(val5);
13852 }
13853 if (obj5) {
13854 ecode6 = SWIG_AsVal_int(obj5, &val6);
13855 if (!SWIG_IsOK(ecode6)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13857 }
13858 arg6 = static_cast< int >(val6);
13859 }
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 {
13863 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13864 result = (wxImage *) &_result_ref;
13865 }
13866 wxPyEndAllowThreads(__tstate);
13867 if (PyErr_Occurred()) SWIG_fail;
13868 }
13869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13870 return resultobj;
13871 fail:
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj = 0;
13878 wxImage *arg1 = (wxImage *) 0 ;
13879 int arg2 ;
13880 int arg3 ;
13881 byte arg4 ;
13882 byte arg5 ;
13883 byte arg6 ;
13884 void *argp1 = 0 ;
13885 int res1 = 0 ;
13886 int val2 ;
13887 int ecode2 = 0 ;
13888 int val3 ;
13889 int ecode3 = 0 ;
13890 unsigned char val4 ;
13891 int ecode4 = 0 ;
13892 unsigned char val5 ;
13893 int ecode5 = 0 ;
13894 unsigned char val6 ;
13895 int ecode6 = 0 ;
13896 PyObject * obj0 = 0 ;
13897 PyObject * obj1 = 0 ;
13898 PyObject * obj2 = 0 ;
13899 PyObject * obj3 = 0 ;
13900 PyObject * obj4 = 0 ;
13901 PyObject * obj5 = 0 ;
13902 char * kwnames[] = {
13903 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13904 };
13905
13906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13908 if (!SWIG_IsOK(res1)) {
13909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13910 }
13911 arg1 = reinterpret_cast< wxImage * >(argp1);
13912 ecode2 = SWIG_AsVal_int(obj1, &val2);
13913 if (!SWIG_IsOK(ecode2)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13915 }
13916 arg2 = static_cast< int >(val2);
13917 ecode3 = SWIG_AsVal_int(obj2, &val3);
13918 if (!SWIG_IsOK(ecode3)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13920 }
13921 arg3 = static_cast< int >(val3);
13922 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13923 if (!SWIG_IsOK(ecode4)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13925 }
13926 arg4 = static_cast< byte >(val4);
13927 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13928 if (!SWIG_IsOK(ecode5)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13930 }
13931 arg5 = static_cast< byte >(val5);
13932 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13933 if (!SWIG_IsOK(ecode6)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13935 }
13936 arg6 = static_cast< byte >(val6);
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 resultobj = SWIG_Py_Void();
13944 return resultobj;
13945 fail:
13946 return NULL;
13947 }
13948
13949
13950 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13951 PyObject *resultobj = 0;
13952 wxImage *arg1 = (wxImage *) 0 ;
13953 wxRect *arg2 = 0 ;
13954 byte arg3 ;
13955 byte arg4 ;
13956 byte arg5 ;
13957 void *argp1 = 0 ;
13958 int res1 = 0 ;
13959 wxRect temp2 ;
13960 unsigned char val3 ;
13961 int ecode3 = 0 ;
13962 unsigned char val4 ;
13963 int ecode4 = 0 ;
13964 unsigned char val5 ;
13965 int ecode5 = 0 ;
13966 PyObject * obj0 = 0 ;
13967 PyObject * obj1 = 0 ;
13968 PyObject * obj2 = 0 ;
13969 PyObject * obj3 = 0 ;
13970 PyObject * obj4 = 0 ;
13971 char * kwnames[] = {
13972 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13973 };
13974
13975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13977 if (!SWIG_IsOK(res1)) {
13978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13979 }
13980 arg1 = reinterpret_cast< wxImage * >(argp1);
13981 {
13982 arg2 = &temp2;
13983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13984 }
13985 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13986 if (!SWIG_IsOK(ecode3)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13988 }
13989 arg3 = static_cast< byte >(val3);
13990 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13991 if (!SWIG_IsOK(ecode4)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13993 }
13994 arg4 = static_cast< byte >(val4);
13995 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13996 if (!SWIG_IsOK(ecode5)) {
13997 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13998 }
13999 arg5 = static_cast< byte >(val5);
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14003 wxPyEndAllowThreads(__tstate);
14004 if (PyErr_Occurred()) SWIG_fail;
14005 }
14006 resultobj = SWIG_Py_Void();
14007 return resultobj;
14008 fail:
14009 return NULL;
14010 }
14011
14012
14013 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14014 PyObject *resultobj = 0;
14015 wxImage *arg1 = (wxImage *) 0 ;
14016 int arg2 ;
14017 int arg3 ;
14018 byte result;
14019 void *argp1 = 0 ;
14020 int res1 = 0 ;
14021 int val2 ;
14022 int ecode2 = 0 ;
14023 int val3 ;
14024 int ecode3 = 0 ;
14025 PyObject * obj0 = 0 ;
14026 PyObject * obj1 = 0 ;
14027 PyObject * obj2 = 0 ;
14028 char * kwnames[] = {
14029 (char *) "self",(char *) "x",(char *) "y", NULL
14030 };
14031
14032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14034 if (!SWIG_IsOK(res1)) {
14035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14036 }
14037 arg1 = reinterpret_cast< wxImage * >(argp1);
14038 ecode2 = SWIG_AsVal_int(obj1, &val2);
14039 if (!SWIG_IsOK(ecode2)) {
14040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14041 }
14042 arg2 = static_cast< int >(val2);
14043 ecode3 = SWIG_AsVal_int(obj2, &val3);
14044 if (!SWIG_IsOK(ecode3)) {
14045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14046 }
14047 arg3 = static_cast< int >(val3);
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 result = (byte)(arg1)->GetRed(arg2,arg3);
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj = 0;
14063 wxImage *arg1 = (wxImage *) 0 ;
14064 int arg2 ;
14065 int arg3 ;
14066 byte result;
14067 void *argp1 = 0 ;
14068 int res1 = 0 ;
14069 int val2 ;
14070 int ecode2 = 0 ;
14071 int val3 ;
14072 int ecode3 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 PyObject * obj2 = 0 ;
14076 char * kwnames[] = {
14077 (char *) "self",(char *) "x",(char *) "y", NULL
14078 };
14079
14080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14082 if (!SWIG_IsOK(res1)) {
14083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14084 }
14085 arg1 = reinterpret_cast< wxImage * >(argp1);
14086 ecode2 = SWIG_AsVal_int(obj1, &val2);
14087 if (!SWIG_IsOK(ecode2)) {
14088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14089 }
14090 arg2 = static_cast< int >(val2);
14091 ecode3 = SWIG_AsVal_int(obj2, &val3);
14092 if (!SWIG_IsOK(ecode3)) {
14093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14094 }
14095 arg3 = static_cast< int >(val3);
14096 {
14097 PyThreadState* __tstate = wxPyBeginAllowThreads();
14098 result = (byte)(arg1)->GetGreen(arg2,arg3);
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14103 return resultobj;
14104 fail:
14105 return NULL;
14106 }
14107
14108
14109 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14110 PyObject *resultobj = 0;
14111 wxImage *arg1 = (wxImage *) 0 ;
14112 int arg2 ;
14113 int arg3 ;
14114 byte result;
14115 void *argp1 = 0 ;
14116 int res1 = 0 ;
14117 int val2 ;
14118 int ecode2 = 0 ;
14119 int val3 ;
14120 int ecode3 = 0 ;
14121 PyObject * obj0 = 0 ;
14122 PyObject * obj1 = 0 ;
14123 PyObject * obj2 = 0 ;
14124 char * kwnames[] = {
14125 (char *) "self",(char *) "x",(char *) "y", NULL
14126 };
14127
14128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14130 if (!SWIG_IsOK(res1)) {
14131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14132 }
14133 arg1 = reinterpret_cast< wxImage * >(argp1);
14134 ecode2 = SWIG_AsVal_int(obj1, &val2);
14135 if (!SWIG_IsOK(ecode2)) {
14136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14137 }
14138 arg2 = static_cast< int >(val2);
14139 ecode3 = SWIG_AsVal_int(obj2, &val3);
14140 if (!SWIG_IsOK(ecode3)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14142 }
14143 arg3 = static_cast< int >(val3);
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (byte)(arg1)->GetBlue(arg2,arg3);
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj = 0;
14159 wxImage *arg1 = (wxImage *) 0 ;
14160 int arg2 ;
14161 int arg3 ;
14162 byte arg4 ;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 int val2 ;
14166 int ecode2 = 0 ;
14167 int val3 ;
14168 int ecode3 = 0 ;
14169 unsigned char val4 ;
14170 int ecode4 = 0 ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 PyObject * obj3 = 0 ;
14175 char * kwnames[] = {
14176 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14177 };
14178
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14183 }
14184 arg1 = reinterpret_cast< wxImage * >(argp1);
14185 ecode2 = SWIG_AsVal_int(obj1, &val2);
14186 if (!SWIG_IsOK(ecode2)) {
14187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14188 }
14189 arg2 = static_cast< int >(val2);
14190 ecode3 = SWIG_AsVal_int(obj2, &val3);
14191 if (!SWIG_IsOK(ecode3)) {
14192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14193 }
14194 arg3 = static_cast< int >(val3);
14195 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14196 if (!SWIG_IsOK(ecode4)) {
14197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14198 }
14199 arg4 = static_cast< byte >(val4);
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 (arg1)->SetAlpha(arg2,arg3,arg4);
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 resultobj = SWIG_Py_Void();
14207 return resultobj;
14208 fail:
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj = 0;
14215 wxImage *arg1 = (wxImage *) 0 ;
14216 int arg2 ;
14217 int arg3 ;
14218 byte result;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 int val2 ;
14222 int ecode2 = 0 ;
14223 int val3 ;
14224 int ecode3 = 0 ;
14225 PyObject * obj0 = 0 ;
14226 PyObject * obj1 = 0 ;
14227 PyObject * obj2 = 0 ;
14228 char * kwnames[] = {
14229 (char *) "self",(char *) "x",(char *) "y", NULL
14230 };
14231
14232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14234 if (!SWIG_IsOK(res1)) {
14235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14236 }
14237 arg1 = reinterpret_cast< wxImage * >(argp1);
14238 ecode2 = SWIG_AsVal_int(obj1, &val2);
14239 if (!SWIG_IsOK(ecode2)) {
14240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14241 }
14242 arg2 = static_cast< int >(val2);
14243 ecode3 = SWIG_AsVal_int(obj2, &val3);
14244 if (!SWIG_IsOK(ecode3)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14246 }
14247 arg3 = static_cast< int >(val3);
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14262 PyObject *resultobj = 0;
14263 wxImage *arg1 = (wxImage *) 0 ;
14264 bool result;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 PyObject *swig_obj[1] ;
14268
14269 if (!args) SWIG_fail;
14270 swig_obj[0] = args;
14271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14272 if (!SWIG_IsOK(res1)) {
14273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14274 }
14275 arg1 = reinterpret_cast< wxImage * >(argp1);
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (bool)(arg1)->HasAlpha();
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 {
14283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14284 }
14285 return resultobj;
14286 fail:
14287 return NULL;
14288 }
14289
14290
14291 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14292 PyObject *resultobj = 0;
14293 wxImage *arg1 = (wxImage *) 0 ;
14294 void *argp1 = 0 ;
14295 int res1 = 0 ;
14296 PyObject *swig_obj[1] ;
14297
14298 if (!args) SWIG_fail;
14299 swig_obj[0] = args;
14300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14301 if (!SWIG_IsOK(res1)) {
14302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14303 }
14304 arg1 = reinterpret_cast< wxImage * >(argp1);
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 (arg1)->InitAlpha();
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 resultobj = SWIG_Py_Void();
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj = 0;
14320 wxImage *arg1 = (wxImage *) 0 ;
14321 int arg2 ;
14322 int arg3 ;
14323 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14324 bool result;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 int val2 ;
14328 int ecode2 = 0 ;
14329 int val3 ;
14330 int ecode3 = 0 ;
14331 unsigned char val4 ;
14332 int ecode4 = 0 ;
14333 PyObject * obj0 = 0 ;
14334 PyObject * obj1 = 0 ;
14335 PyObject * obj2 = 0 ;
14336 PyObject * obj3 = 0 ;
14337 char * kwnames[] = {
14338 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14339 };
14340
14341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14343 if (!SWIG_IsOK(res1)) {
14344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14345 }
14346 arg1 = reinterpret_cast< wxImage * >(argp1);
14347 ecode2 = SWIG_AsVal_int(obj1, &val2);
14348 if (!SWIG_IsOK(ecode2)) {
14349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14350 }
14351 arg2 = static_cast< int >(val2);
14352 ecode3 = SWIG_AsVal_int(obj2, &val3);
14353 if (!SWIG_IsOK(ecode3)) {
14354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14355 }
14356 arg3 = static_cast< int >(val3);
14357 if (obj3) {
14358 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14359 if (!SWIG_IsOK(ecode4)) {
14360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14361 }
14362 arg4 = static_cast< byte >(val4);
14363 }
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14367 wxPyEndAllowThreads(__tstate);
14368 if (PyErr_Occurred()) SWIG_fail;
14369 }
14370 {
14371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14372 }
14373 return resultobj;
14374 fail:
14375 return NULL;
14376 }
14377
14378
14379 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14380 PyObject *resultobj = 0;
14381 wxImage *arg1 = (wxImage *) 0 ;
14382 byte *arg2 = (byte *) 0 ;
14383 byte *arg3 = (byte *) 0 ;
14384 byte *arg4 = (byte *) 0 ;
14385 byte arg5 = (byte) 0 ;
14386 byte arg6 = (byte) 0 ;
14387 byte arg7 = (byte) 0 ;
14388 bool result;
14389 void *argp1 = 0 ;
14390 int res1 = 0 ;
14391 byte temp2 ;
14392 int res2 = SWIG_TMPOBJ ;
14393 byte temp3 ;
14394 int res3 = SWIG_TMPOBJ ;
14395 byte temp4 ;
14396 int res4 = SWIG_TMPOBJ ;
14397 unsigned char val5 ;
14398 int ecode5 = 0 ;
14399 unsigned char val6 ;
14400 int ecode6 = 0 ;
14401 unsigned char val7 ;
14402 int ecode7 = 0 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 PyObject * obj2 = 0 ;
14406 PyObject * obj3 = 0 ;
14407 char * kwnames[] = {
14408 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14409 };
14410
14411 arg2 = &temp2;
14412 arg3 = &temp3;
14413 arg4 = &temp4;
14414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14416 if (!SWIG_IsOK(res1)) {
14417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14418 }
14419 arg1 = reinterpret_cast< wxImage * >(argp1);
14420 if (obj1) {
14421 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14422 if (!SWIG_IsOK(ecode5)) {
14423 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14424 }
14425 arg5 = static_cast< byte >(val5);
14426 }
14427 if (obj2) {
14428 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14429 if (!SWIG_IsOK(ecode6)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14431 }
14432 arg6 = static_cast< byte >(val6);
14433 }
14434 if (obj3) {
14435 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14436 if (!SWIG_IsOK(ecode7)) {
14437 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14438 }
14439 arg7 = static_cast< byte >(val7);
14440 }
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 {
14448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14449 }
14450 if (SWIG_IsTmpObj(res2)) {
14451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14452 } else {
14453 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14455 }
14456 if (SWIG_IsTmpObj(res3)) {
14457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14458 } else {
14459 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14461 }
14462 if (SWIG_IsTmpObj(res4)) {
14463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14464 } else {
14465 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14467 }
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj = 0;
14476 wxImage *arg1 = (wxImage *) 0 ;
14477 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14478 bool result;
14479 void *argp1 = 0 ;
14480 int res1 = 0 ;
14481 unsigned char val2 ;
14482 int ecode2 = 0 ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "threshold", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14493 }
14494 arg1 = reinterpret_cast< wxImage * >(argp1);
14495 if (obj1) {
14496 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14497 if (!SWIG_IsOK(ecode2)) {
14498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14499 }
14500 arg2 = static_cast< byte >(val2);
14501 }
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxImage *arg1 = (wxImage *) 0 ;
14520 byte arg2 ;
14521 byte arg3 ;
14522 byte arg4 ;
14523 bool result;
14524 void *argp1 = 0 ;
14525 int res1 = 0 ;
14526 unsigned char val2 ;
14527 int ecode2 = 0 ;
14528 unsigned char val3 ;
14529 int ecode3 = 0 ;
14530 unsigned char val4 ;
14531 int ecode4 = 0 ;
14532 PyObject * obj0 = 0 ;
14533 PyObject * obj1 = 0 ;
14534 PyObject * obj2 = 0 ;
14535 PyObject * obj3 = 0 ;
14536 char * kwnames[] = {
14537 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14538 };
14539
14540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14542 if (!SWIG_IsOK(res1)) {
14543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14544 }
14545 arg1 = reinterpret_cast< wxImage * >(argp1);
14546 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14547 if (!SWIG_IsOK(ecode2)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14549 }
14550 arg2 = static_cast< byte >(val2);
14551 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14552 if (!SWIG_IsOK(ecode3)) {
14553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14554 }
14555 arg3 = static_cast< byte >(val3);
14556 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14557 if (!SWIG_IsOK(ecode4)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14559 }
14560 arg4 = static_cast< byte >(val4);
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 {
14568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14569 }
14570 return resultobj;
14571 fail:
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14577 PyObject *resultobj = 0;
14578 wxImage *arg1 = (wxImage *) 0 ;
14579 wxImage *arg2 = 0 ;
14580 byte arg3 ;
14581 byte arg4 ;
14582 byte arg5 ;
14583 bool result;
14584 void *argp1 = 0 ;
14585 int res1 = 0 ;
14586 void *argp2 = 0 ;
14587 int res2 = 0 ;
14588 unsigned char val3 ;
14589 int ecode3 = 0 ;
14590 unsigned char val4 ;
14591 int ecode4 = 0 ;
14592 unsigned char val5 ;
14593 int ecode5 = 0 ;
14594 PyObject * obj0 = 0 ;
14595 PyObject * obj1 = 0 ;
14596 PyObject * obj2 = 0 ;
14597 PyObject * obj3 = 0 ;
14598 PyObject * obj4 = 0 ;
14599 char * kwnames[] = {
14600 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14601 };
14602
14603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14605 if (!SWIG_IsOK(res1)) {
14606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14607 }
14608 arg1 = reinterpret_cast< wxImage * >(argp1);
14609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14610 if (!SWIG_IsOK(res2)) {
14611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14612 }
14613 if (!argp2) {
14614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14615 }
14616 arg2 = reinterpret_cast< wxImage * >(argp2);
14617 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14618 if (!SWIG_IsOK(ecode3)) {
14619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14620 }
14621 arg3 = static_cast< byte >(val3);
14622 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14623 if (!SWIG_IsOK(ecode4)) {
14624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14625 }
14626 arg4 = static_cast< byte >(val4);
14627 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14628 if (!SWIG_IsOK(ecode5)) {
14629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14630 }
14631 arg5 = static_cast< byte >(val5);
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 {
14639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14640 }
14641 return resultobj;
14642 fail:
14643 return NULL;
14644 }
14645
14646
14647 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14648 PyObject *resultobj = 0;
14649 wxString *arg1 = 0 ;
14650 bool result;
14651 bool temp1 = false ;
14652 PyObject * obj0 = 0 ;
14653 char * kwnames[] = {
14654 (char *) "filename", NULL
14655 };
14656
14657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14658 {
14659 arg1 = wxString_in_helper(obj0);
14660 if (arg1 == NULL) SWIG_fail;
14661 temp1 = true;
14662 }
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 {
14670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14671 }
14672 {
14673 if (temp1)
14674 delete arg1;
14675 }
14676 return resultobj;
14677 fail:
14678 {
14679 if (temp1)
14680 delete arg1;
14681 }
14682 return NULL;
14683 }
14684
14685
14686 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14687 PyObject *resultobj = 0;
14688 wxString *arg1 = 0 ;
14689 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14690 int result;
14691 bool temp1 = false ;
14692 long val2 ;
14693 int ecode2 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "filename",(char *) "type", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14701 {
14702 arg1 = wxString_in_helper(obj0);
14703 if (arg1 == NULL) SWIG_fail;
14704 temp1 = true;
14705 }
14706 if (obj1) {
14707 ecode2 = SWIG_AsVal_long(obj1, &val2);
14708 if (!SWIG_IsOK(ecode2)) {
14709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14710 }
14711 arg2 = static_cast< long >(val2);
14712 }
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14716 wxPyEndAllowThreads(__tstate);
14717 if (PyErr_Occurred()) SWIG_fail;
14718 }
14719 resultobj = SWIG_From_int(static_cast< int >(result));
14720 {
14721 if (temp1)
14722 delete arg1;
14723 }
14724 return resultobj;
14725 fail:
14726 {
14727 if (temp1)
14728 delete arg1;
14729 }
14730 return NULL;
14731 }
14732
14733
14734 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj = 0;
14736 wxImage *arg1 = (wxImage *) 0 ;
14737 wxString *arg2 = 0 ;
14738 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14739 int arg4 = (int) -1 ;
14740 bool result;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 bool temp2 = false ;
14744 long val3 ;
14745 int ecode3 = 0 ;
14746 int val4 ;
14747 int ecode4 = 0 ;
14748 PyObject * obj0 = 0 ;
14749 PyObject * obj1 = 0 ;
14750 PyObject * obj2 = 0 ;
14751 PyObject * obj3 = 0 ;
14752 char * kwnames[] = {
14753 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14754 };
14755
14756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14758 if (!SWIG_IsOK(res1)) {
14759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14760 }
14761 arg1 = reinterpret_cast< wxImage * >(argp1);
14762 {
14763 arg2 = wxString_in_helper(obj1);
14764 if (arg2 == NULL) SWIG_fail;
14765 temp2 = true;
14766 }
14767 if (obj2) {
14768 ecode3 = SWIG_AsVal_long(obj2, &val3);
14769 if (!SWIG_IsOK(ecode3)) {
14770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14771 }
14772 arg3 = static_cast< long >(val3);
14773 }
14774 if (obj3) {
14775 ecode4 = SWIG_AsVal_int(obj3, &val4);
14776 if (!SWIG_IsOK(ecode4)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14778 }
14779 arg4 = static_cast< int >(val4);
14780 }
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 {
14788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14789 }
14790 {
14791 if (temp2)
14792 delete arg2;
14793 }
14794 return resultobj;
14795 fail:
14796 {
14797 if (temp2)
14798 delete arg2;
14799 }
14800 return NULL;
14801 }
14802
14803
14804 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj = 0;
14806 wxImage *arg1 = (wxImage *) 0 ;
14807 wxString *arg2 = 0 ;
14808 wxString *arg3 = 0 ;
14809 int arg4 = (int) -1 ;
14810 bool result;
14811 void *argp1 = 0 ;
14812 int res1 = 0 ;
14813 bool temp2 = false ;
14814 bool temp3 = false ;
14815 int val4 ;
14816 int ecode4 = 0 ;
14817 PyObject * obj0 = 0 ;
14818 PyObject * obj1 = 0 ;
14819 PyObject * obj2 = 0 ;
14820 PyObject * obj3 = 0 ;
14821 char * kwnames[] = {
14822 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14823 };
14824
14825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14829 }
14830 arg1 = reinterpret_cast< wxImage * >(argp1);
14831 {
14832 arg2 = wxString_in_helper(obj1);
14833 if (arg2 == NULL) SWIG_fail;
14834 temp2 = true;
14835 }
14836 {
14837 arg3 = wxString_in_helper(obj2);
14838 if (arg3 == NULL) SWIG_fail;
14839 temp3 = true;
14840 }
14841 if (obj3) {
14842 ecode4 = SWIG_AsVal_int(obj3, &val4);
14843 if (!SWIG_IsOK(ecode4)) {
14844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14845 }
14846 arg4 = static_cast< int >(val4);
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 {
14855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14856 }
14857 {
14858 if (temp2)
14859 delete arg2;
14860 }
14861 {
14862 if (temp3)
14863 delete arg3;
14864 }
14865 return resultobj;
14866 fail:
14867 {
14868 if (temp2)
14869 delete arg2;
14870 }
14871 {
14872 if (temp3)
14873 delete arg3;
14874 }
14875 return NULL;
14876 }
14877
14878
14879 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14880 PyObject *resultobj = 0;
14881 wxImage *arg1 = (wxImage *) 0 ;
14882 wxString *arg2 = 0 ;
14883 int arg3 ;
14884 bool result;
14885 void *argp1 = 0 ;
14886 int res1 = 0 ;
14887 bool temp2 = false ;
14888 int val3 ;
14889 int ecode3 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 char * kwnames[] = {
14894 (char *) "self",(char *) "name",(char *) "type", NULL
14895 };
14896
14897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14899 if (!SWIG_IsOK(res1)) {
14900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14901 }
14902 arg1 = reinterpret_cast< wxImage * >(argp1);
14903 {
14904 arg2 = wxString_in_helper(obj1);
14905 if (arg2 == NULL) SWIG_fail;
14906 temp2 = true;
14907 }
14908 ecode3 = SWIG_AsVal_int(obj2, &val3);
14909 if (!SWIG_IsOK(ecode3)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14911 }
14912 arg3 = static_cast< int >(val3);
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 {
14920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14921 }
14922 {
14923 if (temp2)
14924 delete arg2;
14925 }
14926 return resultobj;
14927 fail:
14928 {
14929 if (temp2)
14930 delete arg2;
14931 }
14932 return NULL;
14933 }
14934
14935
14936 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj = 0;
14938 wxImage *arg1 = (wxImage *) 0 ;
14939 wxString *arg2 = 0 ;
14940 wxString *arg3 = 0 ;
14941 bool result;
14942 void *argp1 = 0 ;
14943 int res1 = 0 ;
14944 bool temp2 = false ;
14945 bool temp3 = false ;
14946 PyObject * obj0 = 0 ;
14947 PyObject * obj1 = 0 ;
14948 PyObject * obj2 = 0 ;
14949 char * kwnames[] = {
14950 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14951 };
14952
14953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14955 if (!SWIG_IsOK(res1)) {
14956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14957 }
14958 arg1 = reinterpret_cast< wxImage * >(argp1);
14959 {
14960 arg2 = wxString_in_helper(obj1);
14961 if (arg2 == NULL) SWIG_fail;
14962 temp2 = true;
14963 }
14964 {
14965 arg3 = wxString_in_helper(obj2);
14966 if (arg3 == NULL) SWIG_fail;
14967 temp3 = true;
14968 }
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14977 }
14978 {
14979 if (temp2)
14980 delete arg2;
14981 }
14982 {
14983 if (temp3)
14984 delete arg3;
14985 }
14986 return resultobj;
14987 fail:
14988 {
14989 if (temp2)
14990 delete arg2;
14991 }
14992 {
14993 if (temp3)
14994 delete arg3;
14995 }
14996 return NULL;
14997 }
14998
14999
15000 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj = 0;
15002 wxInputStream *arg1 = 0 ;
15003 bool result;
15004 wxPyInputStream *temp1 ;
15005 bool created1 ;
15006 PyObject * obj0 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "stream", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15012 {
15013 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15014 arg1 = temp1->m_wxis;
15015 created1 = false;
15016 } else {
15017 PyErr_Clear(); // clear the failure of the wxPyConvert above
15018 arg1 = wxPyCBInputStream_create(obj0, false);
15019 if (arg1 == NULL) {
15020 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15021 SWIG_fail;
15022 }
15023 created1 = true;
15024 }
15025 }
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 result = (bool)wxImage::CanRead(*arg1);
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 {
15033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15034 }
15035 {
15036 if (created1) delete arg1;
15037 }
15038 return resultobj;
15039 fail:
15040 {
15041 if (created1) delete arg1;
15042 }
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj = 0;
15049 wxImage *arg1 = (wxImage *) 0 ;
15050 wxInputStream *arg2 = 0 ;
15051 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15052 int arg4 = (int) -1 ;
15053 bool result;
15054 void *argp1 = 0 ;
15055 int res1 = 0 ;
15056 wxPyInputStream *temp2 ;
15057 bool created2 ;
15058 long val3 ;
15059 int ecode3 = 0 ;
15060 int val4 ;
15061 int ecode4 = 0 ;
15062 PyObject * obj0 = 0 ;
15063 PyObject * obj1 = 0 ;
15064 PyObject * obj2 = 0 ;
15065 PyObject * obj3 = 0 ;
15066 char * kwnames[] = {
15067 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15068 };
15069
15070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15072 if (!SWIG_IsOK(res1)) {
15073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15074 }
15075 arg1 = reinterpret_cast< wxImage * >(argp1);
15076 {
15077 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15078 arg2 = temp2->m_wxis;
15079 created2 = false;
15080 } else {
15081 PyErr_Clear(); // clear the failure of the wxPyConvert above
15082 arg2 = wxPyCBInputStream_create(obj1, false);
15083 if (arg2 == NULL) {
15084 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15085 SWIG_fail;
15086 }
15087 created2 = true;
15088 }
15089 }
15090 if (obj2) {
15091 ecode3 = SWIG_AsVal_long(obj2, &val3);
15092 if (!SWIG_IsOK(ecode3)) {
15093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15094 }
15095 arg3 = static_cast< long >(val3);
15096 }
15097 if (obj3) {
15098 ecode4 = SWIG_AsVal_int(obj3, &val4);
15099 if (!SWIG_IsOK(ecode4)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15101 }
15102 arg4 = static_cast< int >(val4);
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 {
15111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15112 }
15113 {
15114 if (created2) delete arg2;
15115 }
15116 return resultobj;
15117 fail:
15118 {
15119 if (created2) delete arg2;
15120 }
15121 return NULL;
15122 }
15123
15124
15125 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15126 PyObject *resultobj = 0;
15127 wxImage *arg1 = (wxImage *) 0 ;
15128 wxInputStream *arg2 = 0 ;
15129 wxString *arg3 = 0 ;
15130 int arg4 = (int) -1 ;
15131 bool result;
15132 void *argp1 = 0 ;
15133 int res1 = 0 ;
15134 wxPyInputStream *temp2 ;
15135 bool created2 ;
15136 bool temp3 = false ;
15137 int val4 ;
15138 int ecode4 = 0 ;
15139 PyObject * obj0 = 0 ;
15140 PyObject * obj1 = 0 ;
15141 PyObject * obj2 = 0 ;
15142 PyObject * obj3 = 0 ;
15143 char * kwnames[] = {
15144 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15145 };
15146
15147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15149 if (!SWIG_IsOK(res1)) {
15150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15151 }
15152 arg1 = reinterpret_cast< wxImage * >(argp1);
15153 {
15154 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15155 arg2 = temp2->m_wxis;
15156 created2 = false;
15157 } else {
15158 PyErr_Clear(); // clear the failure of the wxPyConvert above
15159 arg2 = wxPyCBInputStream_create(obj1, false);
15160 if (arg2 == NULL) {
15161 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15162 SWIG_fail;
15163 }
15164 created2 = true;
15165 }
15166 }
15167 {
15168 arg3 = wxString_in_helper(obj2);
15169 if (arg3 == NULL) SWIG_fail;
15170 temp3 = true;
15171 }
15172 if (obj3) {
15173 ecode4 = SWIG_AsVal_int(obj3, &val4);
15174 if (!SWIG_IsOK(ecode4)) {
15175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15176 }
15177 arg4 = static_cast< int >(val4);
15178 }
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15187 }
15188 {
15189 if (created2) delete arg2;
15190 }
15191 {
15192 if (temp3)
15193 delete arg3;
15194 }
15195 return resultobj;
15196 fail:
15197 {
15198 if (created2) delete arg2;
15199 }
15200 {
15201 if (temp3)
15202 delete arg3;
15203 }
15204 return NULL;
15205 }
15206
15207
15208 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15209 PyObject *resultobj = 0;
15210 wxImage *arg1 = (wxImage *) 0 ;
15211 bool result;
15212 void *argp1 = 0 ;
15213 int res1 = 0 ;
15214 PyObject *swig_obj[1] ;
15215
15216 if (!args) SWIG_fail;
15217 swig_obj[0] = args;
15218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15219 if (!SWIG_IsOK(res1)) {
15220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15221 }
15222 arg1 = reinterpret_cast< wxImage * >(argp1);
15223 {
15224 PyThreadState* __tstate = wxPyBeginAllowThreads();
15225 result = (bool)(arg1)->Ok();
15226 wxPyEndAllowThreads(__tstate);
15227 if (PyErr_Occurred()) SWIG_fail;
15228 }
15229 {
15230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15231 }
15232 return resultobj;
15233 fail:
15234 return NULL;
15235 }
15236
15237
15238 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15239 PyObject *resultobj = 0;
15240 wxImage *arg1 = (wxImage *) 0 ;
15241 int result;
15242 void *argp1 = 0 ;
15243 int res1 = 0 ;
15244 PyObject *swig_obj[1] ;
15245
15246 if (!args) SWIG_fail;
15247 swig_obj[0] = args;
15248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15249 if (!SWIG_IsOK(res1)) {
15250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15251 }
15252 arg1 = reinterpret_cast< wxImage * >(argp1);
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (int)(arg1)->GetWidth();
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 resultobj = SWIG_From_int(static_cast< int >(result));
15260 return resultobj;
15261 fail:
15262 return NULL;
15263 }
15264
15265
15266 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15267 PyObject *resultobj = 0;
15268 wxImage *arg1 = (wxImage *) 0 ;
15269 int result;
15270 void *argp1 = 0 ;
15271 int res1 = 0 ;
15272 PyObject *swig_obj[1] ;
15273
15274 if (!args) SWIG_fail;
15275 swig_obj[0] = args;
15276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15277 if (!SWIG_IsOK(res1)) {
15278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15279 }
15280 arg1 = reinterpret_cast< wxImage * >(argp1);
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (int)(arg1)->GetHeight();
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 resultobj = SWIG_From_int(static_cast< int >(result));
15288 return resultobj;
15289 fail:
15290 return NULL;
15291 }
15292
15293
15294 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15295 PyObject *resultobj = 0;
15296 wxImage *arg1 = (wxImage *) 0 ;
15297 wxSize result;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 PyObject *swig_obj[1] ;
15301
15302 if (!args) SWIG_fail;
15303 swig_obj[0] = args;
15304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15305 if (!SWIG_IsOK(res1)) {
15306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15307 }
15308 arg1 = reinterpret_cast< wxImage * >(argp1);
15309 {
15310 PyThreadState* __tstate = wxPyBeginAllowThreads();
15311 result = wxImage_GetSize(arg1);
15312 wxPyEndAllowThreads(__tstate);
15313 if (PyErr_Occurred()) SWIG_fail;
15314 }
15315 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj = 0;
15324 wxImage *arg1 = (wxImage *) 0 ;
15325 wxRect *arg2 = 0 ;
15326 SwigValueWrapper<wxImage > result;
15327 void *argp1 = 0 ;
15328 int res1 = 0 ;
15329 wxRect temp2 ;
15330 PyObject * obj0 = 0 ;
15331 PyObject * obj1 = 0 ;
15332 char * kwnames[] = {
15333 (char *) "self",(char *) "rect", NULL
15334 };
15335
15336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15340 }
15341 arg1 = reinterpret_cast< wxImage * >(argp1);
15342 {
15343 arg2 = &temp2;
15344 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15345 }
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj = 0;
15361 wxImage *arg1 = (wxImage *) 0 ;
15362 wxSize *arg2 = 0 ;
15363 wxPoint *arg3 = 0 ;
15364 int arg4 = (int) -1 ;
15365 int arg5 = (int) -1 ;
15366 int arg6 = (int) -1 ;
15367 SwigValueWrapper<wxImage > result;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 wxSize temp2 ;
15371 wxPoint temp3 ;
15372 int val4 ;
15373 int ecode4 = 0 ;
15374 int val5 ;
15375 int ecode5 = 0 ;
15376 int val6 ;
15377 int ecode6 = 0 ;
15378 PyObject * obj0 = 0 ;
15379 PyObject * obj1 = 0 ;
15380 PyObject * obj2 = 0 ;
15381 PyObject * obj3 = 0 ;
15382 PyObject * obj4 = 0 ;
15383 PyObject * obj5 = 0 ;
15384 char * kwnames[] = {
15385 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15386 };
15387
15388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15392 }
15393 arg1 = reinterpret_cast< wxImage * >(argp1);
15394 {
15395 arg2 = &temp2;
15396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15397 }
15398 {
15399 arg3 = &temp3;
15400 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15401 }
15402 if (obj3) {
15403 ecode4 = SWIG_AsVal_int(obj3, &val4);
15404 if (!SWIG_IsOK(ecode4)) {
15405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15406 }
15407 arg4 = static_cast< int >(val4);
15408 }
15409 if (obj4) {
15410 ecode5 = SWIG_AsVal_int(obj4, &val5);
15411 if (!SWIG_IsOK(ecode5)) {
15412 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15413 }
15414 arg5 = static_cast< int >(val5);
15415 }
15416 if (obj5) {
15417 ecode6 = SWIG_AsVal_int(obj5, &val6);
15418 if (!SWIG_IsOK(ecode6)) {
15419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15420 }
15421 arg6 = static_cast< int >(val6);
15422 }
15423 {
15424 PyThreadState* __tstate = wxPyBeginAllowThreads();
15425 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15437 PyObject *resultobj = 0;
15438 wxImage *arg1 = (wxImage *) 0 ;
15439 SwigValueWrapper<wxImage > result;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject *swig_obj[1] ;
15443
15444 if (!args) SWIG_fail;
15445 swig_obj[0] = args;
15446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15449 }
15450 arg1 = reinterpret_cast< wxImage * >(argp1);
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (arg1)->Copy();
15454 wxPyEndAllowThreads(__tstate);
15455 if (PyErr_Occurred()) SWIG_fail;
15456 }
15457 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj = 0;
15466 wxImage *arg1 = (wxImage *) 0 ;
15467 wxImage *arg2 = 0 ;
15468 int arg3 ;
15469 int arg4 ;
15470 void *argp1 = 0 ;
15471 int res1 = 0 ;
15472 void *argp2 = 0 ;
15473 int res2 = 0 ;
15474 int val3 ;
15475 int ecode3 = 0 ;
15476 int val4 ;
15477 int ecode4 = 0 ;
15478 PyObject * obj0 = 0 ;
15479 PyObject * obj1 = 0 ;
15480 PyObject * obj2 = 0 ;
15481 PyObject * obj3 = 0 ;
15482 char * kwnames[] = {
15483 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15484 };
15485
15486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15490 }
15491 arg1 = reinterpret_cast< wxImage * >(argp1);
15492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15493 if (!SWIG_IsOK(res2)) {
15494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15495 }
15496 if (!argp2) {
15497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15498 }
15499 arg2 = reinterpret_cast< wxImage * >(argp2);
15500 ecode3 = SWIG_AsVal_int(obj2, &val3);
15501 if (!SWIG_IsOK(ecode3)) {
15502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15503 }
15504 arg3 = static_cast< int >(val3);
15505 ecode4 = SWIG_AsVal_int(obj3, &val4);
15506 if (!SWIG_IsOK(ecode4)) {
15507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15508 }
15509 arg4 = static_cast< int >(val4);
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxImage *arg1 = (wxImage *) 0 ;
15526 PyObject *result = 0 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15536 }
15537 arg1 = reinterpret_cast< wxImage * >(argp1);
15538 {
15539 PyThreadState* __tstate = wxPyBeginAllowThreads();
15540 result = (PyObject *)wxImage_GetData(arg1);
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 resultobj = result;
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj = 0;
15553 wxImage *arg1 = (wxImage *) 0 ;
15554 buffer arg2 ;
15555 int arg3 ;
15556 void *argp1 = 0 ;
15557 int res1 = 0 ;
15558 Py_ssize_t temp2 ;
15559 PyObject * obj0 = 0 ;
15560 PyObject * obj1 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "data", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15569 }
15570 arg1 = reinterpret_cast< wxImage * >(argp1);
15571 {
15572 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15573 arg3 = (int)temp2;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetData(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 PyObject *result = 0 ;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = result;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 buffer arg2 ;
15620 int arg3 ;
15621 void *argp1 = 0 ;
15622 int res1 = 0 ;
15623 Py_ssize_t temp2 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 char * kwnames[] = {
15627 (char *) "self",(char *) "data", NULL
15628 };
15629
15630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",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_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15634 }
15635 arg1 = reinterpret_cast< wxImage * >(argp1);
15636 {
15637 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15638 arg3 = (int)temp2;
15639 }
15640 {
15641 PyThreadState* __tstate = wxPyBeginAllowThreads();
15642 wxImage_SetDataBuffer(arg1,arg2,arg3);
15643 wxPyEndAllowThreads(__tstate);
15644 if (PyErr_Occurred()) SWIG_fail;
15645 }
15646 resultobj = SWIG_Py_Void();
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15654 PyObject *resultobj = 0;
15655 wxImage *arg1 = (wxImage *) 0 ;
15656 PyObject *result = 0 ;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 PyObject *swig_obj[1] ;
15660
15661 if (!args) SWIG_fail;
15662 swig_obj[0] = args;
15663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15664 if (!SWIG_IsOK(res1)) {
15665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15666 }
15667 arg1 = reinterpret_cast< wxImage * >(argp1);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (PyObject *)wxImage_GetAlphaData(arg1);
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = result;
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = 0;
15683 wxImage *arg1 = (wxImage *) 0 ;
15684 buffer arg2 ;
15685 int arg3 ;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 Py_ssize_t temp2 ;
15689 PyObject * obj0 = 0 ;
15690 PyObject * obj1 = 0 ;
15691 char * kwnames[] = {
15692 (char *) "self",(char *) "alpha", NULL
15693 };
15694
15695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15697 if (!SWIG_IsOK(res1)) {
15698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15699 }
15700 arg1 = reinterpret_cast< wxImage * >(argp1);
15701 {
15702 if (obj1 != Py_None) {
15703 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15704 arg3 = (int)temp2;
15705 }
15706 }
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 wxImage_SetAlphaData(arg1,arg2,arg3);
15710 wxPyEndAllowThreads(__tstate);
15711 if (PyErr_Occurred()) SWIG_fail;
15712 }
15713 resultobj = SWIG_Py_Void();
15714 return resultobj;
15715 fail:
15716 return NULL;
15717 }
15718
15719
15720 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15721 PyObject *resultobj = 0;
15722 wxImage *arg1 = (wxImage *) 0 ;
15723 PyObject *result = 0 ;
15724 void *argp1 = 0 ;
15725 int res1 = 0 ;
15726 PyObject *swig_obj[1] ;
15727
15728 if (!args) SWIG_fail;
15729 swig_obj[0] = args;
15730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15731 if (!SWIG_IsOK(res1)) {
15732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15733 }
15734 arg1 = reinterpret_cast< wxImage * >(argp1);
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = result;
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj = 0;
15750 wxImage *arg1 = (wxImage *) 0 ;
15751 buffer arg2 ;
15752 int arg3 ;
15753 void *argp1 = 0 ;
15754 int res1 = 0 ;
15755 Py_ssize_t temp2 ;
15756 PyObject * obj0 = 0 ;
15757 PyObject * obj1 = 0 ;
15758 char * kwnames[] = {
15759 (char *) "self",(char *) "alpha", NULL
15760 };
15761
15762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15766 }
15767 arg1 = reinterpret_cast< wxImage * >(argp1);
15768 {
15769 if (obj1 != Py_None) {
15770 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15771 arg3 = (int)temp2;
15772 }
15773 }
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15777 wxPyEndAllowThreads(__tstate);
15778 if (PyErr_Occurred()) SWIG_fail;
15779 }
15780 resultobj = SWIG_Py_Void();
15781 return resultobj;
15782 fail:
15783 return NULL;
15784 }
15785
15786
15787 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15788 PyObject *resultobj = 0;
15789 wxImage *arg1 = (wxImage *) 0 ;
15790 byte arg2 ;
15791 byte arg3 ;
15792 byte arg4 ;
15793 void *argp1 = 0 ;
15794 int res1 = 0 ;
15795 unsigned char val2 ;
15796 int ecode2 = 0 ;
15797 unsigned char val3 ;
15798 int ecode3 = 0 ;
15799 unsigned char val4 ;
15800 int ecode4 = 0 ;
15801 PyObject * obj0 = 0 ;
15802 PyObject * obj1 = 0 ;
15803 PyObject * obj2 = 0 ;
15804 PyObject * obj3 = 0 ;
15805 char * kwnames[] = {
15806 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15807 };
15808
15809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15811 if (!SWIG_IsOK(res1)) {
15812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15813 }
15814 arg1 = reinterpret_cast< wxImage * >(argp1);
15815 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15816 if (!SWIG_IsOK(ecode2)) {
15817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15818 }
15819 arg2 = static_cast< byte >(val2);
15820 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15821 if (!SWIG_IsOK(ecode3)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15823 }
15824 arg3 = static_cast< byte >(val3);
15825 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15826 if (!SWIG_IsOK(ecode4)) {
15827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15828 }
15829 arg4 = static_cast< byte >(val4);
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 (arg1)->SetMaskColour(arg2,arg3,arg4);
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 resultobj = SWIG_Py_Void();
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15844 PyObject *resultobj = 0;
15845 wxImage *arg1 = (wxImage *) 0 ;
15846 byte *arg2 = (byte *) 0 ;
15847 byte *arg3 = (byte *) 0 ;
15848 byte *arg4 = (byte *) 0 ;
15849 void *argp1 = 0 ;
15850 int res1 = 0 ;
15851 byte temp2 ;
15852 int res2 = SWIG_TMPOBJ ;
15853 byte temp3 ;
15854 int res3 = SWIG_TMPOBJ ;
15855 byte temp4 ;
15856 int res4 = SWIG_TMPOBJ ;
15857 PyObject *swig_obj[1] ;
15858
15859 arg2 = &temp2;
15860 arg3 = &temp3;
15861 arg4 = &temp4;
15862 if (!args) SWIG_fail;
15863 swig_obj[0] = args;
15864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15865 if (!SWIG_IsOK(res1)) {
15866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15867 }
15868 arg1 = reinterpret_cast< wxImage * >(argp1);
15869 {
15870 PyThreadState* __tstate = wxPyBeginAllowThreads();
15871 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 resultobj = SWIG_Py_Void();
15876 if (SWIG_IsTmpObj(res2)) {
15877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15878 } else {
15879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15881 }
15882 if (SWIG_IsTmpObj(res3)) {
15883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15884 } else {
15885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15887 }
15888 if (SWIG_IsTmpObj(res4)) {
15889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15890 } else {
15891 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15893 }
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15901 PyObject *resultobj = 0;
15902 wxImage *arg1 = (wxImage *) 0 ;
15903 byte result;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 PyObject *swig_obj[1] ;
15907
15908 if (!args) SWIG_fail;
15909 swig_obj[0] = args;
15910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15911 if (!SWIG_IsOK(res1)) {
15912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15913 }
15914 arg1 = reinterpret_cast< wxImage * >(argp1);
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 result = (byte)(arg1)->GetMaskRed();
15918 wxPyEndAllowThreads(__tstate);
15919 if (PyErr_Occurred()) SWIG_fail;
15920 }
15921 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15922 return resultobj;
15923 fail:
15924 return NULL;
15925 }
15926
15927
15928 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15929 PyObject *resultobj = 0;
15930 wxImage *arg1 = (wxImage *) 0 ;
15931 byte result;
15932 void *argp1 = 0 ;
15933 int res1 = 0 ;
15934 PyObject *swig_obj[1] ;
15935
15936 if (!args) SWIG_fail;
15937 swig_obj[0] = args;
15938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15939 if (!SWIG_IsOK(res1)) {
15940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15941 }
15942 arg1 = reinterpret_cast< wxImage * >(argp1);
15943 {
15944 PyThreadState* __tstate = wxPyBeginAllowThreads();
15945 result = (byte)(arg1)->GetMaskGreen();
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15957 PyObject *resultobj = 0;
15958 wxImage *arg1 = (wxImage *) 0 ;
15959 byte result;
15960 void *argp1 = 0 ;
15961 int res1 = 0 ;
15962 PyObject *swig_obj[1] ;
15963
15964 if (!args) SWIG_fail;
15965 swig_obj[0] = args;
15966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15967 if (!SWIG_IsOK(res1)) {
15968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15969 }
15970 arg1 = reinterpret_cast< wxImage * >(argp1);
15971 {
15972 PyThreadState* __tstate = wxPyBeginAllowThreads();
15973 result = (byte)(arg1)->GetMaskBlue();
15974 wxPyEndAllowThreads(__tstate);
15975 if (PyErr_Occurred()) SWIG_fail;
15976 }
15977 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15978 return resultobj;
15979 fail:
15980 return NULL;
15981 }
15982
15983
15984 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15985 PyObject *resultobj = 0;
15986 wxImage *arg1 = (wxImage *) 0 ;
15987 bool arg2 = (bool) true ;
15988 void *argp1 = 0 ;
15989 int res1 = 0 ;
15990 bool val2 ;
15991 int ecode2 = 0 ;
15992 PyObject * obj0 = 0 ;
15993 PyObject * obj1 = 0 ;
15994 char * kwnames[] = {
15995 (char *) "self",(char *) "mask", NULL
15996 };
15997
15998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16002 }
16003 arg1 = reinterpret_cast< wxImage * >(argp1);
16004 if (obj1) {
16005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16006 if (!SWIG_IsOK(ecode2)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16008 }
16009 arg2 = static_cast< bool >(val2);
16010 }
16011 {
16012 PyThreadState* __tstate = wxPyBeginAllowThreads();
16013 (arg1)->SetMask(arg2);
16014 wxPyEndAllowThreads(__tstate);
16015 if (PyErr_Occurred()) SWIG_fail;
16016 }
16017 resultobj = SWIG_Py_Void();
16018 return resultobj;
16019 fail:
16020 return NULL;
16021 }
16022
16023
16024 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16025 PyObject *resultobj = 0;
16026 wxImage *arg1 = (wxImage *) 0 ;
16027 bool result;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 PyObject *swig_obj[1] ;
16031
16032 if (!args) SWIG_fail;
16033 swig_obj[0] = args;
16034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16035 if (!SWIG_IsOK(res1)) {
16036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16037 }
16038 arg1 = reinterpret_cast< wxImage * >(argp1);
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 result = (bool)(arg1)->HasMask();
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 {
16046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16047 }
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj = 0;
16056 wxImage *arg1 = (wxImage *) 0 ;
16057 double arg2 ;
16058 wxPoint *arg3 = 0 ;
16059 bool arg4 = (bool) true ;
16060 wxPoint *arg5 = (wxPoint *) NULL ;
16061 SwigValueWrapper<wxImage > result;
16062 void *argp1 = 0 ;
16063 int res1 = 0 ;
16064 double val2 ;
16065 int ecode2 = 0 ;
16066 wxPoint temp3 ;
16067 bool val4 ;
16068 int ecode4 = 0 ;
16069 void *argp5 = 0 ;
16070 int res5 = 0 ;
16071 PyObject * obj0 = 0 ;
16072 PyObject * obj1 = 0 ;
16073 PyObject * obj2 = 0 ;
16074 PyObject * obj3 = 0 ;
16075 PyObject * obj4 = 0 ;
16076 char * kwnames[] = {
16077 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16078 };
16079
16080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16082 if (!SWIG_IsOK(res1)) {
16083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16084 }
16085 arg1 = reinterpret_cast< wxImage * >(argp1);
16086 ecode2 = SWIG_AsVal_double(obj1, &val2);
16087 if (!SWIG_IsOK(ecode2)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16089 }
16090 arg2 = static_cast< double >(val2);
16091 {
16092 arg3 = &temp3;
16093 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16094 }
16095 if (obj3) {
16096 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16097 if (!SWIG_IsOK(ecode4)) {
16098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16099 }
16100 arg4 = static_cast< bool >(val4);
16101 }
16102 if (obj4) {
16103 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16104 if (!SWIG_IsOK(res5)) {
16105 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16106 }
16107 arg5 = reinterpret_cast< wxPoint * >(argp5);
16108 }
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16123 PyObject *resultobj = 0;
16124 wxImage *arg1 = (wxImage *) 0 ;
16125 bool arg2 = (bool) true ;
16126 SwigValueWrapper<wxImage > result;
16127 void *argp1 = 0 ;
16128 int res1 = 0 ;
16129 bool val2 ;
16130 int ecode2 = 0 ;
16131 PyObject * obj0 = 0 ;
16132 PyObject * obj1 = 0 ;
16133 char * kwnames[] = {
16134 (char *) "self",(char *) "clockwise", NULL
16135 };
16136
16137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16139 if (!SWIG_IsOK(res1)) {
16140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16141 }
16142 arg1 = reinterpret_cast< wxImage * >(argp1);
16143 if (obj1) {
16144 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16145 if (!SWIG_IsOK(ecode2)) {
16146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16147 }
16148 arg2 = static_cast< bool >(val2);
16149 }
16150 {
16151 PyThreadState* __tstate = wxPyBeginAllowThreads();
16152 result = (arg1)->Rotate90(arg2);
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16157 return resultobj;
16158 fail:
16159 return NULL;
16160 }
16161
16162
16163 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16164 PyObject *resultobj = 0;
16165 wxImage *arg1 = (wxImage *) 0 ;
16166 bool arg2 = (bool) true ;
16167 SwigValueWrapper<wxImage > result;
16168 void *argp1 = 0 ;
16169 int res1 = 0 ;
16170 bool val2 ;
16171 int ecode2 = 0 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "horizontally", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 if (obj1) {
16185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16186 if (!SWIG_IsOK(ecode2)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16188 }
16189 arg2 = static_cast< bool >(val2);
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (arg1)->Mirror(arg2);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 byte arg2 ;
16208 byte arg3 ;
16209 byte arg4 ;
16210 byte arg5 ;
16211 byte arg6 ;
16212 byte arg7 ;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 unsigned char val2 ;
16216 int ecode2 = 0 ;
16217 unsigned char val3 ;
16218 int ecode3 = 0 ;
16219 unsigned char val4 ;
16220 int ecode4 = 0 ;
16221 unsigned char val5 ;
16222 int ecode5 = 0 ;
16223 unsigned char val6 ;
16224 int ecode6 = 0 ;
16225 unsigned char val7 ;
16226 int ecode7 = 0 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 PyObject * obj3 = 0 ;
16231 PyObject * obj4 = 0 ;
16232 PyObject * obj5 = 0 ;
16233 PyObject * obj6 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
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_Replace" "', 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_Replace" "', 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_Replace" "', expected argument " "4"" of type '" "byte""'");
16257 }
16258 arg4 = static_cast< byte >(val4);
16259 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16260 if (!SWIG_IsOK(ecode5)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16262 }
16263 arg5 = static_cast< byte >(val5);
16264 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16265 if (!SWIG_IsOK(ecode6)) {
16266 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16267 }
16268 arg6 = static_cast< byte >(val6);
16269 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16270 if (!SWIG_IsOK(ecode7)) {
16271 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16272 }
16273 arg7 = static_cast< byte >(val7);
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 resultobj = SWIG_Py_Void();
16281 return resultobj;
16282 fail:
16283 return NULL;
16284 }
16285
16286
16287 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16288 PyObject *resultobj = 0;
16289 wxImage *arg1 = (wxImage *) 0 ;
16290 double arg2 = (double) 0.299 ;
16291 double arg3 = (double) 0.587 ;
16292 double arg4 = (double) 0.114 ;
16293 SwigValueWrapper<wxImage > result;
16294 void *argp1 = 0 ;
16295 int res1 = 0 ;
16296 double val2 ;
16297 int ecode2 = 0 ;
16298 double val3 ;
16299 int ecode3 = 0 ;
16300 double val4 ;
16301 int ecode4 = 0 ;
16302 PyObject * obj0 = 0 ;
16303 PyObject * obj1 = 0 ;
16304 PyObject * obj2 = 0 ;
16305 PyObject * obj3 = 0 ;
16306 char * kwnames[] = {
16307 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16308 };
16309
16310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16312 if (!SWIG_IsOK(res1)) {
16313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16314 }
16315 arg1 = reinterpret_cast< wxImage * >(argp1);
16316 if (obj1) {
16317 ecode2 = SWIG_AsVal_double(obj1, &val2);
16318 if (!SWIG_IsOK(ecode2)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16320 }
16321 arg2 = static_cast< double >(val2);
16322 }
16323 if (obj2) {
16324 ecode3 = SWIG_AsVal_double(obj2, &val3);
16325 if (!SWIG_IsOK(ecode3)) {
16326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16327 }
16328 arg3 = static_cast< double >(val3);
16329 }
16330 if (obj3) {
16331 ecode4 = SWIG_AsVal_double(obj3, &val4);
16332 if (!SWIG_IsOK(ecode4)) {
16333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16334 }
16335 arg4 = static_cast< double >(val4);
16336 }
16337 {
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16344 return resultobj;
16345 fail:
16346 return NULL;
16347 }
16348
16349
16350 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16351 PyObject *resultobj = 0;
16352 wxImage *arg1 = (wxImage *) 0 ;
16353 byte arg2 ;
16354 byte arg3 ;
16355 byte arg4 ;
16356 SwigValueWrapper<wxImage > result;
16357 void *argp1 = 0 ;
16358 int res1 = 0 ;
16359 unsigned char val2 ;
16360 int ecode2 = 0 ;
16361 unsigned char val3 ;
16362 int ecode3 = 0 ;
16363 unsigned char val4 ;
16364 int ecode4 = 0 ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 PyObject * obj2 = 0 ;
16368 PyObject * obj3 = 0 ;
16369 char * kwnames[] = {
16370 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16371 };
16372
16373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16375 if (!SWIG_IsOK(res1)) {
16376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16377 }
16378 arg1 = reinterpret_cast< wxImage * >(argp1);
16379 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16380 if (!SWIG_IsOK(ecode2)) {
16381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16382 }
16383 arg2 = static_cast< byte >(val2);
16384 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16385 if (!SWIG_IsOK(ecode3)) {
16386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16387 }
16388 arg3 = static_cast< byte >(val3);
16389 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16390 if (!SWIG_IsOK(ecode4)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16392 }
16393 arg4 = static_cast< byte >(val4);
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj = 0;
16409 wxImage *arg1 = (wxImage *) 0 ;
16410 wxString *arg2 = 0 ;
16411 wxString *arg3 = 0 ;
16412 void *argp1 = 0 ;
16413 int res1 = 0 ;
16414 bool temp2 = false ;
16415 bool temp3 = false ;
16416 PyObject * obj0 = 0 ;
16417 PyObject * obj1 = 0 ;
16418 PyObject * obj2 = 0 ;
16419 char * kwnames[] = {
16420 (char *) "self",(char *) "name",(char *) "value", NULL
16421 };
16422
16423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16425 if (!SWIG_IsOK(res1)) {
16426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16427 }
16428 arg1 = reinterpret_cast< wxImage * >(argp1);
16429 {
16430 arg2 = wxString_in_helper(obj1);
16431 if (arg2 == NULL) SWIG_fail;
16432 temp2 = true;
16433 }
16434 {
16435 arg3 = wxString_in_helper(obj2);
16436 if (arg3 == NULL) SWIG_fail;
16437 temp3 = true;
16438 }
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16442 wxPyEndAllowThreads(__tstate);
16443 if (PyErr_Occurred()) SWIG_fail;
16444 }
16445 resultobj = SWIG_Py_Void();
16446 {
16447 if (temp2)
16448 delete arg2;
16449 }
16450 {
16451 if (temp3)
16452 delete arg3;
16453 }
16454 return resultobj;
16455 fail:
16456 {
16457 if (temp2)
16458 delete arg2;
16459 }
16460 {
16461 if (temp3)
16462 delete arg3;
16463 }
16464 return NULL;
16465 }
16466
16467
16468 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj = 0;
16470 wxImage *arg1 = (wxImage *) 0 ;
16471 wxString *arg2 = 0 ;
16472 int arg3 ;
16473 void *argp1 = 0 ;
16474 int res1 = 0 ;
16475 bool temp2 = false ;
16476 int val3 ;
16477 int ecode3 = 0 ;
16478 PyObject * obj0 = 0 ;
16479 PyObject * obj1 = 0 ;
16480 PyObject * obj2 = 0 ;
16481 char * kwnames[] = {
16482 (char *) "self",(char *) "name",(char *) "value", NULL
16483 };
16484
16485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16489 }
16490 arg1 = reinterpret_cast< wxImage * >(argp1);
16491 {
16492 arg2 = wxString_in_helper(obj1);
16493 if (arg2 == NULL) SWIG_fail;
16494 temp2 = true;
16495 }
16496 ecode3 = SWIG_AsVal_int(obj2, &val3);
16497 if (!SWIG_IsOK(ecode3)) {
16498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16499 }
16500 arg3 = static_cast< int >(val3);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 (arg1)->SetOption((wxString const &)*arg2,arg3);
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_Py_Void();
16508 {
16509 if (temp2)
16510 delete arg2;
16511 }
16512 return resultobj;
16513 fail:
16514 {
16515 if (temp2)
16516 delete arg2;
16517 }
16518 return NULL;
16519 }
16520
16521
16522 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16523 PyObject *resultobj = 0;
16524 wxImage *arg1 = (wxImage *) 0 ;
16525 wxString *arg2 = 0 ;
16526 wxString result;
16527 void *argp1 = 0 ;
16528 int res1 = 0 ;
16529 bool temp2 = false ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 char * kwnames[] = {
16533 (char *) "self",(char *) "name", NULL
16534 };
16535
16536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16538 if (!SWIG_IsOK(res1)) {
16539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16540 }
16541 arg1 = reinterpret_cast< wxImage * >(argp1);
16542 {
16543 arg2 = wxString_in_helper(obj1);
16544 if (arg2 == NULL) SWIG_fail;
16545 temp2 = true;
16546 }
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 {
16554 #if wxUSE_UNICODE
16555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16556 #else
16557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16558 #endif
16559 }
16560 {
16561 if (temp2)
16562 delete arg2;
16563 }
16564 return resultobj;
16565 fail:
16566 {
16567 if (temp2)
16568 delete arg2;
16569 }
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxImage *arg1 = (wxImage *) 0 ;
16577 wxString *arg2 = 0 ;
16578 int result;
16579 void *argp1 = 0 ;
16580 int res1 = 0 ;
16581 bool temp2 = false ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 char * kwnames[] = {
16585 (char *) "self",(char *) "name", NULL
16586 };
16587
16588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16592 }
16593 arg1 = reinterpret_cast< wxImage * >(argp1);
16594 {
16595 arg2 = wxString_in_helper(obj1);
16596 if (arg2 == NULL) SWIG_fail;
16597 temp2 = true;
16598 }
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16602 wxPyEndAllowThreads(__tstate);
16603 if (PyErr_Occurred()) SWIG_fail;
16604 }
16605 resultobj = SWIG_From_int(static_cast< int >(result));
16606 {
16607 if (temp2)
16608 delete arg2;
16609 }
16610 return resultobj;
16611 fail:
16612 {
16613 if (temp2)
16614 delete arg2;
16615 }
16616 return NULL;
16617 }
16618
16619
16620 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16621 PyObject *resultobj = 0;
16622 wxImage *arg1 = (wxImage *) 0 ;
16623 wxString *arg2 = 0 ;
16624 bool result;
16625 void *argp1 = 0 ;
16626 int res1 = 0 ;
16627 bool temp2 = false ;
16628 PyObject * obj0 = 0 ;
16629 PyObject * obj1 = 0 ;
16630 char * kwnames[] = {
16631 (char *) "self",(char *) "name", NULL
16632 };
16633
16634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16636 if (!SWIG_IsOK(res1)) {
16637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16638 }
16639 arg1 = reinterpret_cast< wxImage * >(argp1);
16640 {
16641 arg2 = wxString_in_helper(obj1);
16642 if (arg2 == NULL) SWIG_fail;
16643 temp2 = true;
16644 }
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 {
16652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16653 }
16654 {
16655 if (temp2)
16656 delete arg2;
16657 }
16658 return resultobj;
16659 fail:
16660 {
16661 if (temp2)
16662 delete arg2;
16663 }
16664 return NULL;
16665 }
16666
16667
16668 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj = 0;
16670 wxImage *arg1 = (wxImage *) 0 ;
16671 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16672 unsigned long result;
16673 void *argp1 = 0 ;
16674 int res1 = 0 ;
16675 unsigned long val2 ;
16676 int ecode2 = 0 ;
16677 PyObject * obj0 = 0 ;
16678 PyObject * obj1 = 0 ;
16679 char * kwnames[] = {
16680 (char *) "self",(char *) "stopafter", NULL
16681 };
16682
16683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16685 if (!SWIG_IsOK(res1)) {
16686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16687 }
16688 arg1 = reinterpret_cast< wxImage * >(argp1);
16689 if (obj1) {
16690 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16691 if (!SWIG_IsOK(ecode2)) {
16692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16693 }
16694 arg2 = static_cast< unsigned long >(val2);
16695 }
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 result = (unsigned long)(arg1)->CountColours(arg2);
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj = 0;
16711 wxImage *arg1 = (wxImage *) 0 ;
16712 wxImageHistogram *arg2 = 0 ;
16713 unsigned long result;
16714 void *argp1 = 0 ;
16715 int res1 = 0 ;
16716 void *argp2 = 0 ;
16717 int res2 = 0 ;
16718 PyObject * obj0 = 0 ;
16719 PyObject * obj1 = 0 ;
16720 char * kwnames[] = {
16721 (char *) "self",(char *) "h", NULL
16722 };
16723
16724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16728 }
16729 arg1 = reinterpret_cast< wxImage * >(argp1);
16730 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16731 if (!SWIG_IsOK(res2)) {
16732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16733 }
16734 if (!argp2) {
16735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16736 }
16737 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj = 0;
16753 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 PyObject * obj0 = 0 ;
16757 char * kwnames[] = {
16758 (char *) "handler", NULL
16759 };
16760
16761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16765 }
16766 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 wxImage::AddHandler(arg1);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_Py_Void();
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16783 void *argp1 = 0 ;
16784 int res1 = 0 ;
16785 PyObject * obj0 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "handler", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16794 }
16795 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 wxImage::InsertHandler(arg1);
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 resultobj = SWIG_Py_Void();
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj = 0;
16811 wxString *arg1 = 0 ;
16812 bool result;
16813 bool temp1 = false ;
16814 PyObject * obj0 = 0 ;
16815 char * kwnames[] = {
16816 (char *) "name", NULL
16817 };
16818
16819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16820 {
16821 arg1 = wxString_in_helper(obj0);
16822 if (arg1 == NULL) SWIG_fail;
16823 temp1 = true;
16824 }
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16833 }
16834 {
16835 if (temp1)
16836 delete arg1;
16837 }
16838 return resultobj;
16839 fail:
16840 {
16841 if (temp1)
16842 delete arg1;
16843 }
16844 return NULL;
16845 }
16846
16847
16848 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16849 PyObject *resultobj = 0;
16850 PyObject *result = 0 ;
16851
16852 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16853 {
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 result = (PyObject *)wxImage_GetHandlers();
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 resultobj = result;
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16867 PyObject *resultobj = 0;
16868 wxString result;
16869
16870 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = wxImage::GetImageExtWildcard();
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 {
16878 #if wxUSE_UNICODE
16879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16880 #else
16881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16882 #endif
16883 }
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16891 PyObject *resultobj = 0;
16892 wxImage *arg1 = (wxImage *) 0 ;
16893 int arg2 = (int) -1 ;
16894 wxBitmap result;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 int val2 ;
16898 int ecode2 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 PyObject * obj1 = 0 ;
16901 char * kwnames[] = {
16902 (char *) "self",(char *) "depth", NULL
16903 };
16904
16905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16909 }
16910 arg1 = reinterpret_cast< wxImage * >(argp1);
16911 if (obj1) {
16912 ecode2 = SWIG_AsVal_int(obj1, &val2);
16913 if (!SWIG_IsOK(ecode2)) {
16914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16915 }
16916 arg2 = static_cast< int >(val2);
16917 }
16918 {
16919 if (!wxPyCheckForApp()) SWIG_fail;
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 result = wxImage_ConvertToBitmap(arg1,arg2);
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj = 0;
16934 wxImage *arg1 = (wxImage *) 0 ;
16935 byte arg2 ;
16936 byte arg3 ;
16937 byte arg4 ;
16938 wxBitmap result;
16939 void *argp1 = 0 ;
16940 int res1 = 0 ;
16941 unsigned char val2 ;
16942 int ecode2 = 0 ;
16943 unsigned char val3 ;
16944 int ecode3 = 0 ;
16945 unsigned char val4 ;
16946 int ecode4 = 0 ;
16947 PyObject * obj0 = 0 ;
16948 PyObject * obj1 = 0 ;
16949 PyObject * obj2 = 0 ;
16950 PyObject * obj3 = 0 ;
16951 char * kwnames[] = {
16952 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16953 };
16954
16955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16957 if (!SWIG_IsOK(res1)) {
16958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16959 }
16960 arg1 = reinterpret_cast< wxImage * >(argp1);
16961 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16962 if (!SWIG_IsOK(ecode2)) {
16963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16964 }
16965 arg2 = static_cast< byte >(val2);
16966 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16967 if (!SWIG_IsOK(ecode3)) {
16968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16969 }
16970 arg3 = static_cast< byte >(val3);
16971 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16972 if (!SWIG_IsOK(ecode4)) {
16973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16974 }
16975 arg4 = static_cast< byte >(val4);
16976 {
16977 if (!wxPyCheckForApp()) SWIG_fail;
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj = 0;
16992 wxImage *arg1 = (wxImage *) 0 ;
16993 double arg2 ;
16994 void *argp1 = 0 ;
16995 int res1 = 0 ;
16996 double val2 ;
16997 int ecode2 = 0 ;
16998 PyObject * obj0 = 0 ;
16999 PyObject * obj1 = 0 ;
17000 char * kwnames[] = {
17001 (char *) "self",(char *) "angle", NULL
17002 };
17003
17004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17006 if (!SWIG_IsOK(res1)) {
17007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17008 }
17009 arg1 = reinterpret_cast< wxImage * >(argp1);
17010 ecode2 = SWIG_AsVal_double(obj1, &val2);
17011 if (!SWIG_IsOK(ecode2)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17013 }
17014 arg2 = static_cast< double >(val2);
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 (arg1)->RotateHue(arg2);
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 resultobj = SWIG_Py_Void();
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 wxImage_RGBValue arg1 ;
17031 wxImage_HSVValue result;
17032 void *argp1 ;
17033 int res1 = 0 ;
17034 PyObject * obj0 = 0 ;
17035 char * kwnames[] = {
17036 (char *) "rgb", NULL
17037 };
17038
17039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17040 {
17041 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17042 if (!SWIG_IsOK(res1)) {
17043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17044 }
17045 if (!argp1) {
17046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17047 } else {
17048 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17049 arg1 = *temp;
17050 if (SWIG_IsNewObj(res1)) delete temp;
17051 }
17052 }
17053 {
17054 PyThreadState* __tstate = wxPyBeginAllowThreads();
17055 result = wxImage::RGBtoHSV(arg1);
17056 wxPyEndAllowThreads(__tstate);
17057 if (PyErr_Occurred()) SWIG_fail;
17058 }
17059 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17060 return resultobj;
17061 fail:
17062 return NULL;
17063 }
17064
17065
17066 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17067 PyObject *resultobj = 0;
17068 wxImage_HSVValue arg1 ;
17069 wxImage_RGBValue result;
17070 void *argp1 ;
17071 int res1 = 0 ;
17072 PyObject * obj0 = 0 ;
17073 char * kwnames[] = {
17074 (char *) "hsv", NULL
17075 };
17076
17077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17078 {
17079 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17080 if (!SWIG_IsOK(res1)) {
17081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17082 }
17083 if (!argp1) {
17084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17085 } else {
17086 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17087 arg1 = *temp;
17088 if (SWIG_IsNewObj(res1)) delete temp;
17089 }
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = wxImage::HSVtoRGB(arg1);
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17098 return resultobj;
17099 fail:
17100 return NULL;
17101 }
17102
17103
17104 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17105 PyObject *obj;
17106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17107 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17108 return SWIG_Py_Void();
17109 }
17110
17111 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17112 return SWIG_Python_InitShadowInstance(args);
17113 }
17114
17115 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17116 PyObject *resultobj = 0;
17117 int arg1 ;
17118 int arg2 ;
17119 buffer arg3 ;
17120 int arg4 ;
17121 buffer arg5 = (buffer) NULL ;
17122 int arg6 = (int) 0 ;
17123 wxImage *result = 0 ;
17124 int val1 ;
17125 int ecode1 = 0 ;
17126 int val2 ;
17127 int ecode2 = 0 ;
17128 Py_ssize_t temp3 ;
17129 Py_ssize_t temp5 ;
17130 PyObject * obj0 = 0 ;
17131 PyObject * obj1 = 0 ;
17132 PyObject * obj2 = 0 ;
17133 PyObject * obj3 = 0 ;
17134 char * kwnames[] = {
17135 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17136 };
17137
17138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17139 ecode1 = SWIG_AsVal_int(obj0, &val1);
17140 if (!SWIG_IsOK(ecode1)) {
17141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17142 }
17143 arg1 = static_cast< int >(val1);
17144 ecode2 = SWIG_AsVal_int(obj1, &val2);
17145 if (!SWIG_IsOK(ecode2)) {
17146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17147 }
17148 arg2 = static_cast< int >(val2);
17149 {
17150 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17151 arg4 = (int)temp3;
17152 }
17153 if (obj3) {
17154 {
17155 if (obj3 != Py_None) {
17156 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17157 arg6 = (int)temp5;
17158 }
17159 }
17160 }
17161 {
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 {
17168 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17169 }
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 SWIGINTERN int NullImage_set(PyObject *) {
17177 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17178 return 1;
17179 }
17180
17181
17182 SWIGINTERN PyObject *NullImage_get(void) {
17183 PyObject *pyobj = 0;
17184
17185 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17186 return pyobj;
17187 }
17188
17189
17190 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17191 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17192 return 1;
17193 }
17194
17195
17196 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17197 PyObject *pyobj = 0;
17198
17199 {
17200 #if wxUSE_UNICODE
17201 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17202 #else
17203 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17204 #endif
17205 }
17206 return pyobj;
17207 }
17208
17209
17210 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17211 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17212 return 1;
17213 }
17214
17215
17216 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17217 PyObject *pyobj = 0;
17218
17219 {
17220 #if wxUSE_UNICODE
17221 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17222 #else
17223 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17224 #endif
17225 }
17226 return pyobj;
17227 }
17228
17229
17230 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17231 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17232 return 1;
17233 }
17234
17235
17236 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17237 PyObject *pyobj = 0;
17238
17239 {
17240 #if wxUSE_UNICODE
17241 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17242 #else
17243 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17244 #endif
17245 }
17246 return pyobj;
17247 }
17248
17249
17250 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17251 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17252 return 1;
17253 }
17254
17255
17256 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17257 PyObject *pyobj = 0;
17258
17259 {
17260 #if wxUSE_UNICODE
17261 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17262 #else
17263 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17264 #endif
17265 }
17266 return pyobj;
17267 }
17268
17269
17270 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17271 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17272 return 1;
17273 }
17274
17275
17276 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17277 PyObject *pyobj = 0;
17278
17279 {
17280 #if wxUSE_UNICODE
17281 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17282 #else
17283 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17284 #endif
17285 }
17286 return pyobj;
17287 }
17288
17289
17290 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17291 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17292 return 1;
17293 }
17294
17295
17296 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17297 PyObject *pyobj = 0;
17298
17299 {
17300 #if wxUSE_UNICODE
17301 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17302 #else
17303 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17304 #endif
17305 }
17306 return pyobj;
17307 }
17308
17309
17310 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17311 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17312 return 1;
17313 }
17314
17315
17316 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17317 PyObject *pyobj = 0;
17318
17319 {
17320 #if wxUSE_UNICODE
17321 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17322 #else
17323 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17324 #endif
17325 }
17326 return pyobj;
17327 }
17328
17329
17330 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17331 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17332 return 1;
17333 }
17334
17335
17336 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17337 PyObject *pyobj = 0;
17338
17339 {
17340 #if wxUSE_UNICODE
17341 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17342 #else
17343 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17344 #endif
17345 }
17346 return pyobj;
17347 }
17348
17349
17350 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17351 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17352 return 1;
17353 }
17354
17355
17356 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17357 PyObject *pyobj = 0;
17358
17359 {
17360 #if wxUSE_UNICODE
17361 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17362 #else
17363 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17364 #endif
17365 }
17366 return pyobj;
17367 }
17368
17369
17370 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17371 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17372 return 1;
17373 }
17374
17375
17376 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17377 PyObject *pyobj = 0;
17378
17379 {
17380 #if wxUSE_UNICODE
17381 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17382 #else
17383 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17384 #endif
17385 }
17386 return pyobj;
17387 }
17388
17389
17390 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17391 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17392 return 1;
17393 }
17394
17395
17396 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17397 PyObject *pyobj = 0;
17398
17399 {
17400 #if wxUSE_UNICODE
17401 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17402 #else
17403 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17404 #endif
17405 }
17406 return pyobj;
17407 }
17408
17409
17410 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17411 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17412 return 1;
17413 }
17414
17415
17416 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17417 PyObject *pyobj = 0;
17418
17419 {
17420 #if wxUSE_UNICODE
17421 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17422 #else
17423 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17424 #endif
17425 }
17426 return pyobj;
17427 }
17428
17429
17430 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17431 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17432 return 1;
17433 }
17434
17435
17436 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17437 PyObject *pyobj = 0;
17438
17439 {
17440 #if wxUSE_UNICODE
17441 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17442 #else
17443 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17444 #endif
17445 }
17446 return pyobj;
17447 }
17448
17449
17450 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17451 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17452 return 1;
17453 }
17454
17455
17456 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17457 PyObject *pyobj = 0;
17458
17459 {
17460 #if wxUSE_UNICODE
17461 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17462 #else
17463 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17464 #endif
17465 }
17466 return pyobj;
17467 }
17468
17469
17470 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17471 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17472 return 1;
17473 }
17474
17475
17476 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17477 PyObject *pyobj = 0;
17478
17479 {
17480 #if wxUSE_UNICODE
17481 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17482 #else
17483 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17484 #endif
17485 }
17486 return pyobj;
17487 }
17488
17489
17490 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *resultobj = 0;
17492 wxBMPHandler *result = 0 ;
17493
17494 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 result = (wxBMPHandler *)new wxBMPHandler();
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 PyObject *obj;
17510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17511 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17512 return SWIG_Py_Void();
17513 }
17514
17515 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 return SWIG_Python_InitShadowInstance(args);
17517 }
17518
17519 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17520 PyObject *resultobj = 0;
17521 wxICOHandler *result = 0 ;
17522
17523 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (wxICOHandler *)new wxICOHandler();
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17538 PyObject *obj;
17539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17540 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17541 return SWIG_Py_Void();
17542 }
17543
17544 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17545 return SWIG_Python_InitShadowInstance(args);
17546 }
17547
17548 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17549 PyObject *resultobj = 0;
17550 wxCURHandler *result = 0 ;
17551
17552 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (wxCURHandler *)new wxCURHandler();
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 PyObject *obj;
17568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17569 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17570 return SWIG_Py_Void();
17571 }
17572
17573 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 return SWIG_Python_InitShadowInstance(args);
17575 }
17576
17577 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *resultobj = 0;
17579 wxANIHandler *result = 0 ;
17580
17581 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (wxANIHandler *)new wxANIHandler();
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 PyObject *obj;
17597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17598 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17599 return SWIG_Py_Void();
17600 }
17601
17602 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 return SWIG_Python_InitShadowInstance(args);
17604 }
17605
17606 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17607 PyObject *resultobj = 0;
17608 wxPNGHandler *result = 0 ;
17609
17610 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (wxPNGHandler *)new wxPNGHandler();
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17625 PyObject *obj;
17626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17627 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17628 return SWIG_Py_Void();
17629 }
17630
17631 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 return SWIG_Python_InitShadowInstance(args);
17633 }
17634
17635 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17636 PyObject *resultobj = 0;
17637 wxGIFHandler *result = 0 ;
17638
17639 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (wxGIFHandler *)new wxGIFHandler();
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17654 PyObject *obj;
17655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17656 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17657 return SWIG_Py_Void();
17658 }
17659
17660 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17661 return SWIG_Python_InitShadowInstance(args);
17662 }
17663
17664 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17665 PyObject *resultobj = 0;
17666 wxPCXHandler *result = 0 ;
17667
17668 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (wxPCXHandler *)new wxPCXHandler();
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17676 return resultobj;
17677 fail:
17678 return NULL;
17679 }
17680
17681
17682 SWIGINTERN PyObject *PCXHandler_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_wxPCXHandler, SWIG_NewClientData(obj));
17686 return SWIG_Py_Void();
17687 }
17688
17689 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 return SWIG_Python_InitShadowInstance(args);
17691 }
17692
17693 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17694 PyObject *resultobj = 0;
17695 wxJPEGHandler *result = 0 ;
17696
17697 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = (wxJPEGHandler *)new wxJPEGHandler();
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17712 PyObject *obj;
17713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17714 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17715 return SWIG_Py_Void();
17716 }
17717
17718 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17719 return SWIG_Python_InitShadowInstance(args);
17720 }
17721
17722 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17723 PyObject *resultobj = 0;
17724 wxPNMHandler *result = 0 ;
17725
17726 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (wxPNMHandler *)new wxPNMHandler();
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17734 return resultobj;
17735 fail:
17736 return NULL;
17737 }
17738
17739
17740 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17741 PyObject *obj;
17742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17744 return SWIG_Py_Void();
17745 }
17746
17747 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17748 return SWIG_Python_InitShadowInstance(args);
17749 }
17750
17751 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17752 PyObject *resultobj = 0;
17753 wxXPMHandler *result = 0 ;
17754
17755 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17756 {
17757 PyThreadState* __tstate = wxPyBeginAllowThreads();
17758 result = (wxXPMHandler *)new wxXPMHandler();
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17770 PyObject *obj;
17771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17772 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17773 return SWIG_Py_Void();
17774 }
17775
17776 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17777 return SWIG_Python_InitShadowInstance(args);
17778 }
17779
17780 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17781 PyObject *resultobj = 0;
17782 wxTIFFHandler *result = 0 ;
17783
17784 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (wxTIFFHandler *)new wxTIFFHandler();
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17799 PyObject *obj;
17800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17801 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17802 return SWIG_Py_Void();
17803 }
17804
17805 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17806 return SWIG_Python_InitShadowInstance(args);
17807 }
17808
17809 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj = 0;
17811 wxImage *arg1 = 0 ;
17812 wxImage *arg2 = 0 ;
17813 int arg3 = (int) 236 ;
17814 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17815 bool result;
17816 void *argp1 = 0 ;
17817 int res1 = 0 ;
17818 void *argp2 = 0 ;
17819 int res2 = 0 ;
17820 int val3 ;
17821 int ecode3 = 0 ;
17822 int val4 ;
17823 int ecode4 = 0 ;
17824 PyObject * obj0 = 0 ;
17825 PyObject * obj1 = 0 ;
17826 PyObject * obj2 = 0 ;
17827 PyObject * obj3 = 0 ;
17828 char * kwnames[] = {
17829 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17830 };
17831
17832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17833 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17834 if (!SWIG_IsOK(res1)) {
17835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17836 }
17837 if (!argp1) {
17838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17839 }
17840 arg1 = reinterpret_cast< wxImage * >(argp1);
17841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17842 if (!SWIG_IsOK(res2)) {
17843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17844 }
17845 if (!argp2) {
17846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17847 }
17848 arg2 = reinterpret_cast< wxImage * >(argp2);
17849 if (obj2) {
17850 ecode3 = SWIG_AsVal_int(obj2, &val3);
17851 if (!SWIG_IsOK(ecode3)) {
17852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17853 }
17854 arg3 = static_cast< int >(val3);
17855 }
17856 if (obj3) {
17857 ecode4 = SWIG_AsVal_int(obj3, &val4);
17858 if (!SWIG_IsOK(ecode4)) {
17859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17860 }
17861 arg4 = static_cast< int >(val4);
17862 }
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17871 }
17872 return resultobj;
17873 fail:
17874 return NULL;
17875 }
17876
17877
17878 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17879 PyObject *obj;
17880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17881 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17882 return SWIG_Py_Void();
17883 }
17884
17885 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17886 PyObject *resultobj = 0;
17887 wxEvtHandler *result = 0 ;
17888
17889 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 result = (wxEvtHandler *)new wxEvtHandler();
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17897 return resultobj;
17898 fail:
17899 return NULL;
17900 }
17901
17902
17903 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17904 PyObject *resultobj = 0;
17905 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17906 wxEvtHandler *result = 0 ;
17907 void *argp1 = 0 ;
17908 int res1 = 0 ;
17909 PyObject *swig_obj[1] ;
17910
17911 if (!args) SWIG_fail;
17912 swig_obj[0] = args;
17913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17914 if (!SWIG_IsOK(res1)) {
17915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17916 }
17917 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17918 {
17919 PyThreadState* __tstate = wxPyBeginAllowThreads();
17920 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 {
17925 resultobj = wxPyMake_wxObject(result, 0);
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17934 PyObject *resultobj = 0;
17935 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17936 wxEvtHandler *result = 0 ;
17937 void *argp1 = 0 ;
17938 int res1 = 0 ;
17939 PyObject *swig_obj[1] ;
17940
17941 if (!args) SWIG_fail;
17942 swig_obj[0] = args;
17943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17946 }
17947 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 {
17955 resultobj = wxPyMake_wxObject(result, 0);
17956 }
17957 return resultobj;
17958 fail:
17959 return NULL;
17960 }
17961
17962
17963 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17964 PyObject *resultobj = 0;
17965 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17966 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17967 void *argp1 = 0 ;
17968 int res1 = 0 ;
17969 void *argp2 = 0 ;
17970 int res2 = 0 ;
17971 PyObject * obj0 = 0 ;
17972 PyObject * obj1 = 0 ;
17973 char * kwnames[] = {
17974 (char *) "self",(char *) "handler", NULL
17975 };
17976
17977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17979 if (!SWIG_IsOK(res1)) {
17980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17981 }
17982 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17984 if (!SWIG_IsOK(res2)) {
17985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17986 }
17987 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 (arg1)->SetNextHandler(arg2);
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 resultobj = SWIG_Py_Void();
17995 return resultobj;
17996 fail:
17997 return NULL;
17998 }
17999
18000
18001 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18002 PyObject *resultobj = 0;
18003 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18004 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18005 void *argp1 = 0 ;
18006 int res1 = 0 ;
18007 void *argp2 = 0 ;
18008 int res2 = 0 ;
18009 PyObject * obj0 = 0 ;
18010 PyObject * obj1 = 0 ;
18011 char * kwnames[] = {
18012 (char *) "self",(char *) "handler", NULL
18013 };
18014
18015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18017 if (!SWIG_IsOK(res1)) {
18018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18019 }
18020 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18022 if (!SWIG_IsOK(res2)) {
18023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18024 }
18025 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18026 {
18027 PyThreadState* __tstate = wxPyBeginAllowThreads();
18028 (arg1)->SetPreviousHandler(arg2);
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 resultobj = SWIG_Py_Void();
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18040 PyObject *resultobj = 0;
18041 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18042 bool result;
18043 void *argp1 = 0 ;
18044 int res1 = 0 ;
18045 PyObject *swig_obj[1] ;
18046
18047 if (!args) SWIG_fail;
18048 swig_obj[0] = args;
18049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18052 }
18053 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18054 {
18055 PyThreadState* __tstate = wxPyBeginAllowThreads();
18056 result = (bool)(arg1)->GetEvtHandlerEnabled();
18057 wxPyEndAllowThreads(__tstate);
18058 if (PyErr_Occurred()) SWIG_fail;
18059 }
18060 {
18061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18062 }
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj = 0;
18071 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18072 bool arg2 ;
18073 void *argp1 = 0 ;
18074 int res1 = 0 ;
18075 bool val2 ;
18076 int ecode2 = 0 ;
18077 PyObject * obj0 = 0 ;
18078 PyObject * obj1 = 0 ;
18079 char * kwnames[] = {
18080 (char *) "self",(char *) "enabled", NULL
18081 };
18082
18083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18085 if (!SWIG_IsOK(res1)) {
18086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18087 }
18088 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18089 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18090 if (!SWIG_IsOK(ecode2)) {
18091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18092 }
18093 arg2 = static_cast< bool >(val2);
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 (arg1)->SetEvtHandlerEnabled(arg2);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 resultobj = SWIG_Py_Void();
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj = 0;
18109 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18110 wxEvent *arg2 = 0 ;
18111 bool result;
18112 void *argp1 = 0 ;
18113 int res1 = 0 ;
18114 void *argp2 = 0 ;
18115 int res2 = 0 ;
18116 PyObject * obj0 = 0 ;
18117 PyObject * obj1 = 0 ;
18118 char * kwnames[] = {
18119 (char *) "self",(char *) "event", NULL
18120 };
18121
18122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18124 if (!SWIG_IsOK(res1)) {
18125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18126 }
18127 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18129 if (!SWIG_IsOK(res2)) {
18130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18131 }
18132 if (!argp2) {
18133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18134 }
18135 arg2 = reinterpret_cast< wxEvent * >(argp2);
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 result = (bool)(arg1)->ProcessEvent(*arg2);
18139 wxPyEndAllowThreads(__tstate);
18140 if (PyErr_Occurred()) SWIG_fail;
18141 }
18142 {
18143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18144 }
18145 return resultobj;
18146 fail:
18147 return NULL;
18148 }
18149
18150
18151 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18152 PyObject *resultobj = 0;
18153 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18154 wxEvent *arg2 = 0 ;
18155 void *argp1 = 0 ;
18156 int res1 = 0 ;
18157 void *argp2 = 0 ;
18158 int res2 = 0 ;
18159 PyObject * obj0 = 0 ;
18160 PyObject * obj1 = 0 ;
18161 char * kwnames[] = {
18162 (char *) "self",(char *) "event", NULL
18163 };
18164
18165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18167 if (!SWIG_IsOK(res1)) {
18168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18169 }
18170 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18172 if (!SWIG_IsOK(res2)) {
18173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18174 }
18175 if (!argp2) {
18176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18177 }
18178 arg2 = reinterpret_cast< wxEvent * >(argp2);
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 (arg1)->AddPendingEvent(*arg2);
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 resultobj = SWIG_Py_Void();
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18193 PyObject *resultobj = 0;
18194 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 PyObject *swig_obj[1] ;
18198
18199 if (!args) SWIG_fail;
18200 swig_obj[0] = args;
18201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18204 }
18205 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 (arg1)->ProcessPendingEvents();
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = SWIG_Py_Void();
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj = 0;
18221 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18222 int arg2 ;
18223 int arg3 ;
18224 int arg4 ;
18225 PyObject *arg5 = (PyObject *) 0 ;
18226 void *argp1 = 0 ;
18227 int res1 = 0 ;
18228 int val2 ;
18229 int ecode2 = 0 ;
18230 int val3 ;
18231 int ecode3 = 0 ;
18232 int val4 ;
18233 int ecode4 = 0 ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 PyObject * obj2 = 0 ;
18237 PyObject * obj3 = 0 ;
18238 PyObject * obj4 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18249 ecode2 = SWIG_AsVal_int(obj1, &val2);
18250 if (!SWIG_IsOK(ecode2)) {
18251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18252 }
18253 arg2 = static_cast< int >(val2);
18254 ecode3 = SWIG_AsVal_int(obj2, &val3);
18255 if (!SWIG_IsOK(ecode3)) {
18256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18257 }
18258 arg3 = static_cast< int >(val3);
18259 ecode4 = SWIG_AsVal_int(obj3, &val4);
18260 if (!SWIG_IsOK(ecode4)) {
18261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18262 }
18263 arg4 = static_cast< int >(val4);
18264 arg5 = obj4;
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18268 wxPyEndAllowThreads(__tstate);
18269 if (PyErr_Occurred()) SWIG_fail;
18270 }
18271 resultobj = SWIG_Py_Void();
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18281 int arg2 ;
18282 int arg3 = (int) -1 ;
18283 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18284 bool result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 int val2 ;
18288 int ecode2 = 0 ;
18289 int val3 ;
18290 int ecode3 = 0 ;
18291 int val4 ;
18292 int ecode4 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 PyObject * obj3 = 0 ;
18297 char * kwnames[] = {
18298 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18299 };
18300
18301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18305 }
18306 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18307 ecode2 = SWIG_AsVal_int(obj1, &val2);
18308 if (!SWIG_IsOK(ecode2)) {
18309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18310 }
18311 arg2 = static_cast< int >(val2);
18312 if (obj2) {
18313 ecode3 = SWIG_AsVal_int(obj2, &val3);
18314 if (!SWIG_IsOK(ecode3)) {
18315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18316 }
18317 arg3 = static_cast< int >(val3);
18318 }
18319 if (obj3) {
18320 ecode4 = SWIG_AsVal_int(obj3, &val4);
18321 if (!SWIG_IsOK(ecode4)) {
18322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18323 }
18324 arg4 = static_cast< wxEventType >(val4);
18325 }
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 {
18333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj = 0;
18343 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18344 PyObject *arg2 = (PyObject *) 0 ;
18345 bool arg3 = (bool) true ;
18346 void *argp1 = 0 ;
18347 int res1 = 0 ;
18348 bool val3 ;
18349 int ecode3 = 0 ;
18350 PyObject * obj0 = 0 ;
18351 PyObject * obj1 = 0 ;
18352 PyObject * obj2 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "_self",(char *) "incref", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18361 }
18362 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18363 arg2 = obj1;
18364 if (obj2) {
18365 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18366 if (!SWIG_IsOK(ecode3)) {
18367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18368 }
18369 arg3 = static_cast< bool >(val3);
18370 }
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = SWIG_Py_Void();
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18385 PyObject *obj;
18386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18387 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18388 return SWIG_Py_Void();
18389 }
18390
18391 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18392 return SWIG_Python_InitShadowInstance(args);
18393 }
18394
18395 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18396 PyObject *resultobj = 0;
18397 wxEventType result;
18398
18399 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 result = (wxEventType)wxNewEventType();
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 resultobj = SWIG_From_int(static_cast< int >(result));
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18414 PyObject *resultobj = 0;
18415 wxEvent *arg1 = (wxEvent *) 0 ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 PyObject *swig_obj[1] ;
18419
18420 if (!args) SWIG_fail;
18421 swig_obj[0] = args;
18422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18423 if (!SWIG_IsOK(res1)) {
18424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18425 }
18426 arg1 = reinterpret_cast< wxEvent * >(argp1);
18427 {
18428 PyThreadState* __tstate = wxPyBeginAllowThreads();
18429 delete arg1;
18430
18431 wxPyEndAllowThreads(__tstate);
18432 if (PyErr_Occurred()) SWIG_fail;
18433 }
18434 resultobj = SWIG_Py_Void();
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj = 0;
18443 wxEvent *arg1 = (wxEvent *) 0 ;
18444 wxEventType arg2 ;
18445 void *argp1 = 0 ;
18446 int res1 = 0 ;
18447 int val2 ;
18448 int ecode2 = 0 ;
18449 PyObject * obj0 = 0 ;
18450 PyObject * obj1 = 0 ;
18451 char * kwnames[] = {
18452 (char *) "self",(char *) "typ", NULL
18453 };
18454
18455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18459 }
18460 arg1 = reinterpret_cast< wxEvent * >(argp1);
18461 ecode2 = SWIG_AsVal_int(obj1, &val2);
18462 if (!SWIG_IsOK(ecode2)) {
18463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18464 }
18465 arg2 = static_cast< wxEventType >(val2);
18466 {
18467 PyThreadState* __tstate = wxPyBeginAllowThreads();
18468 (arg1)->SetEventType(arg2);
18469 wxPyEndAllowThreads(__tstate);
18470 if (PyErr_Occurred()) SWIG_fail;
18471 }
18472 resultobj = SWIG_Py_Void();
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18480 PyObject *resultobj = 0;
18481 wxEvent *arg1 = (wxEvent *) 0 ;
18482 wxEventType result;
18483 void *argp1 = 0 ;
18484 int res1 = 0 ;
18485 PyObject *swig_obj[1] ;
18486
18487 if (!args) SWIG_fail;
18488 swig_obj[0] = args;
18489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18490 if (!SWIG_IsOK(res1)) {
18491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18492 }
18493 arg1 = reinterpret_cast< wxEvent * >(argp1);
18494 {
18495 PyThreadState* __tstate = wxPyBeginAllowThreads();
18496 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18497 wxPyEndAllowThreads(__tstate);
18498 if (PyErr_Occurred()) SWIG_fail;
18499 }
18500 resultobj = SWIG_From_int(static_cast< int >(result));
18501 return resultobj;
18502 fail:
18503 return NULL;
18504 }
18505
18506
18507 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18508 PyObject *resultobj = 0;
18509 wxEvent *arg1 = (wxEvent *) 0 ;
18510 wxObject *result = 0 ;
18511 void *argp1 = 0 ;
18512 int res1 = 0 ;
18513 PyObject *swig_obj[1] ;
18514
18515 if (!args) SWIG_fail;
18516 swig_obj[0] = args;
18517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18518 if (!SWIG_IsOK(res1)) {
18519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18520 }
18521 arg1 = reinterpret_cast< wxEvent * >(argp1);
18522 {
18523 PyThreadState* __tstate = wxPyBeginAllowThreads();
18524 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18525 wxPyEndAllowThreads(__tstate);
18526 if (PyErr_Occurred()) SWIG_fail;
18527 }
18528 {
18529 resultobj = wxPyMake_wxObject(result, (bool)0);
18530 }
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj = 0;
18539 wxEvent *arg1 = (wxEvent *) 0 ;
18540 wxObject *arg2 = (wxObject *) 0 ;
18541 void *argp1 = 0 ;
18542 int res1 = 0 ;
18543 void *argp2 = 0 ;
18544 int res2 = 0 ;
18545 PyObject * obj0 = 0 ;
18546 PyObject * obj1 = 0 ;
18547 char * kwnames[] = {
18548 (char *) "self",(char *) "obj", NULL
18549 };
18550
18551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18553 if (!SWIG_IsOK(res1)) {
18554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18555 }
18556 arg1 = reinterpret_cast< wxEvent * >(argp1);
18557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18558 if (!SWIG_IsOK(res2)) {
18559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18560 }
18561 arg2 = reinterpret_cast< wxObject * >(argp2);
18562 {
18563 PyThreadState* __tstate = wxPyBeginAllowThreads();
18564 (arg1)->SetEventObject(arg2);
18565 wxPyEndAllowThreads(__tstate);
18566 if (PyErr_Occurred()) SWIG_fail;
18567 }
18568 resultobj = SWIG_Py_Void();
18569 return resultobj;
18570 fail:
18571 return NULL;
18572 }
18573
18574
18575 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18576 PyObject *resultobj = 0;
18577 wxEvent *arg1 = (wxEvent *) 0 ;
18578 long result;
18579 void *argp1 = 0 ;
18580 int res1 = 0 ;
18581 PyObject *swig_obj[1] ;
18582
18583 if (!args) SWIG_fail;
18584 swig_obj[0] = args;
18585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18586 if (!SWIG_IsOK(res1)) {
18587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18588 }
18589 arg1 = reinterpret_cast< wxEvent * >(argp1);
18590 {
18591 PyThreadState* __tstate = wxPyBeginAllowThreads();
18592 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18593 wxPyEndAllowThreads(__tstate);
18594 if (PyErr_Occurred()) SWIG_fail;
18595 }
18596 resultobj = SWIG_From_long(static_cast< long >(result));
18597 return resultobj;
18598 fail:
18599 return NULL;
18600 }
18601
18602
18603 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18604 PyObject *resultobj = 0;
18605 wxEvent *arg1 = (wxEvent *) 0 ;
18606 long arg2 = (long) 0 ;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 long val2 ;
18610 int ecode2 = 0 ;
18611 PyObject * obj0 = 0 ;
18612 PyObject * obj1 = 0 ;
18613 char * kwnames[] = {
18614 (char *) "self",(char *) "ts", NULL
18615 };
18616
18617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18619 if (!SWIG_IsOK(res1)) {
18620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18621 }
18622 arg1 = reinterpret_cast< wxEvent * >(argp1);
18623 if (obj1) {
18624 ecode2 = SWIG_AsVal_long(obj1, &val2);
18625 if (!SWIG_IsOK(ecode2)) {
18626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18627 }
18628 arg2 = static_cast< long >(val2);
18629 }
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 (arg1)->SetTimestamp(arg2);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_Py_Void();
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_Event_GetId(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_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvent * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (int)((wxEvent const *)arg1)->GetId();
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_SetId(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 *) "Id", NULL
18683 };
18684
18685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",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_SetId" "', 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_SetId" "', expected argument " "2"" of type '" "int""'");
18694 }
18695 arg2 = static_cast< int >(val2);
18696 {
18697 PyThreadState* __tstate = wxPyBeginAllowThreads();
18698 (arg1)->SetId(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_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18710 PyObject *resultobj = 0;
18711 wxEvent *arg1 = (wxEvent *) 0 ;
18712 bool result;
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_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvent * >(argp1);
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 {
18731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18732 }
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj = 0;
18741 wxEvent *arg1 = (wxEvent *) 0 ;
18742 bool arg2 = (bool) true ;
18743 void *argp1 = 0 ;
18744 int res1 = 0 ;
18745 bool val2 ;
18746 int ecode2 = 0 ;
18747 PyObject * obj0 = 0 ;
18748 PyObject * obj1 = 0 ;
18749 char * kwnames[] = {
18750 (char *) "self",(char *) "skip", NULL
18751 };
18752
18753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18757 }
18758 arg1 = reinterpret_cast< wxEvent * >(argp1);
18759 if (obj1) {
18760 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18761 if (!SWIG_IsOK(ecode2)) {
18762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18763 }
18764 arg2 = static_cast< bool >(val2);
18765 }
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 (arg1)->Skip(arg2);
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 resultobj = SWIG_Py_Void();
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18780 PyObject *resultobj = 0;
18781 wxEvent *arg1 = (wxEvent *) 0 ;
18782 bool result;
18783 void *argp1 = 0 ;
18784 int res1 = 0 ;
18785 PyObject *swig_obj[1] ;
18786
18787 if (!args) SWIG_fail;
18788 swig_obj[0] = args;
18789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18790 if (!SWIG_IsOK(res1)) {
18791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18792 }
18793 arg1 = reinterpret_cast< wxEvent * >(argp1);
18794 {
18795 PyThreadState* __tstate = wxPyBeginAllowThreads();
18796 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18797 wxPyEndAllowThreads(__tstate);
18798 if (PyErr_Occurred()) SWIG_fail;
18799 }
18800 {
18801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18802 }
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18810 PyObject *resultobj = 0;
18811 wxEvent *arg1 = (wxEvent *) 0 ;
18812 bool result;
18813 void *argp1 = 0 ;
18814 int res1 = 0 ;
18815 PyObject *swig_obj[1] ;
18816
18817 if (!args) SWIG_fail;
18818 swig_obj[0] = args;
18819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18820 if (!SWIG_IsOK(res1)) {
18821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18822 }
18823 arg1 = reinterpret_cast< wxEvent * >(argp1);
18824 {
18825 PyThreadState* __tstate = wxPyBeginAllowThreads();
18826 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 {
18831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18832 }
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18840 PyObject *resultobj = 0;
18841 wxEvent *arg1 = (wxEvent *) 0 ;
18842 int result;
18843 void *argp1 = 0 ;
18844 int res1 = 0 ;
18845 PyObject *swig_obj[1] ;
18846
18847 if (!args) SWIG_fail;
18848 swig_obj[0] = args;
18849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18850 if (!SWIG_IsOK(res1)) {
18851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18852 }
18853 arg1 = reinterpret_cast< wxEvent * >(argp1);
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (int)(arg1)->StopPropagation();
18857 wxPyEndAllowThreads(__tstate);
18858 if (PyErr_Occurred()) SWIG_fail;
18859 }
18860 resultobj = SWIG_From_int(static_cast< int >(result));
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18868 PyObject *resultobj = 0;
18869 wxEvent *arg1 = (wxEvent *) 0 ;
18870 int arg2 ;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 int val2 ;
18874 int ecode2 = 0 ;
18875 PyObject * obj0 = 0 ;
18876 PyObject * obj1 = 0 ;
18877 char * kwnames[] = {
18878 (char *) "self",(char *) "propagationLevel", NULL
18879 };
18880
18881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18883 if (!SWIG_IsOK(res1)) {
18884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18885 }
18886 arg1 = reinterpret_cast< wxEvent * >(argp1);
18887 ecode2 = SWIG_AsVal_int(obj1, &val2);
18888 if (!SWIG_IsOK(ecode2)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18890 }
18891 arg2 = static_cast< int >(val2);
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 (arg1)->ResumePropagation(arg2);
18895 wxPyEndAllowThreads(__tstate);
18896 if (PyErr_Occurred()) SWIG_fail;
18897 }
18898 resultobj = SWIG_Py_Void();
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18906 PyObject *resultobj = 0;
18907 wxEvent *arg1 = (wxEvent *) 0 ;
18908 wxEvent *result = 0 ;
18909 void *argp1 = 0 ;
18910 int res1 = 0 ;
18911 PyObject *swig_obj[1] ;
18912
18913 if (!args) SWIG_fail;
18914 swig_obj[0] = args;
18915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18916 if (!SWIG_IsOK(res1)) {
18917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18918 }
18919 arg1 = reinterpret_cast< wxEvent * >(argp1);
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 result = (wxEvent *)(arg1)->Clone();
18923 wxPyEndAllowThreads(__tstate);
18924 if (PyErr_Occurred()) SWIG_fail;
18925 }
18926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18934 PyObject *obj;
18935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18936 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18937 return SWIG_Py_Void();
18938 }
18939
18940 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18941 PyObject *resultobj = 0;
18942 wxEvent *arg1 = 0 ;
18943 wxPropagationDisabler *result = 0 ;
18944 void *argp1 = 0 ;
18945 int res1 = 0 ;
18946 PyObject * obj0 = 0 ;
18947 char * kwnames[] = {
18948 (char *) "event", NULL
18949 };
18950
18951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18952 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18953 if (!SWIG_IsOK(res1)) {
18954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18955 }
18956 if (!argp1) {
18957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18958 }
18959 arg1 = reinterpret_cast< wxEvent * >(argp1);
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18974 PyObject *resultobj = 0;
18975 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18976 void *argp1 = 0 ;
18977 int res1 = 0 ;
18978 PyObject *swig_obj[1] ;
18979
18980 if (!args) SWIG_fail;
18981 swig_obj[0] = args;
18982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18985 }
18986 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 delete arg1;
18990
18991 wxPyEndAllowThreads(__tstate);
18992 if (PyErr_Occurred()) SWIG_fail;
18993 }
18994 resultobj = SWIG_Py_Void();
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19002 PyObject *obj;
19003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19004 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19005 return SWIG_Py_Void();
19006 }
19007
19008 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19009 return SWIG_Python_InitShadowInstance(args);
19010 }
19011
19012 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxEvent *arg1 = 0 ;
19015 wxPropagateOnce *result = 0 ;
19016 void *argp1 = 0 ;
19017 int res1 = 0 ;
19018 PyObject * obj0 = 0 ;
19019 char * kwnames[] = {
19020 (char *) "event", NULL
19021 };
19022
19023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19024 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19025 if (!SWIG_IsOK(res1)) {
19026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19027 }
19028 if (!argp1) {
19029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19030 }
19031 arg1 = reinterpret_cast< wxEvent * >(argp1);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19046 PyObject *resultobj = 0;
19047 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19048 void *argp1 = 0 ;
19049 int res1 = 0 ;
19050 PyObject *swig_obj[1] ;
19051
19052 if (!args) SWIG_fail;
19053 swig_obj[0] = args;
19054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19055 if (!SWIG_IsOK(res1)) {
19056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19057 }
19058 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 delete arg1;
19062
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 resultobj = SWIG_Py_Void();
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19074 PyObject *obj;
19075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19076 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19077 return SWIG_Py_Void();
19078 }
19079
19080 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19081 return SWIG_Python_InitShadowInstance(args);
19082 }
19083
19084 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19085 PyObject *resultobj = 0;
19086 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19087 int arg2 = (int) 0 ;
19088 wxCommandEvent *result = 0 ;
19089 int val1 ;
19090 int ecode1 = 0 ;
19091 int val2 ;
19092 int ecode2 = 0 ;
19093 PyObject * obj0 = 0 ;
19094 PyObject * obj1 = 0 ;
19095 char * kwnames[] = {
19096 (char *) "commandType",(char *) "winid", NULL
19097 };
19098
19099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19100 if (obj0) {
19101 ecode1 = SWIG_AsVal_int(obj0, &val1);
19102 if (!SWIG_IsOK(ecode1)) {
19103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19104 }
19105 arg1 = static_cast< wxEventType >(val1);
19106 }
19107 if (obj1) {
19108 ecode2 = SWIG_AsVal_int(obj1, &val2);
19109 if (!SWIG_IsOK(ecode2)) {
19110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19111 }
19112 arg2 = static_cast< int >(val2);
19113 }
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19128 PyObject *resultobj = 0;
19129 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19130 int result;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject *swig_obj[1] ;
19134
19135 if (!args) SWIG_fail;
19136 swig_obj[0] = args;
19137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19138 if (!SWIG_IsOK(res1)) {
19139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19140 }
19141 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19145 wxPyEndAllowThreads(__tstate);
19146 if (PyErr_Occurred()) SWIG_fail;
19147 }
19148 resultobj = SWIG_From_int(static_cast< int >(result));
19149 return resultobj;
19150 fail:
19151 return NULL;
19152 }
19153
19154
19155 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19156 PyObject *resultobj = 0;
19157 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19158 wxString *arg2 = 0 ;
19159 void *argp1 = 0 ;
19160 int res1 = 0 ;
19161 bool temp2 = false ;
19162 PyObject * obj0 = 0 ;
19163 PyObject * obj1 = 0 ;
19164 char * kwnames[] = {
19165 (char *) "self",(char *) "s", NULL
19166 };
19167
19168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19172 }
19173 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19174 {
19175 arg2 = wxString_in_helper(obj1);
19176 if (arg2 == NULL) SWIG_fail;
19177 temp2 = true;
19178 }
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 (arg1)->SetString((wxString const &)*arg2);
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 resultobj = SWIG_Py_Void();
19186 {
19187 if (temp2)
19188 delete arg2;
19189 }
19190 return resultobj;
19191 fail:
19192 {
19193 if (temp2)
19194 delete arg2;
19195 }
19196 return NULL;
19197 }
19198
19199
19200 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19201 PyObject *resultobj = 0;
19202 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19203 wxString result;
19204 void *argp1 = 0 ;
19205 int res1 = 0 ;
19206 PyObject *swig_obj[1] ;
19207
19208 if (!args) SWIG_fail;
19209 swig_obj[0] = args;
19210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19213 }
19214 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19215 {
19216 PyThreadState* __tstate = wxPyBeginAllowThreads();
19217 result = ((wxCommandEvent const *)arg1)->GetString();
19218 wxPyEndAllowThreads(__tstate);
19219 if (PyErr_Occurred()) SWIG_fail;
19220 }
19221 {
19222 #if wxUSE_UNICODE
19223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19224 #else
19225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19226 #endif
19227 }
19228 return resultobj;
19229 fail:
19230 return NULL;
19231 }
19232
19233
19234 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19235 PyObject *resultobj = 0;
19236 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19237 bool result;
19238 void *argp1 = 0 ;
19239 int res1 = 0 ;
19240 PyObject *swig_obj[1] ;
19241
19242 if (!args) SWIG_fail;
19243 swig_obj[0] = args;
19244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19245 if (!SWIG_IsOK(res1)) {
19246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19247 }
19248 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19249 {
19250 PyThreadState* __tstate = wxPyBeginAllowThreads();
19251 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19257 }
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19265 PyObject *resultobj = 0;
19266 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19267 bool result;
19268 void *argp1 = 0 ;
19269 int res1 = 0 ;
19270 PyObject *swig_obj[1] ;
19271
19272 if (!args) SWIG_fail;
19273 swig_obj[0] = args;
19274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19275 if (!SWIG_IsOK(res1)) {
19276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19277 }
19278 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19279 {
19280 PyThreadState* __tstate = wxPyBeginAllowThreads();
19281 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19287 }
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19295 PyObject *resultobj = 0;
19296 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19297 long arg2 ;
19298 void *argp1 = 0 ;
19299 int res1 = 0 ;
19300 long val2 ;
19301 int ecode2 = 0 ;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 char * kwnames[] = {
19305 (char *) "self",(char *) "extraLong", NULL
19306 };
19307
19308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19310 if (!SWIG_IsOK(res1)) {
19311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19312 }
19313 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19314 ecode2 = SWIG_AsVal_long(obj1, &val2);
19315 if (!SWIG_IsOK(ecode2)) {
19316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19317 }
19318 arg2 = static_cast< long >(val2);
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 (arg1)->SetExtraLong(arg2);
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 resultobj = SWIG_Py_Void();
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 PyObject *resultobj = 0;
19334 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19335 long result;
19336 void *argp1 = 0 ;
19337 int res1 = 0 ;
19338 PyObject *swig_obj[1] ;
19339
19340 if (!args) SWIG_fail;
19341 swig_obj[0] = args;
19342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19343 if (!SWIG_IsOK(res1)) {
19344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19345 }
19346 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19347 {
19348 PyThreadState* __tstate = wxPyBeginAllowThreads();
19349 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 resultobj = SWIG_From_long(static_cast< long >(result));
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj = 0;
19362 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19363 int arg2 ;
19364 void *argp1 = 0 ;
19365 int res1 = 0 ;
19366 int val2 ;
19367 int ecode2 = 0 ;
19368 PyObject * obj0 = 0 ;
19369 PyObject * obj1 = 0 ;
19370 char * kwnames[] = {
19371 (char *) "self",(char *) "i", NULL
19372 };
19373
19374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19376 if (!SWIG_IsOK(res1)) {
19377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19378 }
19379 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19380 ecode2 = SWIG_AsVal_int(obj1, &val2);
19381 if (!SWIG_IsOK(ecode2)) {
19382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19383 }
19384 arg2 = static_cast< int >(val2);
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->SetInt(arg2);
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_Py_Void();
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 PyObject *resultobj = 0;
19400 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19401 int result;
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_wxCommandEvent, 0 | 0 );
19409 if (!SWIG_IsOK(res1)) {
19410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19411 }
19412 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 resultobj = SWIG_From_int(static_cast< int >(result));
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19427 PyObject *resultobj = 0;
19428 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19429 PyObject *result = 0 ;
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_wxCommandEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 resultobj = result;
19448 return resultobj;
19449 fail:
19450 return NULL;
19451 }
19452
19453
19454 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19455 PyObject *resultobj = 0;
19456 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19457 PyObject *arg2 = (PyObject *) 0 ;
19458 void *argp1 = 0 ;
19459 int res1 = 0 ;
19460 PyObject * obj0 = 0 ;
19461 PyObject * obj1 = 0 ;
19462 char * kwnames[] = {
19463 (char *) "self",(char *) "clientData", NULL
19464 };
19465
19466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19468 if (!SWIG_IsOK(res1)) {
19469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19470 }
19471 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19472 arg2 = obj1;
19473 {
19474 PyThreadState* __tstate = wxPyBeginAllowThreads();
19475 wxCommandEvent_SetClientData(arg1,arg2);
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 resultobj = SWIG_Py_Void();
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19487 PyObject *resultobj = 0;
19488 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19489 wxEvent *result = 0 ;
19490 void *argp1 = 0 ;
19491 int res1 = 0 ;
19492 PyObject *swig_obj[1] ;
19493
19494 if (!args) SWIG_fail;
19495 swig_obj[0] = args;
19496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19497 if (!SWIG_IsOK(res1)) {
19498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19499 }
19500 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 PyObject *obj;
19516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19517 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19518 return SWIG_Py_Void();
19519 }
19520
19521 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19522 return SWIG_Python_InitShadowInstance(args);
19523 }
19524
19525 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj = 0;
19527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19528 int arg2 = (int) 0 ;
19529 wxNotifyEvent *result = 0 ;
19530 int val1 ;
19531 int ecode1 = 0 ;
19532 int val2 ;
19533 int ecode2 = 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 char * kwnames[] = {
19537 (char *) "commandType",(char *) "winid", NULL
19538 };
19539
19540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19541 if (obj0) {
19542 ecode1 = SWIG_AsVal_int(obj0, &val1);
19543 if (!SWIG_IsOK(ecode1)) {
19544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19545 }
19546 arg1 = static_cast< wxEventType >(val1);
19547 }
19548 if (obj1) {
19549 ecode2 = SWIG_AsVal_int(obj1, &val2);
19550 if (!SWIG_IsOK(ecode2)) {
19551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19552 }
19553 arg2 = static_cast< int >(val2);
19554 }
19555 {
19556 PyThreadState* __tstate = wxPyBeginAllowThreads();
19557 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19558 wxPyEndAllowThreads(__tstate);
19559 if (PyErr_Occurred()) SWIG_fail;
19560 }
19561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19562 return resultobj;
19563 fail:
19564 return NULL;
19565 }
19566
19567
19568 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19569 PyObject *resultobj = 0;
19570 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19571 void *argp1 = 0 ;
19572 int res1 = 0 ;
19573 PyObject *swig_obj[1] ;
19574
19575 if (!args) SWIG_fail;
19576 swig_obj[0] = args;
19577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19580 }
19581 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19582 {
19583 PyThreadState* __tstate = wxPyBeginAllowThreads();
19584 (arg1)->Veto();
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 resultobj = SWIG_Py_Void();
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 PyObject *resultobj = 0;
19597 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19598 void *argp1 = 0 ;
19599 int res1 = 0 ;
19600 PyObject *swig_obj[1] ;
19601
19602 if (!args) SWIG_fail;
19603 swig_obj[0] = args;
19604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19605 if (!SWIG_IsOK(res1)) {
19606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19607 }
19608 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 (arg1)->Allow();
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_Py_Void();
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19623 PyObject *resultobj = 0;
19624 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19625 bool result;
19626 void *argp1 = 0 ;
19627 int res1 = 0 ;
19628 PyObject *swig_obj[1] ;
19629
19630 if (!args) SWIG_fail;
19631 swig_obj[0] = args;
19632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19633 if (!SWIG_IsOK(res1)) {
19634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19635 }
19636 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 result = (bool)(arg1)->IsAllowed();
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 {
19644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19645 }
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19653 PyObject *obj;
19654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19655 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19656 return SWIG_Py_Void();
19657 }
19658
19659 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19660 return SWIG_Python_InitShadowInstance(args);
19661 }
19662
19663 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj = 0;
19665 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19666 int arg2 = (int) 0 ;
19667 int arg3 = (int) 0 ;
19668 int arg4 = (int) 0 ;
19669 wxScrollEvent *result = 0 ;
19670 int val1 ;
19671 int ecode1 = 0 ;
19672 int val2 ;
19673 int ecode2 = 0 ;
19674 int val3 ;
19675 int ecode3 = 0 ;
19676 int val4 ;
19677 int ecode4 = 0 ;
19678 PyObject * obj0 = 0 ;
19679 PyObject * obj1 = 0 ;
19680 PyObject * obj2 = 0 ;
19681 PyObject * obj3 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19687 if (obj0) {
19688 ecode1 = SWIG_AsVal_int(obj0, &val1);
19689 if (!SWIG_IsOK(ecode1)) {
19690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19691 }
19692 arg1 = static_cast< wxEventType >(val1);
19693 }
19694 if (obj1) {
19695 ecode2 = SWIG_AsVal_int(obj1, &val2);
19696 if (!SWIG_IsOK(ecode2)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19698 }
19699 arg2 = static_cast< int >(val2);
19700 }
19701 if (obj2) {
19702 ecode3 = SWIG_AsVal_int(obj2, &val3);
19703 if (!SWIG_IsOK(ecode3)) {
19704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19705 }
19706 arg3 = static_cast< int >(val3);
19707 }
19708 if (obj3) {
19709 ecode4 = SWIG_AsVal_int(obj3, &val4);
19710 if (!SWIG_IsOK(ecode4)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19712 }
19713 arg4 = static_cast< int >(val4);
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19731 int result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19741 }
19742 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_From_int(static_cast< int >(result));
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19769 }
19770 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19785 PyObject *resultobj = 0;
19786 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19787 int arg2 ;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 int val2 ;
19791 int ecode2 = 0 ;
19792 PyObject * obj0 = 0 ;
19793 PyObject * obj1 = 0 ;
19794 char * kwnames[] = {
19795 (char *) "self",(char *) "orient", NULL
19796 };
19797
19798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19802 }
19803 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19804 ecode2 = SWIG_AsVal_int(obj1, &val2);
19805 if (!SWIG_IsOK(ecode2)) {
19806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19807 }
19808 arg2 = static_cast< int >(val2);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetOrientation(arg2);
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = SWIG_Py_Void();
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19825 int arg2 ;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 int val2 ;
19829 int ecode2 = 0 ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "pos", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19840 }
19841 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 (arg1)->SetPosition(arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_Py_Void();
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19861 PyObject *obj;
19862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19863 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19864 return SWIG_Py_Void();
19865 }
19866
19867 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 return SWIG_Python_InitShadowInstance(args);
19869 }
19870
19871 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj = 0;
19873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19874 int arg2 = (int) 0 ;
19875 int arg3 = (int) 0 ;
19876 wxScrollWinEvent *result = 0 ;
19877 int val1 ;
19878 int ecode1 = 0 ;
19879 int val2 ;
19880 int ecode2 = 0 ;
19881 int val3 ;
19882 int ecode3 = 0 ;
19883 PyObject * obj0 = 0 ;
19884 PyObject * obj1 = 0 ;
19885 PyObject * obj2 = 0 ;
19886 char * kwnames[] = {
19887 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19888 };
19889
19890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19891 if (obj0) {
19892 ecode1 = SWIG_AsVal_int(obj0, &val1);
19893 if (!SWIG_IsOK(ecode1)) {
19894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19895 }
19896 arg1 = static_cast< wxEventType >(val1);
19897 }
19898 if (obj1) {
19899 ecode2 = SWIG_AsVal_int(obj1, &val2);
19900 if (!SWIG_IsOK(ecode2)) {
19901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19902 }
19903 arg2 = static_cast< int >(val2);
19904 }
19905 if (obj2) {
19906 ecode3 = SWIG_AsVal_int(obj2, &val3);
19907 if (!SWIG_IsOK(ecode3)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19909 }
19910 arg3 = static_cast< int >(val3);
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19915 wxPyEndAllowThreads(__tstate);
19916 if (PyErr_Occurred()) SWIG_fail;
19917 }
19918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19919 return resultobj;
19920 fail:
19921 return NULL;
19922 }
19923
19924
19925 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19926 PyObject *resultobj = 0;
19927 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19928 int result;
19929 void *argp1 = 0 ;
19930 int res1 = 0 ;
19931 PyObject *swig_obj[1] ;
19932
19933 if (!args) SWIG_fail;
19934 swig_obj[0] = args;
19935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19936 if (!SWIG_IsOK(res1)) {
19937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19938 }
19939 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 resultobj = SWIG_From_int(static_cast< int >(result));
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19954 PyObject *resultobj = 0;
19955 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19956 int result;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 PyObject *swig_obj[1] ;
19960
19961 if (!args) SWIG_fail;
19962 swig_obj[0] = args;
19963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19964 if (!SWIG_IsOK(res1)) {
19965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19966 }
19967 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = SWIG_From_int(static_cast< int >(result));
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19982 PyObject *resultobj = 0;
19983 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19984 int arg2 ;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 int val2 ;
19988 int ecode2 = 0 ;
19989 PyObject * obj0 = 0 ;
19990 PyObject * obj1 = 0 ;
19991 char * kwnames[] = {
19992 (char *) "self",(char *) "orient", NULL
19993 };
19994
19995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19997 if (!SWIG_IsOK(res1)) {
19998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19999 }
20000 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20001 ecode2 = SWIG_AsVal_int(obj1, &val2);
20002 if (!SWIG_IsOK(ecode2)) {
20003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20004 }
20005 arg2 = static_cast< int >(val2);
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 (arg1)->SetOrientation(arg2);
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 resultobj = SWIG_Py_Void();
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20020 PyObject *resultobj = 0;
20021 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20022 int arg2 ;
20023 void *argp1 = 0 ;
20024 int res1 = 0 ;
20025 int val2 ;
20026 int ecode2 = 0 ;
20027 PyObject * obj0 = 0 ;
20028 PyObject * obj1 = 0 ;
20029 char * kwnames[] = {
20030 (char *) "self",(char *) "pos", NULL
20031 };
20032
20033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20035 if (!SWIG_IsOK(res1)) {
20036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20037 }
20038 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20039 ecode2 = SWIG_AsVal_int(obj1, &val2);
20040 if (!SWIG_IsOK(ecode2)) {
20041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20042 }
20043 arg2 = static_cast< int >(val2);
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 (arg1)->SetPosition(arg2);
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 resultobj = SWIG_Py_Void();
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20058 PyObject *obj;
20059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20060 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20061 return SWIG_Py_Void();
20062 }
20063
20064 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20065 return SWIG_Python_InitShadowInstance(args);
20066 }
20067
20068 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20069 PyObject *resultobj = 0;
20070 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20071 wxMouseEvent *result = 0 ;
20072 int val1 ;
20073 int ecode1 = 0 ;
20074 PyObject * obj0 = 0 ;
20075 char * kwnames[] = {
20076 (char *) "mouseType", NULL
20077 };
20078
20079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20080 if (obj0) {
20081 ecode1 = SWIG_AsVal_int(obj0, &val1);
20082 if (!SWIG_IsOK(ecode1)) {
20083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20084 }
20085 arg1 = static_cast< wxEventType >(val1);
20086 }
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 {
20094 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20103 PyObject *resultobj = 0;
20104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20105 bool result;
20106 void *argp1 = 0 ;
20107 int res1 = 0 ;
20108 PyObject *swig_obj[1] ;
20109
20110 if (!args) SWIG_fail;
20111 swig_obj[0] = args;
20112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20113 if (!SWIG_IsOK(res1)) {
20114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20115 }
20116 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj = 0;
20134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20135 int arg2 = (int) wxMOUSE_BTN_ANY ;
20136 bool result;
20137 void *argp1 = 0 ;
20138 int res1 = 0 ;
20139 int val2 ;
20140 int ecode2 = 0 ;
20141 PyObject * obj0 = 0 ;
20142 PyObject * obj1 = 0 ;
20143 char * kwnames[] = {
20144 (char *) "self",(char *) "but", NULL
20145 };
20146
20147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20149 if (!SWIG_IsOK(res1)) {
20150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20151 }
20152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20153 if (obj1) {
20154 ecode2 = SWIG_AsVal_int(obj1, &val2);
20155 if (!SWIG_IsOK(ecode2)) {
20156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20157 }
20158 arg2 = static_cast< int >(val2);
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 {
20167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20168 }
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20176 PyObject *resultobj = 0;
20177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20178 int arg2 = (int) wxMOUSE_BTN_ANY ;
20179 bool result;
20180 void *argp1 = 0 ;
20181 int res1 = 0 ;
20182 int val2 ;
20183 int ecode2 = 0 ;
20184 PyObject * obj0 = 0 ;
20185 PyObject * obj1 = 0 ;
20186 char * kwnames[] = {
20187 (char *) "self",(char *) "but", NULL
20188 };
20189
20190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20194 }
20195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20196 if (obj1) {
20197 ecode2 = SWIG_AsVal_int(obj1, &val2);
20198 if (!SWIG_IsOK(ecode2)) {
20199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20200 }
20201 arg2 = static_cast< int >(val2);
20202 }
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 {
20210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20211 }
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20219 PyObject *resultobj = 0;
20220 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20221 int arg2 = (int) wxMOUSE_BTN_ANY ;
20222 bool result;
20223 void *argp1 = 0 ;
20224 int res1 = 0 ;
20225 int val2 ;
20226 int ecode2 = 0 ;
20227 PyObject * obj0 = 0 ;
20228 PyObject * obj1 = 0 ;
20229 char * kwnames[] = {
20230 (char *) "self",(char *) "but", NULL
20231 };
20232
20233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20235 if (!SWIG_IsOK(res1)) {
20236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20237 }
20238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20239 if (obj1) {
20240 ecode2 = SWIG_AsVal_int(obj1, &val2);
20241 if (!SWIG_IsOK(ecode2)) {
20242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20243 }
20244 arg2 = static_cast< int >(val2);
20245 }
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 {
20253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20254 }
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20262 PyObject *resultobj = 0;
20263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20264 int arg2 ;
20265 bool result;
20266 void *argp1 = 0 ;
20267 int res1 = 0 ;
20268 int val2 ;
20269 int ecode2 = 0 ;
20270 PyObject * obj0 = 0 ;
20271 PyObject * obj1 = 0 ;
20272 char * kwnames[] = {
20273 (char *) "self",(char *) "button", NULL
20274 };
20275
20276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20280 }
20281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20282 ecode2 = SWIG_AsVal_int(obj1, &val2);
20283 if (!SWIG_IsOK(ecode2)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20285 }
20286 arg2 = static_cast< int >(val2);
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj = 0;
20304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20305 int arg2 ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 int val2 ;
20310 int ecode2 = 0 ;
20311 PyObject * obj0 = 0 ;
20312 PyObject * obj1 = 0 ;
20313 char * kwnames[] = {
20314 (char *) "self",(char *) "but", NULL
20315 };
20316
20317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20319 if (!SWIG_IsOK(res1)) {
20320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20321 }
20322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20323 ecode2 = SWIG_AsVal_int(obj1, &val2);
20324 if (!SWIG_IsOK(ecode2)) {
20325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20326 }
20327 arg2 = static_cast< int >(val2);
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20331 wxPyEndAllowThreads(__tstate);
20332 if (PyErr_Occurred()) SWIG_fail;
20333 }
20334 {
20335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20336 }
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 PyObject *resultobj = 0;
20345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20346 int result;
20347 void *argp1 = 0 ;
20348 int res1 = 0 ;
20349 PyObject *swig_obj[1] ;
20350
20351 if (!args) SWIG_fail;
20352 swig_obj[0] = args;
20353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20356 }
20357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 resultobj = SWIG_From_int(static_cast< int >(result));
20365 return resultobj;
20366 fail:
20367 return NULL;
20368 }
20369
20370
20371 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20372 PyObject *resultobj = 0;
20373 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20374 bool result;
20375 void *argp1 = 0 ;
20376 int res1 = 0 ;
20377 PyObject *swig_obj[1] ;
20378
20379 if (!args) SWIG_fail;
20380 swig_obj[0] = args;
20381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20382 if (!SWIG_IsOK(res1)) {
20383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20384 }
20385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 {
20393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20394 }
20395 return resultobj;
20396 fail:
20397 return NULL;
20398 }
20399
20400
20401 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20402 PyObject *resultobj = 0;
20403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20404 bool result;
20405 void *argp1 = 0 ;
20406 int res1 = 0 ;
20407 PyObject *swig_obj[1] ;
20408
20409 if (!args) SWIG_fail;
20410 swig_obj[0] = args;
20411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20412 if (!SWIG_IsOK(res1)) {
20413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20414 }
20415 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20416 {
20417 PyThreadState* __tstate = wxPyBeginAllowThreads();
20418 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 {
20423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20424 }
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *resultobj = 0;
20433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20434 bool result;
20435 void *argp1 = 0 ;
20436 int res1 = 0 ;
20437 PyObject *swig_obj[1] ;
20438
20439 if (!args) SWIG_fail;
20440 swig_obj[0] = args;
20441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20442 if (!SWIG_IsOK(res1)) {
20443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20444 }
20445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20446 {
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20449 wxPyEndAllowThreads(__tstate);
20450 if (PyErr_Occurred()) SWIG_fail;
20451 }
20452 {
20453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20454 }
20455 return resultobj;
20456 fail:
20457 return NULL;
20458 }
20459
20460
20461 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462 PyObject *resultobj = 0;
20463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20464 bool result;
20465 void *argp1 = 0 ;
20466 int res1 = 0 ;
20467 PyObject *swig_obj[1] ;
20468
20469 if (!args) SWIG_fail;
20470 swig_obj[0] = args;
20471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20472 if (!SWIG_IsOK(res1)) {
20473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20474 }
20475 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 {
20483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20484 }
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20492 PyObject *resultobj = 0;
20493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20494 bool result;
20495 void *argp1 = 0 ;
20496 int res1 = 0 ;
20497 PyObject *swig_obj[1] ;
20498
20499 if (!args) SWIG_fail;
20500 swig_obj[0] = args;
20501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20504 }
20505 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 {
20513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20514 }
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20522 PyObject *resultobj = 0;
20523 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20524 bool result;
20525 void *argp1 = 0 ;
20526 int res1 = 0 ;
20527 PyObject *swig_obj[1] ;
20528
20529 if (!args) SWIG_fail;
20530 swig_obj[0] = args;
20531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20532 if (!SWIG_IsOK(res1)) {
20533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20534 }
20535 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20536 {
20537 PyThreadState* __tstate = wxPyBeginAllowThreads();
20538 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 {
20543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20544 }
20545 return resultobj;
20546 fail:
20547 return NULL;
20548 }
20549
20550
20551 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20552 PyObject *resultobj = 0;
20553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20554 bool result;
20555 void *argp1 = 0 ;
20556 int res1 = 0 ;
20557 PyObject *swig_obj[1] ;
20558
20559 if (!args) SWIG_fail;
20560 swig_obj[0] = args;
20561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20562 if (!SWIG_IsOK(res1)) {
20563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20564 }
20565 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20566 {
20567 PyThreadState* __tstate = wxPyBeginAllowThreads();
20568 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 {
20573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20574 }
20575 return resultobj;
20576 fail:
20577 return NULL;
20578 }
20579
20580
20581 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20582 PyObject *resultobj = 0;
20583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20584 bool result;
20585 void *argp1 = 0 ;
20586 int res1 = 0 ;
20587 PyObject *swig_obj[1] ;
20588
20589 if (!args) SWIG_fail;
20590 swig_obj[0] = args;
20591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20594 }
20595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20596 {
20597 PyThreadState* __tstate = wxPyBeginAllowThreads();
20598 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 {
20603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20604 }
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20612 PyObject *resultobj = 0;
20613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20614 bool result;
20615 void *argp1 = 0 ;
20616 int res1 = 0 ;
20617 PyObject *swig_obj[1] ;
20618
20619 if (!args) SWIG_fail;
20620 swig_obj[0] = args;
20621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20622 if (!SWIG_IsOK(res1)) {
20623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20624 }
20625 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20629 wxPyEndAllowThreads(__tstate);
20630 if (PyErr_Occurred()) SWIG_fail;
20631 }
20632 {
20633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20634 }
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20642 PyObject *resultobj = 0;
20643 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20644 bool result;
20645 void *argp1 = 0 ;
20646 int res1 = 0 ;
20647 PyObject *swig_obj[1] ;
20648
20649 if (!args) SWIG_fail;
20650 swig_obj[0] = args;
20651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20652 if (!SWIG_IsOK(res1)) {
20653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20654 }
20655 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 {
20663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20672 PyObject *resultobj = 0;
20673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20674 bool result;
20675 void *argp1 = 0 ;
20676 int res1 = 0 ;
20677 PyObject *swig_obj[1] ;
20678
20679 if (!args) SWIG_fail;
20680 swig_obj[0] = args;
20681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20682 if (!SWIG_IsOK(res1)) {
20683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20684 }
20685 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20702 PyObject *resultobj = 0;
20703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20704 bool result;
20705 void *argp1 = 0 ;
20706 int res1 = 0 ;
20707 PyObject *swig_obj[1] ;
20708
20709 if (!args) SWIG_fail;
20710 swig_obj[0] = args;
20711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20712 if (!SWIG_IsOK(res1)) {
20713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20714 }
20715 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20716 {
20717 PyThreadState* __tstate = wxPyBeginAllowThreads();
20718 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 {
20723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20724 }
20725 return resultobj;
20726 fail:
20727 return NULL;
20728 }
20729
20730
20731 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20732 PyObject *resultobj = 0;
20733 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20734 bool result;
20735 void *argp1 = 0 ;
20736 int res1 = 0 ;
20737 PyObject *swig_obj[1] ;
20738
20739 if (!args) SWIG_fail;
20740 swig_obj[0] = args;
20741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20742 if (!SWIG_IsOK(res1)) {
20743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20744 }
20745 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 {
20753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20754 }
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20762 PyObject *resultobj = 0;
20763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20764 bool result;
20765 void *argp1 = 0 ;
20766 int res1 = 0 ;
20767 PyObject *swig_obj[1] ;
20768
20769 if (!args) SWIG_fail;
20770 swig_obj[0] = args;
20771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20772 if (!SWIG_IsOK(res1)) {
20773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20774 }
20775 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20776 {
20777 PyThreadState* __tstate = wxPyBeginAllowThreads();
20778 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 {
20783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20784 }
20785 return resultobj;
20786 fail:
20787 return NULL;
20788 }
20789
20790
20791 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20792 PyObject *resultobj = 0;
20793 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20794 bool result;
20795 void *argp1 = 0 ;
20796 int res1 = 0 ;
20797 PyObject *swig_obj[1] ;
20798
20799 if (!args) SWIG_fail;
20800 swig_obj[0] = args;
20801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (bool)(arg1)->LeftIsDown();
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 {
20813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20814 }
20815 return resultobj;
20816 fail:
20817 return NULL;
20818 }
20819
20820
20821 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20822 PyObject *resultobj = 0;
20823 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20824 bool result;
20825 void *argp1 = 0 ;
20826 int res1 = 0 ;
20827 PyObject *swig_obj[1] ;
20828
20829 if (!args) SWIG_fail;
20830 swig_obj[0] = args;
20831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20832 if (!SWIG_IsOK(res1)) {
20833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20834 }
20835 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (bool)(arg1)->MiddleIsDown();
20839 wxPyEndAllowThreads(__tstate);
20840 if (PyErr_Occurred()) SWIG_fail;
20841 }
20842 {
20843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20844 }
20845 return resultobj;
20846 fail:
20847 return NULL;
20848 }
20849
20850
20851 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20852 PyObject *resultobj = 0;
20853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20854 bool result;
20855 void *argp1 = 0 ;
20856 int res1 = 0 ;
20857 PyObject *swig_obj[1] ;
20858
20859 if (!args) SWIG_fail;
20860 swig_obj[0] = args;
20861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20862 if (!SWIG_IsOK(res1)) {
20863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20864 }
20865 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = (bool)(arg1)->RightIsDown();
20869 wxPyEndAllowThreads(__tstate);
20870 if (PyErr_Occurred()) SWIG_fail;
20871 }
20872 {
20873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20874 }
20875 return resultobj;
20876 fail:
20877 return NULL;
20878 }
20879
20880
20881 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20882 PyObject *resultobj = 0;
20883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20884 bool result;
20885 void *argp1 = 0 ;
20886 int res1 = 0 ;
20887 PyObject *swig_obj[1] ;
20888
20889 if (!args) SWIG_fail;
20890 swig_obj[0] = args;
20891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20892 if (!SWIG_IsOK(res1)) {
20893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20894 }
20895 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 {
20903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20904 }
20905 return resultobj;
20906 fail:
20907 return NULL;
20908 }
20909
20910
20911 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912 PyObject *resultobj = 0;
20913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20914 bool result;
20915 void *argp1 = 0 ;
20916 int res1 = 0 ;
20917 PyObject *swig_obj[1] ;
20918
20919 if (!args) SWIG_fail;
20920 swig_obj[0] = args;
20921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20922 if (!SWIG_IsOK(res1)) {
20923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20924 }
20925 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20929 wxPyEndAllowThreads(__tstate);
20930 if (PyErr_Occurred()) SWIG_fail;
20931 }
20932 {
20933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20934 }
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20942 PyObject *resultobj = 0;
20943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20944 bool result;
20945 void *argp1 = 0 ;
20946 int res1 = 0 ;
20947 PyObject *swig_obj[1] ;
20948
20949 if (!args) SWIG_fail;
20950 swig_obj[0] = args;
20951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20952 if (!SWIG_IsOK(res1)) {
20953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20954 }
20955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20959 wxPyEndAllowThreads(__tstate);
20960 if (PyErr_Occurred()) SWIG_fail;
20961 }
20962 {
20963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20964 }
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20972 PyObject *resultobj = 0;
20973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20974 bool result;
20975 void *argp1 = 0 ;
20976 int res1 = 0 ;
20977 PyObject *swig_obj[1] ;
20978
20979 if (!args) SWIG_fail;
20980 swig_obj[0] = args;
20981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20984 }
20985 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20989 wxPyEndAllowThreads(__tstate);
20990 if (PyErr_Occurred()) SWIG_fail;
20991 }
20992 {
20993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20994 }
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21002 PyObject *resultobj = 0;
21003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21004 wxPoint result;
21005 void *argp1 = 0 ;
21006 int res1 = 0 ;
21007 PyObject *swig_obj[1] ;
21008
21009 if (!args) SWIG_fail;
21010 swig_obj[0] = args;
21011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21012 if (!SWIG_IsOK(res1)) {
21013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21014 }
21015 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21016 {
21017 PyThreadState* __tstate = wxPyBeginAllowThreads();
21018 result = (arg1)->GetPosition();
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21032 long *arg2 = (long *) 0 ;
21033 long *arg3 = (long *) 0 ;
21034 void *argp1 = 0 ;
21035 int res1 = 0 ;
21036 long temp2 ;
21037 int res2 = SWIG_TMPOBJ ;
21038 long temp3 ;
21039 int res3 = SWIG_TMPOBJ ;
21040 PyObject *swig_obj[1] ;
21041
21042 arg2 = &temp2;
21043 arg3 = &temp3;
21044 if (!args) SWIG_fail;
21045 swig_obj[0] = args;
21046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21047 if (!SWIG_IsOK(res1)) {
21048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21049 }
21050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21051 {
21052 PyThreadState* __tstate = wxPyBeginAllowThreads();
21053 (arg1)->GetPosition(arg2,arg3);
21054 wxPyEndAllowThreads(__tstate);
21055 if (PyErr_Occurred()) SWIG_fail;
21056 }
21057 resultobj = SWIG_Py_Void();
21058 if (SWIG_IsTmpObj(res2)) {
21059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21060 } else {
21061 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21063 }
21064 if (SWIG_IsTmpObj(res3)) {
21065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21066 } else {
21067 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21077 PyObject *resultobj = 0;
21078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21079 wxDC *arg2 = 0 ;
21080 wxPoint result;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 void *argp2 = 0 ;
21084 int res2 = 0 ;
21085 PyObject * obj0 = 0 ;
21086 PyObject * obj1 = 0 ;
21087 char * kwnames[] = {
21088 (char *) "self",(char *) "dc", NULL
21089 };
21090
21091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21095 }
21096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21098 if (!SWIG_IsOK(res2)) {
21099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21100 }
21101 if (!argp2) {
21102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21103 }
21104 arg2 = reinterpret_cast< wxDC * >(argp2);
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *resultobj = 0;
21120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21121 int result;
21122 void *argp1 = 0 ;
21123 int res1 = 0 ;
21124 PyObject *swig_obj[1] ;
21125
21126 if (!args) SWIG_fail;
21127 swig_obj[0] = args;
21128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21129 if (!SWIG_IsOK(res1)) {
21130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21131 }
21132 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (int)((wxMouseEvent const *)arg1)->GetX();
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 resultobj = SWIG_From_int(static_cast< int >(result));
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21149 int result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
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_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21159 }
21160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = (int)((wxMouseEvent const *)arg1)->GetY();
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 resultobj = SWIG_From_int(static_cast< int >(result));
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21177 int result;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21187 }
21188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 resultobj = SWIG_From_int(static_cast< int >(result));
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21203 PyObject *resultobj = 0;
21204 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21205 int result;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 PyObject *swig_obj[1] ;
21209
21210 if (!args) SWIG_fail;
21211 swig_obj[0] = args;
21212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21215 }
21216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 resultobj = SWIG_From_int(static_cast< int >(result));
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21233 int result;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21243 }
21244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 resultobj = SWIG_From_int(static_cast< int >(result));
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21259 PyObject *resultobj = 0;
21260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21261 bool result;
21262 void *argp1 = 0 ;
21263 int res1 = 0 ;
21264 PyObject *swig_obj[1] ;
21265
21266 if (!args) SWIG_fail;
21267 swig_obj[0] = args;
21268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 {
21280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21289 PyObject *resultobj = 0;
21290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21291 int arg2 ;
21292 void *argp1 = 0 ;
21293 int res1 = 0 ;
21294 int val2 ;
21295 int ecode2 = 0 ;
21296 PyObject *swig_obj[2] ;
21297
21298 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21300 if (!SWIG_IsOK(res1)) {
21301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21302 }
21303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21304 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21305 if (!SWIG_IsOK(ecode2)) {
21306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21307 }
21308 arg2 = static_cast< int >(val2);
21309 if (arg1) (arg1)->m_x = arg2;
21310
21311 resultobj = SWIG_Py_Void();
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21321 int result;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 PyObject *swig_obj[1] ;
21325
21326 if (!args) SWIG_fail;
21327 swig_obj[0] = args;
21328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21329 if (!SWIG_IsOK(res1)) {
21330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21331 }
21332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21333 result = (int) ((arg1)->m_x);
21334 resultobj = SWIG_From_int(static_cast< int >(result));
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21342 PyObject *resultobj = 0;
21343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21344 int arg2 ;
21345 void *argp1 = 0 ;
21346 int res1 = 0 ;
21347 int val2 ;
21348 int ecode2 = 0 ;
21349 PyObject *swig_obj[2] ;
21350
21351 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21353 if (!SWIG_IsOK(res1)) {
21354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21355 }
21356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21357 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21358 if (!SWIG_IsOK(ecode2)) {
21359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21360 }
21361 arg2 = static_cast< int >(val2);
21362 if (arg1) (arg1)->m_y = arg2;
21363
21364 resultobj = SWIG_Py_Void();
21365 return resultobj;
21366 fail:
21367 return NULL;
21368 }
21369
21370
21371 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21372 PyObject *resultobj = 0;
21373 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21374 int result;
21375 void *argp1 = 0 ;
21376 int res1 = 0 ;
21377 PyObject *swig_obj[1] ;
21378
21379 if (!args) SWIG_fail;
21380 swig_obj[0] = args;
21381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21382 if (!SWIG_IsOK(res1)) {
21383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21384 }
21385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21386 result = (int) ((arg1)->m_y);
21387 resultobj = SWIG_From_int(static_cast< int >(result));
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21395 PyObject *resultobj = 0;
21396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21397 bool arg2 ;
21398 void *argp1 = 0 ;
21399 int res1 = 0 ;
21400 bool val2 ;
21401 int ecode2 = 0 ;
21402 PyObject *swig_obj[2] ;
21403
21404 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21408 }
21409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21410 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21411 if (!SWIG_IsOK(ecode2)) {
21412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21413 }
21414 arg2 = static_cast< bool >(val2);
21415 if (arg1) (arg1)->m_leftDown = arg2;
21416
21417 resultobj = SWIG_Py_Void();
21418 return resultobj;
21419 fail:
21420 return NULL;
21421 }
21422
21423
21424 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21425 PyObject *resultobj = 0;
21426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21427 bool result;
21428 void *argp1 = 0 ;
21429 int res1 = 0 ;
21430 PyObject *swig_obj[1] ;
21431
21432 if (!args) SWIG_fail;
21433 swig_obj[0] = args;
21434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21435 if (!SWIG_IsOK(res1)) {
21436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21437 }
21438 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21439 result = (bool) ((arg1)->m_leftDown);
21440 {
21441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21442 }
21443 return resultobj;
21444 fail:
21445 return NULL;
21446 }
21447
21448
21449 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21450 PyObject *resultobj = 0;
21451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21452 bool arg2 ;
21453 void *argp1 = 0 ;
21454 int res1 = 0 ;
21455 bool val2 ;
21456 int ecode2 = 0 ;
21457 PyObject *swig_obj[2] ;
21458
21459 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21461 if (!SWIG_IsOK(res1)) {
21462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21463 }
21464 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21465 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21466 if (!SWIG_IsOK(ecode2)) {
21467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21468 }
21469 arg2 = static_cast< bool >(val2);
21470 if (arg1) (arg1)->m_middleDown = arg2;
21471
21472 resultobj = SWIG_Py_Void();
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21480 PyObject *resultobj = 0;
21481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21482 bool result;
21483 void *argp1 = 0 ;
21484 int res1 = 0 ;
21485 PyObject *swig_obj[1] ;
21486
21487 if (!args) SWIG_fail;
21488 swig_obj[0] = args;
21489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21490 if (!SWIG_IsOK(res1)) {
21491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21492 }
21493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21494 result = (bool) ((arg1)->m_middleDown);
21495 {
21496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21497 }
21498 return resultobj;
21499 fail:
21500 return NULL;
21501 }
21502
21503
21504 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21505 PyObject *resultobj = 0;
21506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21507 bool arg2 ;
21508 void *argp1 = 0 ;
21509 int res1 = 0 ;
21510 bool val2 ;
21511 int ecode2 = 0 ;
21512 PyObject *swig_obj[2] ;
21513
21514 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21516 if (!SWIG_IsOK(res1)) {
21517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21518 }
21519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21520 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21521 if (!SWIG_IsOK(ecode2)) {
21522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21523 }
21524 arg2 = static_cast< bool >(val2);
21525 if (arg1) (arg1)->m_rightDown = arg2;
21526
21527 resultobj = SWIG_Py_Void();
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21535 PyObject *resultobj = 0;
21536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21537 bool result;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 PyObject *swig_obj[1] ;
21541
21542 if (!args) SWIG_fail;
21543 swig_obj[0] = args;
21544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21545 if (!SWIG_IsOK(res1)) {
21546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21547 }
21548 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21549 result = (bool) ((arg1)->m_rightDown);
21550 {
21551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21552 }
21553 return resultobj;
21554 fail:
21555 return NULL;
21556 }
21557
21558
21559 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21560 PyObject *resultobj = 0;
21561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21562 bool arg2 ;
21563 void *argp1 = 0 ;
21564 int res1 = 0 ;
21565 bool val2 ;
21566 int ecode2 = 0 ;
21567 PyObject *swig_obj[2] ;
21568
21569 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21571 if (!SWIG_IsOK(res1)) {
21572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21573 }
21574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21575 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21576 if (!SWIG_IsOK(ecode2)) {
21577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21578 }
21579 arg2 = static_cast< bool >(val2);
21580 if (arg1) (arg1)->m_controlDown = arg2;
21581
21582 resultobj = SWIG_Py_Void();
21583 return resultobj;
21584 fail:
21585 return NULL;
21586 }
21587
21588
21589 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21590 PyObject *resultobj = 0;
21591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21592 bool result;
21593 void *argp1 = 0 ;
21594 int res1 = 0 ;
21595 PyObject *swig_obj[1] ;
21596
21597 if (!args) SWIG_fail;
21598 swig_obj[0] = args;
21599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21600 if (!SWIG_IsOK(res1)) {
21601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21602 }
21603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21604 result = (bool) ((arg1)->m_controlDown);
21605 {
21606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21607 }
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21615 PyObject *resultobj = 0;
21616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21617 bool arg2 ;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 bool val2 ;
21621 int ecode2 = 0 ;
21622 PyObject *swig_obj[2] ;
21623
21624 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21626 if (!SWIG_IsOK(res1)) {
21627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21628 }
21629 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21630 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21631 if (!SWIG_IsOK(ecode2)) {
21632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21633 }
21634 arg2 = static_cast< bool >(val2);
21635 if (arg1) (arg1)->m_shiftDown = arg2;
21636
21637 resultobj = SWIG_Py_Void();
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *resultobj = 0;
21646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21647 bool result;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 PyObject *swig_obj[1] ;
21651
21652 if (!args) SWIG_fail;
21653 swig_obj[0] = args;
21654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21655 if (!SWIG_IsOK(res1)) {
21656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21657 }
21658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21659 result = (bool) ((arg1)->m_shiftDown);
21660 {
21661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21662 }
21663 return resultobj;
21664 fail:
21665 return NULL;
21666 }
21667
21668
21669 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21670 PyObject *resultobj = 0;
21671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21672 bool arg2 ;
21673 void *argp1 = 0 ;
21674 int res1 = 0 ;
21675 bool val2 ;
21676 int ecode2 = 0 ;
21677 PyObject *swig_obj[2] ;
21678
21679 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21683 }
21684 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21685 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21686 if (!SWIG_IsOK(ecode2)) {
21687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21688 }
21689 arg2 = static_cast< bool >(val2);
21690 if (arg1) (arg1)->m_altDown = arg2;
21691
21692 resultobj = SWIG_Py_Void();
21693 return resultobj;
21694 fail:
21695 return NULL;
21696 }
21697
21698
21699 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21700 PyObject *resultobj = 0;
21701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21702 bool result;
21703 void *argp1 = 0 ;
21704 int res1 = 0 ;
21705 PyObject *swig_obj[1] ;
21706
21707 if (!args) SWIG_fail;
21708 swig_obj[0] = args;
21709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21710 if (!SWIG_IsOK(res1)) {
21711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21712 }
21713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21714 result = (bool) ((arg1)->m_altDown);
21715 {
21716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21717 }
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21725 PyObject *resultobj = 0;
21726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21727 bool arg2 ;
21728 void *argp1 = 0 ;
21729 int res1 = 0 ;
21730 bool val2 ;
21731 int ecode2 = 0 ;
21732 PyObject *swig_obj[2] ;
21733
21734 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21736 if (!SWIG_IsOK(res1)) {
21737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21738 }
21739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21740 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21741 if (!SWIG_IsOK(ecode2)) {
21742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21743 }
21744 arg2 = static_cast< bool >(val2);
21745 if (arg1) (arg1)->m_metaDown = arg2;
21746
21747 resultobj = SWIG_Py_Void();
21748 return resultobj;
21749 fail:
21750 return NULL;
21751 }
21752
21753
21754 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21755 PyObject *resultobj = 0;
21756 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21757 bool result;
21758 void *argp1 = 0 ;
21759 int res1 = 0 ;
21760 PyObject *swig_obj[1] ;
21761
21762 if (!args) SWIG_fail;
21763 swig_obj[0] = args;
21764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21765 if (!SWIG_IsOK(res1)) {
21766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21767 }
21768 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21769 result = (bool) ((arg1)->m_metaDown);
21770 {
21771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21772 }
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21782 int arg2 ;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 int val2 ;
21786 int ecode2 = 0 ;
21787 PyObject *swig_obj[2] ;
21788
21789 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21791 if (!SWIG_IsOK(res1)) {
21792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21793 }
21794 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21795 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21796 if (!SWIG_IsOK(ecode2)) {
21797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21798 }
21799 arg2 = static_cast< int >(val2);
21800 if (arg1) (arg1)->m_wheelRotation = arg2;
21801
21802 resultobj = SWIG_Py_Void();
21803 return resultobj;
21804 fail:
21805 return NULL;
21806 }
21807
21808
21809 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21810 PyObject *resultobj = 0;
21811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21812 int result;
21813 void *argp1 = 0 ;
21814 int res1 = 0 ;
21815 PyObject *swig_obj[1] ;
21816
21817 if (!args) SWIG_fail;
21818 swig_obj[0] = args;
21819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21820 if (!SWIG_IsOK(res1)) {
21821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21822 }
21823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21824 result = (int) ((arg1)->m_wheelRotation);
21825 resultobj = SWIG_From_int(static_cast< int >(result));
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21833 PyObject *resultobj = 0;
21834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21835 int arg2 ;
21836 void *argp1 = 0 ;
21837 int res1 = 0 ;
21838 int val2 ;
21839 int ecode2 = 0 ;
21840 PyObject *swig_obj[2] ;
21841
21842 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21844 if (!SWIG_IsOK(res1)) {
21845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21846 }
21847 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21848 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21849 if (!SWIG_IsOK(ecode2)) {
21850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21851 }
21852 arg2 = static_cast< int >(val2);
21853 if (arg1) (arg1)->m_wheelDelta = arg2;
21854
21855 resultobj = SWIG_Py_Void();
21856 return resultobj;
21857 fail:
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21863 PyObject *resultobj = 0;
21864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21865 int result;
21866 void *argp1 = 0 ;
21867 int res1 = 0 ;
21868 PyObject *swig_obj[1] ;
21869
21870 if (!args) SWIG_fail;
21871 swig_obj[0] = args;
21872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21873 if (!SWIG_IsOK(res1)) {
21874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21875 }
21876 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21877 result = (int) ((arg1)->m_wheelDelta);
21878 resultobj = SWIG_From_int(static_cast< int >(result));
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21886 PyObject *resultobj = 0;
21887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21888 int arg2 ;
21889 void *argp1 = 0 ;
21890 int res1 = 0 ;
21891 int val2 ;
21892 int ecode2 = 0 ;
21893 PyObject *swig_obj[2] ;
21894
21895 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21899 }
21900 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21901 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21902 if (!SWIG_IsOK(ecode2)) {
21903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21904 }
21905 arg2 = static_cast< int >(val2);
21906 if (arg1) (arg1)->m_linesPerAction = arg2;
21907
21908 resultobj = SWIG_Py_Void();
21909 return resultobj;
21910 fail:
21911 return NULL;
21912 }
21913
21914
21915 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21916 PyObject *resultobj = 0;
21917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21918 int result;
21919 void *argp1 = 0 ;
21920 int res1 = 0 ;
21921 PyObject *swig_obj[1] ;
21922
21923 if (!args) SWIG_fail;
21924 swig_obj[0] = args;
21925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21926 if (!SWIG_IsOK(res1)) {
21927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21928 }
21929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21930 result = (int) ((arg1)->m_linesPerAction);
21931 resultobj = SWIG_From_int(static_cast< int >(result));
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21939 PyObject *obj;
21940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21941 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21942 return SWIG_Py_Void();
21943 }
21944
21945 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21946 return SWIG_Python_InitShadowInstance(args);
21947 }
21948
21949 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj = 0;
21951 int arg1 = (int) 0 ;
21952 int arg2 = (int) 0 ;
21953 wxSetCursorEvent *result = 0 ;
21954 int val1 ;
21955 int ecode1 = 0 ;
21956 int val2 ;
21957 int ecode2 = 0 ;
21958 PyObject * obj0 = 0 ;
21959 PyObject * obj1 = 0 ;
21960 char * kwnames[] = {
21961 (char *) "x",(char *) "y", NULL
21962 };
21963
21964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21965 if (obj0) {
21966 ecode1 = SWIG_AsVal_int(obj0, &val1);
21967 if (!SWIG_IsOK(ecode1)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21969 }
21970 arg1 = static_cast< int >(val1);
21971 }
21972 if (obj1) {
21973 ecode2 = SWIG_AsVal_int(obj1, &val2);
21974 if (!SWIG_IsOK(ecode2)) {
21975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21976 }
21977 arg2 = static_cast< int >(val2);
21978 }
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21986 return resultobj;
21987 fail:
21988 return NULL;
21989 }
21990
21991
21992 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21993 PyObject *resultobj = 0;
21994 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21995 int result;
21996 void *argp1 = 0 ;
21997 int res1 = 0 ;
21998 PyObject *swig_obj[1] ;
21999
22000 if (!args) SWIG_fail;
22001 swig_obj[0] = args;
22002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22003 if (!SWIG_IsOK(res1)) {
22004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22005 }
22006 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22010 wxPyEndAllowThreads(__tstate);
22011 if (PyErr_Occurred()) SWIG_fail;
22012 }
22013 resultobj = SWIG_From_int(static_cast< int >(result));
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22021 PyObject *resultobj = 0;
22022 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22023 int result;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 PyObject *swig_obj[1] ;
22027
22028 if (!args) SWIG_fail;
22029 swig_obj[0] = args;
22030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22031 if (!SWIG_IsOK(res1)) {
22032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22033 }
22034 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 resultobj = SWIG_From_int(static_cast< int >(result));
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj = 0;
22050 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22051 wxCursor *arg2 = 0 ;
22052 void *argp1 = 0 ;
22053 int res1 = 0 ;
22054 void *argp2 = 0 ;
22055 int res2 = 0 ;
22056 PyObject * obj0 = 0 ;
22057 PyObject * obj1 = 0 ;
22058 char * kwnames[] = {
22059 (char *) "self",(char *) "cursor", NULL
22060 };
22061
22062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22064 if (!SWIG_IsOK(res1)) {
22065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22066 }
22067 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22069 if (!SWIG_IsOK(res2)) {
22070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22071 }
22072 if (!argp2) {
22073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22074 }
22075 arg2 = reinterpret_cast< wxCursor * >(argp2);
22076 {
22077 PyThreadState* __tstate = wxPyBeginAllowThreads();
22078 (arg1)->SetCursor((wxCursor const &)*arg2);
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 resultobj = SWIG_Py_Void();
22083 return resultobj;
22084 fail:
22085 return NULL;
22086 }
22087
22088
22089 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22090 PyObject *resultobj = 0;
22091 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22092 wxCursor *result = 0 ;
22093 void *argp1 = 0 ;
22094 int res1 = 0 ;
22095 PyObject *swig_obj[1] ;
22096
22097 if (!args) SWIG_fail;
22098 swig_obj[0] = args;
22099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22100 if (!SWIG_IsOK(res1)) {
22101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22102 }
22103 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 {
22107 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22108 result = (wxCursor *) &_result_ref;
22109 }
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 {
22114 wxCursor* resultptr = new wxCursor(*result);
22115 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22116 }
22117 return resultobj;
22118 fail:
22119 return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22126 bool result;
22127 void *argp1 = 0 ;
22128 int res1 = 0 ;
22129 PyObject *swig_obj[1] ;
22130
22131 if (!args) SWIG_fail;
22132 swig_obj[0] = args;
22133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22136 }
22137 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 {
22145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22146 }
22147 return resultobj;
22148 fail:
22149 return NULL;
22150 }
22151
22152
22153 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22154 PyObject *obj;
22155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22156 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22157 return SWIG_Py_Void();
22158 }
22159
22160 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 return SWIG_Python_InitShadowInstance(args);
22162 }
22163
22164 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj = 0;
22166 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22167 wxKeyEvent *result = 0 ;
22168 int val1 ;
22169 int ecode1 = 0 ;
22170 PyObject * obj0 = 0 ;
22171 char * kwnames[] = {
22172 (char *) "eventType", NULL
22173 };
22174
22175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22176 if (obj0) {
22177 ecode1 = SWIG_AsVal_int(obj0, &val1);
22178 if (!SWIG_IsOK(ecode1)) {
22179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22180 }
22181 arg1 = static_cast< wxEventType >(val1);
22182 }
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22197 PyObject *resultobj = 0;
22198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22199 int result;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 PyObject *swig_obj[1] ;
22203
22204 if (!args) SWIG_fail;
22205 swig_obj[0] = args;
22206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22207 if (!SWIG_IsOK(res1)) {
22208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22209 }
22210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 resultobj = SWIG_From_int(static_cast< int >(result));
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22225 PyObject *resultobj = 0;
22226 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22227 bool result;
22228 void *argp1 = 0 ;
22229 int res1 = 0 ;
22230 PyObject *swig_obj[1] ;
22231
22232 if (!args) SWIG_fail;
22233 swig_obj[0] = args;
22234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22237 }
22238 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 {
22246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22247 }
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 PyObject *resultobj = 0;
22256 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22257 bool result;
22258 void *argp1 = 0 ;
22259 int res1 = 0 ;
22260 PyObject *swig_obj[1] ;
22261
22262 if (!args) SWIG_fail;
22263 swig_obj[0] = args;
22264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22265 if (!SWIG_IsOK(res1)) {
22266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22267 }
22268 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 {
22276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22277 }
22278 return resultobj;
22279 fail:
22280 return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 PyObject *resultobj = 0;
22286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22287 bool result;
22288 void *argp1 = 0 ;
22289 int res1 = 0 ;
22290 PyObject *swig_obj[1] ;
22291
22292 if (!args) SWIG_fail;
22293 swig_obj[0] = args;
22294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22295 if (!SWIG_IsOK(res1)) {
22296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22297 }
22298 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 {
22306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22307 }
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22315 PyObject *resultobj = 0;
22316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22317 bool result;
22318 void *argp1 = 0 ;
22319 int res1 = 0 ;
22320 PyObject *swig_obj[1] ;
22321
22322 if (!args) SWIG_fail;
22323 swig_obj[0] = args;
22324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22325 if (!SWIG_IsOK(res1)) {
22326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22327 }
22328 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22329 {
22330 PyThreadState* __tstate = wxPyBeginAllowThreads();
22331 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 {
22336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22337 }
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22345 PyObject *resultobj = 0;
22346 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22347 bool result;
22348 void *argp1 = 0 ;
22349 int res1 = 0 ;
22350 PyObject *swig_obj[1] ;
22351
22352 if (!args) SWIG_fail;
22353 swig_obj[0] = args;
22354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22355 if (!SWIG_IsOK(res1)) {
22356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22357 }
22358 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 {
22366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22367 }
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22375 PyObject *resultobj = 0;
22376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22377 bool result;
22378 void *argp1 = 0 ;
22379 int res1 = 0 ;
22380 PyObject *swig_obj[1] ;
22381
22382 if (!args) SWIG_fail;
22383 swig_obj[0] = args;
22384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22387 }
22388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 {
22396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22397 }
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *resultobj = 0;
22406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22407 int result;
22408 void *argp1 = 0 ;
22409 int res1 = 0 ;
22410 PyObject *swig_obj[1] ;
22411
22412 if (!args) SWIG_fail;
22413 swig_obj[0] = args;
22414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22415 if (!SWIG_IsOK(res1)) {
22416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22417 }
22418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22422 wxPyEndAllowThreads(__tstate);
22423 if (PyErr_Occurred()) SWIG_fail;
22424 }
22425 resultobj = SWIG_From_int(static_cast< int >(result));
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 int result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_From_int(static_cast< int >(result));
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 int arg2 ;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 int val2 ;
22467 int ecode2 = 0 ;
22468 PyObject * obj0 = 0 ;
22469 PyObject * obj1 = 0 ;
22470 char * kwnames[] = {
22471 (char *) "self",(char *) "uniChar", NULL
22472 };
22473
22474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22476 if (!SWIG_IsOK(res1)) {
22477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22478 }
22479 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22480 ecode2 = SWIG_AsVal_int(obj1, &val2);
22481 if (!SWIG_IsOK(ecode2)) {
22482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22483 }
22484 arg2 = static_cast< int >(val2);
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 resultobj = SWIG_Py_Void();
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22501 unsigned int result;
22502 void *argp1 = 0 ;
22503 int res1 = 0 ;
22504 PyObject *swig_obj[1] ;
22505
22506 if (!args) SWIG_fail;
22507 swig_obj[0] = args;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22516 wxPyEndAllowThreads(__tstate);
22517 if (PyErr_Occurred()) SWIG_fail;
22518 }
22519 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 unsigned int result;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 PyObject *swig_obj[1] ;
22533
22534 if (!args) SWIG_fail;
22535 swig_obj[0] = args;
22536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22539 }
22540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22541 {
22542 PyThreadState* __tstate = wxPyBeginAllowThreads();
22543 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22544 wxPyEndAllowThreads(__tstate);
22545 if (PyErr_Occurred()) SWIG_fail;
22546 }
22547 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22548 return resultobj;
22549 fail:
22550 return NULL;
22551 }
22552
22553
22554 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22555 PyObject *resultobj = 0;
22556 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22557 wxPoint result;
22558 void *argp1 = 0 ;
22559 int res1 = 0 ;
22560 PyObject *swig_obj[1] ;
22561
22562 if (!args) SWIG_fail;
22563 swig_obj[0] = args;
22564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22565 if (!SWIG_IsOK(res1)) {
22566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22567 }
22568 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22569 {
22570 PyThreadState* __tstate = wxPyBeginAllowThreads();
22571 result = (arg1)->GetPosition();
22572 wxPyEndAllowThreads(__tstate);
22573 if (PyErr_Occurred()) SWIG_fail;
22574 }
22575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 long *arg2 = (long *) 0 ;
22586 long *arg3 = (long *) 0 ;
22587 void *argp1 = 0 ;
22588 int res1 = 0 ;
22589 long temp2 ;
22590 int res2 = SWIG_TMPOBJ ;
22591 long temp3 ;
22592 int res3 = SWIG_TMPOBJ ;
22593 PyObject *swig_obj[1] ;
22594
22595 arg2 = &temp2;
22596 arg3 = &temp3;
22597 if (!args) SWIG_fail;
22598 swig_obj[0] = args;
22599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22600 if (!SWIG_IsOK(res1)) {
22601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22602 }
22603 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22604 {
22605 PyThreadState* __tstate = wxPyBeginAllowThreads();
22606 (arg1)->GetPosition(arg2,arg3);
22607 wxPyEndAllowThreads(__tstate);
22608 if (PyErr_Occurred()) SWIG_fail;
22609 }
22610 resultobj = SWIG_Py_Void();
22611 if (SWIG_IsTmpObj(res2)) {
22612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22613 } else {
22614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22616 }
22617 if (SWIG_IsTmpObj(res3)) {
22618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22619 } else {
22620 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22622 }
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22630 PyObject *resultobj = 0;
22631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22632 int result;
22633 void *argp1 = 0 ;
22634 int res1 = 0 ;
22635 PyObject *swig_obj[1] ;
22636
22637 if (!args) SWIG_fail;
22638 swig_obj[0] = args;
22639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22640 if (!SWIG_IsOK(res1)) {
22641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22642 }
22643 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 result = (int)((wxKeyEvent const *)arg1)->GetX();
22647 wxPyEndAllowThreads(__tstate);
22648 if (PyErr_Occurred()) SWIG_fail;
22649 }
22650 resultobj = SWIG_From_int(static_cast< int >(result));
22651 return resultobj;
22652 fail:
22653 return NULL;
22654 }
22655
22656
22657 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22658 PyObject *resultobj = 0;
22659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22660 int result;
22661 void *argp1 = 0 ;
22662 int res1 = 0 ;
22663 PyObject *swig_obj[1] ;
22664
22665 if (!args) SWIG_fail;
22666 swig_obj[0] = args;
22667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22668 if (!SWIG_IsOK(res1)) {
22669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22670 }
22671 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22672 {
22673 PyThreadState* __tstate = wxPyBeginAllowThreads();
22674 result = (int)((wxKeyEvent const *)arg1)->GetY();
22675 wxPyEndAllowThreads(__tstate);
22676 if (PyErr_Occurred()) SWIG_fail;
22677 }
22678 resultobj = SWIG_From_int(static_cast< int >(result));
22679 return resultobj;
22680 fail:
22681 return NULL;
22682 }
22683
22684
22685 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22686 PyObject *resultobj = 0;
22687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22688 int arg2 ;
22689 void *argp1 = 0 ;
22690 int res1 = 0 ;
22691 int val2 ;
22692 int ecode2 = 0 ;
22693 PyObject *swig_obj[2] ;
22694
22695 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22697 if (!SWIG_IsOK(res1)) {
22698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22699 }
22700 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22701 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22702 if (!SWIG_IsOK(ecode2)) {
22703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22704 }
22705 arg2 = static_cast< int >(val2);
22706 if (arg1) (arg1)->m_x = arg2;
22707
22708 resultobj = SWIG_Py_Void();
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22716 PyObject *resultobj = 0;
22717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22718 int result;
22719 void *argp1 = 0 ;
22720 int res1 = 0 ;
22721 PyObject *swig_obj[1] ;
22722
22723 if (!args) SWIG_fail;
22724 swig_obj[0] = args;
22725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22726 if (!SWIG_IsOK(res1)) {
22727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22728 }
22729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22730 result = (int) ((arg1)->m_x);
22731 resultobj = SWIG_From_int(static_cast< int >(result));
22732 return resultobj;
22733 fail:
22734 return NULL;
22735 }
22736
22737
22738 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22739 PyObject *resultobj = 0;
22740 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22741 int arg2 ;
22742 void *argp1 = 0 ;
22743 int res1 = 0 ;
22744 int val2 ;
22745 int ecode2 = 0 ;
22746 PyObject *swig_obj[2] ;
22747
22748 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22750 if (!SWIG_IsOK(res1)) {
22751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22752 }
22753 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22754 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22755 if (!SWIG_IsOK(ecode2)) {
22756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22757 }
22758 arg2 = static_cast< int >(val2);
22759 if (arg1) (arg1)->m_y = arg2;
22760
22761 resultobj = SWIG_Py_Void();
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22771 int result;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 PyObject *swig_obj[1] ;
22775
22776 if (!args) SWIG_fail;
22777 swig_obj[0] = args;
22778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22779 if (!SWIG_IsOK(res1)) {
22780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22781 }
22782 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22783 result = (int) ((arg1)->m_y);
22784 resultobj = SWIG_From_int(static_cast< int >(result));
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22792 PyObject *resultobj = 0;
22793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22794 long arg2 ;
22795 void *argp1 = 0 ;
22796 int res1 = 0 ;
22797 long val2 ;
22798 int ecode2 = 0 ;
22799 PyObject *swig_obj[2] ;
22800
22801 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22803 if (!SWIG_IsOK(res1)) {
22804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22805 }
22806 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22807 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22808 if (!SWIG_IsOK(ecode2)) {
22809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22810 }
22811 arg2 = static_cast< long >(val2);
22812 if (arg1) (arg1)->m_keyCode = arg2;
22813
22814 resultobj = SWIG_Py_Void();
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *resultobj = 0;
22823 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22824 long result;
22825 void *argp1 = 0 ;
22826 int res1 = 0 ;
22827 PyObject *swig_obj[1] ;
22828
22829 if (!args) SWIG_fail;
22830 swig_obj[0] = args;
22831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22832 if (!SWIG_IsOK(res1)) {
22833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22834 }
22835 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22836 result = (long) ((arg1)->m_keyCode);
22837 resultobj = SWIG_From_long(static_cast< long >(result));
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22845 PyObject *resultobj = 0;
22846 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22847 bool arg2 ;
22848 void *argp1 = 0 ;
22849 int res1 = 0 ;
22850 bool val2 ;
22851 int ecode2 = 0 ;
22852 PyObject *swig_obj[2] ;
22853
22854 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22858 }
22859 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22860 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22861 if (!SWIG_IsOK(ecode2)) {
22862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22863 }
22864 arg2 = static_cast< bool >(val2);
22865 if (arg1) (arg1)->m_controlDown = arg2;
22866
22867 resultobj = SWIG_Py_Void();
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22875 PyObject *resultobj = 0;
22876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22877 bool result;
22878 void *argp1 = 0 ;
22879 int res1 = 0 ;
22880 PyObject *swig_obj[1] ;
22881
22882 if (!args) SWIG_fail;
22883 swig_obj[0] = args;
22884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22887 }
22888 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22889 result = (bool) ((arg1)->m_controlDown);
22890 {
22891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22892 }
22893 return resultobj;
22894 fail:
22895 return NULL;
22896 }
22897
22898
22899 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22900 PyObject *resultobj = 0;
22901 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22902 bool arg2 ;
22903 void *argp1 = 0 ;
22904 int res1 = 0 ;
22905 bool val2 ;
22906 int ecode2 = 0 ;
22907 PyObject *swig_obj[2] ;
22908
22909 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22911 if (!SWIG_IsOK(res1)) {
22912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22913 }
22914 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22915 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22916 if (!SWIG_IsOK(ecode2)) {
22917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22918 }
22919 arg2 = static_cast< bool >(val2);
22920 if (arg1) (arg1)->m_shiftDown = arg2;
22921
22922 resultobj = SWIG_Py_Void();
22923 return resultobj;
22924 fail:
22925 return NULL;
22926 }
22927
22928
22929 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22930 PyObject *resultobj = 0;
22931 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22932 bool result;
22933 void *argp1 = 0 ;
22934 int res1 = 0 ;
22935 PyObject *swig_obj[1] ;
22936
22937 if (!args) SWIG_fail;
22938 swig_obj[0] = args;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22942 }
22943 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22944 result = (bool) ((arg1)->m_shiftDown);
22945 {
22946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22947 }
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22955 PyObject *resultobj = 0;
22956 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22957 bool arg2 ;
22958 void *argp1 = 0 ;
22959 int res1 = 0 ;
22960 bool val2 ;
22961 int ecode2 = 0 ;
22962 PyObject *swig_obj[2] ;
22963
22964 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22966 if (!SWIG_IsOK(res1)) {
22967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22968 }
22969 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22970 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22971 if (!SWIG_IsOK(ecode2)) {
22972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22973 }
22974 arg2 = static_cast< bool >(val2);
22975 if (arg1) (arg1)->m_altDown = arg2;
22976
22977 resultobj = SWIG_Py_Void();
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22985 PyObject *resultobj = 0;
22986 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22987 bool result;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 PyObject *swig_obj[1] ;
22991
22992 if (!args) SWIG_fail;
22993 swig_obj[0] = args;
22994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22997 }
22998 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22999 result = (bool) ((arg1)->m_altDown);
23000 {
23001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23010 PyObject *resultobj = 0;
23011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23012 bool arg2 ;
23013 void *argp1 = 0 ;
23014 int res1 = 0 ;
23015 bool val2 ;
23016 int ecode2 = 0 ;
23017 PyObject *swig_obj[2] ;
23018
23019 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23021 if (!SWIG_IsOK(res1)) {
23022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23023 }
23024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23025 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23026 if (!SWIG_IsOK(ecode2)) {
23027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23028 }
23029 arg2 = static_cast< bool >(val2);
23030 if (arg1) (arg1)->m_metaDown = arg2;
23031
23032 resultobj = SWIG_Py_Void();
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23040 PyObject *resultobj = 0;
23041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23042 bool result;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 PyObject *swig_obj[1] ;
23046
23047 if (!args) SWIG_fail;
23048 swig_obj[0] = args;
23049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23050 if (!SWIG_IsOK(res1)) {
23051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23052 }
23053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23054 result = (bool) ((arg1)->m_metaDown);
23055 {
23056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23057 }
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23067 bool arg2 ;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 bool val2 ;
23071 int ecode2 = 0 ;
23072 PyObject *swig_obj[2] ;
23073
23074 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23078 }
23079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23080 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23081 if (!SWIG_IsOK(ecode2)) {
23082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23083 }
23084 arg2 = static_cast< bool >(val2);
23085 if (arg1) (arg1)->m_scanCode = arg2;
23086
23087 resultobj = SWIG_Py_Void();
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 PyObject *resultobj = 0;
23096 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23097 bool result;
23098 void *argp1 = 0 ;
23099 int res1 = 0 ;
23100 PyObject *swig_obj[1] ;
23101
23102 if (!args) SWIG_fail;
23103 swig_obj[0] = args;
23104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23107 }
23108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23109 result = (bool) ((arg1)->m_scanCode);
23110 {
23111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23112 }
23113 return resultobj;
23114 fail:
23115 return NULL;
23116 }
23117
23118
23119 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23120 PyObject *resultobj = 0;
23121 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23122 unsigned int arg2 ;
23123 void *argp1 = 0 ;
23124 int res1 = 0 ;
23125 unsigned int val2 ;
23126 int ecode2 = 0 ;
23127 PyObject *swig_obj[2] ;
23128
23129 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23131 if (!SWIG_IsOK(res1)) {
23132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23133 }
23134 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23135 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23136 if (!SWIG_IsOK(ecode2)) {
23137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23138 }
23139 arg2 = static_cast< unsigned int >(val2);
23140 if (arg1) (arg1)->m_rawCode = arg2;
23141
23142 resultobj = SWIG_Py_Void();
23143 return resultobj;
23144 fail:
23145 return NULL;
23146 }
23147
23148
23149 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23150 PyObject *resultobj = 0;
23151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23152 unsigned int result;
23153 void *argp1 = 0 ;
23154 int res1 = 0 ;
23155 PyObject *swig_obj[1] ;
23156
23157 if (!args) SWIG_fail;
23158 swig_obj[0] = args;
23159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23160 if (!SWIG_IsOK(res1)) {
23161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23162 }
23163 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23164 result = (unsigned int) ((arg1)->m_rawCode);
23165 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23173 PyObject *resultobj = 0;
23174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23175 unsigned int arg2 ;
23176 void *argp1 = 0 ;
23177 int res1 = 0 ;
23178 unsigned int val2 ;
23179 int ecode2 = 0 ;
23180 PyObject *swig_obj[2] ;
23181
23182 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23184 if (!SWIG_IsOK(res1)) {
23185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23186 }
23187 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23188 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23189 if (!SWIG_IsOK(ecode2)) {
23190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23191 }
23192 arg2 = static_cast< unsigned int >(val2);
23193 if (arg1) (arg1)->m_rawFlags = arg2;
23194
23195 resultobj = SWIG_Py_Void();
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23203 PyObject *resultobj = 0;
23204 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23205 unsigned int result;
23206 void *argp1 = 0 ;
23207 int res1 = 0 ;
23208 PyObject *swig_obj[1] ;
23209
23210 if (!args) SWIG_fail;
23211 swig_obj[0] = args;
23212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23213 if (!SWIG_IsOK(res1)) {
23214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23215 }
23216 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23217 result = (unsigned int) ((arg1)->m_rawFlags);
23218 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23226 PyObject *obj;
23227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23228 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23229 return SWIG_Py_Void();
23230 }
23231
23232 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23233 return SWIG_Python_InitShadowInstance(args);
23234 }
23235
23236 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23237 PyObject *resultobj = 0;
23238 wxSize const &arg1_defvalue = wxDefaultSize ;
23239 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23240 int arg2 = (int) 0 ;
23241 wxSizeEvent *result = 0 ;
23242 wxSize temp1 ;
23243 int val2 ;
23244 int ecode2 = 0 ;
23245 PyObject * obj0 = 0 ;
23246 PyObject * obj1 = 0 ;
23247 char * kwnames[] = {
23248 (char *) "sz",(char *) "winid", NULL
23249 };
23250
23251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23252 if (obj0) {
23253 {
23254 arg1 = &temp1;
23255 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23256 }
23257 }
23258 if (obj1) {
23259 ecode2 = SWIG_AsVal_int(obj1, &val2);
23260 if (!SWIG_IsOK(ecode2)) {
23261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23262 }
23263 arg2 = static_cast< int >(val2);
23264 }
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23268 wxPyEndAllowThreads(__tstate);
23269 if (PyErr_Occurred()) SWIG_fail;
23270 }
23271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23279 PyObject *resultobj = 0;
23280 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23281 wxSize result;
23282 void *argp1 = 0 ;
23283 int res1 = 0 ;
23284 PyObject *swig_obj[1] ;
23285
23286 if (!args) SWIG_fail;
23287 swig_obj[0] = args;
23288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23289 if (!SWIG_IsOK(res1)) {
23290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23291 }
23292 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23293 {
23294 PyThreadState* __tstate = wxPyBeginAllowThreads();
23295 result = ((wxSizeEvent const *)arg1)->GetSize();
23296 wxPyEndAllowThreads(__tstate);
23297 if (PyErr_Occurred()) SWIG_fail;
23298 }
23299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23300 return resultobj;
23301 fail:
23302 return NULL;
23303 }
23304
23305
23306 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 PyObject *resultobj = 0;
23308 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23309 wxRect result;
23310 void *argp1 = 0 ;
23311 int res1 = 0 ;
23312 PyObject *swig_obj[1] ;
23313
23314 if (!args) SWIG_fail;
23315 swig_obj[0] = args;
23316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23317 if (!SWIG_IsOK(res1)) {
23318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23319 }
23320 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = ((wxSizeEvent const *)arg1)->GetRect();
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23335 PyObject *resultobj = 0;
23336 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23337 wxRect arg2 ;
23338 void *argp1 = 0 ;
23339 int res1 = 0 ;
23340 void *argp2 ;
23341 int res2 = 0 ;
23342 PyObject * obj0 = 0 ;
23343 PyObject * obj1 = 0 ;
23344 char * kwnames[] = {
23345 (char *) "self",(char *) "rect", NULL
23346 };
23347
23348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23350 if (!SWIG_IsOK(res1)) {
23351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23352 }
23353 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23354 {
23355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23356 if (!SWIG_IsOK(res2)) {
23357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23358 }
23359 if (!argp2) {
23360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23361 } else {
23362 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23363 arg2 = *temp;
23364 if (SWIG_IsNewObj(res2)) delete temp;
23365 }
23366 }
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 (arg1)->SetRect(arg2);
23370 wxPyEndAllowThreads(__tstate);
23371 if (PyErr_Occurred()) SWIG_fail;
23372 }
23373 resultobj = SWIG_Py_Void();
23374 return resultobj;
23375 fail:
23376 return NULL;
23377 }
23378
23379
23380 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23381 PyObject *resultobj = 0;
23382 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23383 wxSize arg2 ;
23384 void *argp1 = 0 ;
23385 int res1 = 0 ;
23386 void *argp2 ;
23387 int res2 = 0 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char * kwnames[] = {
23391 (char *) "self",(char *) "size", NULL
23392 };
23393
23394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23396 if (!SWIG_IsOK(res1)) {
23397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23398 }
23399 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23400 {
23401 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23402 if (!SWIG_IsOK(res2)) {
23403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23404 }
23405 if (!argp2) {
23406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23407 } else {
23408 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23409 arg2 = *temp;
23410 if (SWIG_IsNewObj(res2)) delete temp;
23411 }
23412 }
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 wxSizeEvent_SetSize(arg1,arg2);
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 resultobj = SWIG_Py_Void();
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *resultobj = 0;
23428 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23429 wxSize *arg2 = (wxSize *) 0 ;
23430 void *argp1 = 0 ;
23431 int res1 = 0 ;
23432 void *argp2 = 0 ;
23433 int res2 = 0 ;
23434 PyObject *swig_obj[2] ;
23435
23436 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23440 }
23441 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23442 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23443 if (!SWIG_IsOK(res2)) {
23444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23445 }
23446 arg2 = reinterpret_cast< wxSize * >(argp2);
23447 if (arg1) (arg1)->m_size = *arg2;
23448
23449 resultobj = SWIG_Py_Void();
23450 return resultobj;
23451 fail:
23452 return NULL;
23453 }
23454
23455
23456 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 PyObject *resultobj = 0;
23458 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23459 wxSize *result = 0 ;
23460 void *argp1 = 0 ;
23461 int res1 = 0 ;
23462 PyObject *swig_obj[1] ;
23463
23464 if (!args) SWIG_fail;
23465 swig_obj[0] = args;
23466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23467 if (!SWIG_IsOK(res1)) {
23468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23469 }
23470 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23471 result = (wxSize *)& ((arg1)->m_size);
23472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23473 return resultobj;
23474 fail:
23475 return NULL;
23476 }
23477
23478
23479 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23480 PyObject *resultobj = 0;
23481 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23482 wxRect *arg2 = (wxRect *) 0 ;
23483 void *argp1 = 0 ;
23484 int res1 = 0 ;
23485 void *argp2 = 0 ;
23486 int res2 = 0 ;
23487 PyObject *swig_obj[2] ;
23488
23489 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23491 if (!SWIG_IsOK(res1)) {
23492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23493 }
23494 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23495 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23496 if (!SWIG_IsOK(res2)) {
23497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23498 }
23499 arg2 = reinterpret_cast< wxRect * >(argp2);
23500 if (arg1) (arg1)->m_rect = *arg2;
23501
23502 resultobj = SWIG_Py_Void();
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23510 PyObject *resultobj = 0;
23511 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23512 wxRect *result = 0 ;
23513 void *argp1 = 0 ;
23514 int res1 = 0 ;
23515 PyObject *swig_obj[1] ;
23516
23517 if (!args) SWIG_fail;
23518 swig_obj[0] = args;
23519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23520 if (!SWIG_IsOK(res1)) {
23521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23522 }
23523 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23524 result = (wxRect *)& ((arg1)->m_rect);
23525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23526 return resultobj;
23527 fail:
23528 return NULL;
23529 }
23530
23531
23532 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23533 PyObject *obj;
23534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23535 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23536 return SWIG_Py_Void();
23537 }
23538
23539 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 return SWIG_Python_InitShadowInstance(args);
23541 }
23542
23543 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23544 PyObject *resultobj = 0;
23545 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23546 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23547 int arg2 = (int) 0 ;
23548 wxMoveEvent *result = 0 ;
23549 wxPoint temp1 ;
23550 int val2 ;
23551 int ecode2 = 0 ;
23552 PyObject * obj0 = 0 ;
23553 PyObject * obj1 = 0 ;
23554 char * kwnames[] = {
23555 (char *) "pos",(char *) "winid", NULL
23556 };
23557
23558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23559 if (obj0) {
23560 {
23561 arg1 = &temp1;
23562 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23563 }
23564 }
23565 if (obj1) {
23566 ecode2 = SWIG_AsVal_int(obj1, &val2);
23567 if (!SWIG_IsOK(ecode2)) {
23568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23569 }
23570 arg2 = static_cast< int >(val2);
23571 }
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23586 PyObject *resultobj = 0;
23587 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23588 wxPoint result;
23589 void *argp1 = 0 ;
23590 int res1 = 0 ;
23591 PyObject *swig_obj[1] ;
23592
23593 if (!args) SWIG_fail;
23594 swig_obj[0] = args;
23595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23596 if (!SWIG_IsOK(res1)) {
23597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23598 }
23599 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23600 {
23601 PyThreadState* __tstate = wxPyBeginAllowThreads();
23602 result = ((wxMoveEvent const *)arg1)->GetPosition();
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23614 PyObject *resultobj = 0;
23615 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23616 wxRect result;
23617 void *argp1 = 0 ;
23618 int res1 = 0 ;
23619 PyObject *swig_obj[1] ;
23620
23621 if (!args) SWIG_fail;
23622 swig_obj[0] = args;
23623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23624 if (!SWIG_IsOK(res1)) {
23625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23626 }
23627 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = ((wxMoveEvent const *)arg1)->GetRect();
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = 0;
23643 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23644 wxRect *arg2 = 0 ;
23645 void *argp1 = 0 ;
23646 int res1 = 0 ;
23647 wxRect temp2 ;
23648 PyObject * obj0 = 0 ;
23649 PyObject * obj1 = 0 ;
23650 char * kwnames[] = {
23651 (char *) "self",(char *) "rect", NULL
23652 };
23653
23654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23656 if (!SWIG_IsOK(res1)) {
23657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23658 }
23659 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23660 {
23661 arg2 = &temp2;
23662 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 (arg1)->SetRect((wxRect const &)*arg2);
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_Py_Void();
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj = 0;
23679 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23680 wxPoint *arg2 = 0 ;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 wxPoint temp2 ;
23684 PyObject * obj0 = 0 ;
23685 PyObject * obj1 = 0 ;
23686 char * kwnames[] = {
23687 (char *) "self",(char *) "pos", NULL
23688 };
23689
23690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23692 if (!SWIG_IsOK(res1)) {
23693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23694 }
23695 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23696 {
23697 arg2 = &temp2;
23698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23699 }
23700 {
23701 PyThreadState* __tstate = wxPyBeginAllowThreads();
23702 (arg1)->SetPosition((wxPoint const &)*arg2);
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 resultobj = SWIG_Py_Void();
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23714 PyObject *obj;
23715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23716 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23717 return SWIG_Py_Void();
23718 }
23719
23720 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 return SWIG_Python_InitShadowInstance(args);
23722 }
23723
23724 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj = 0;
23726 int arg1 = (int) 0 ;
23727 wxPaintEvent *result = 0 ;
23728 int val1 ;
23729 int ecode1 = 0 ;
23730 PyObject * obj0 = 0 ;
23731 char * kwnames[] = {
23732 (char *) "Id", NULL
23733 };
23734
23735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23736 if (obj0) {
23737 ecode1 = SWIG_AsVal_int(obj0, &val1);
23738 if (!SWIG_IsOK(ecode1)) {
23739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23740 }
23741 arg1 = static_cast< int >(val1);
23742 }
23743 {
23744 PyThreadState* __tstate = wxPyBeginAllowThreads();
23745 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23746 wxPyEndAllowThreads(__tstate);
23747 if (PyErr_Occurred()) SWIG_fail;
23748 }
23749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23750 return resultobj;
23751 fail:
23752 return NULL;
23753 }
23754
23755
23756 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23757 PyObject *obj;
23758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23759 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23760 return SWIG_Py_Void();
23761 }
23762
23763 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23764 return SWIG_Python_InitShadowInstance(args);
23765 }
23766
23767 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj = 0;
23769 int arg1 = (int) 0 ;
23770 wxNcPaintEvent *result = 0 ;
23771 int val1 ;
23772 int ecode1 = 0 ;
23773 PyObject * obj0 = 0 ;
23774 char * kwnames[] = {
23775 (char *) "winid", NULL
23776 };
23777
23778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23779 if (obj0) {
23780 ecode1 = SWIG_AsVal_int(obj0, &val1);
23781 if (!SWIG_IsOK(ecode1)) {
23782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23783 }
23784 arg1 = static_cast< int >(val1);
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 PyObject *obj;
23801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23802 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23803 return SWIG_Py_Void();
23804 }
23805
23806 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23807 return SWIG_Python_InitShadowInstance(args);
23808 }
23809
23810 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23811 PyObject *resultobj = 0;
23812 int arg1 = (int) 0 ;
23813 wxDC *arg2 = (wxDC *) NULL ;
23814 wxEraseEvent *result = 0 ;
23815 int val1 ;
23816 int ecode1 = 0 ;
23817 void *argp2 = 0 ;
23818 int res2 = 0 ;
23819 PyObject * obj0 = 0 ;
23820 PyObject * obj1 = 0 ;
23821 char * kwnames[] = {
23822 (char *) "Id",(char *) "dc", NULL
23823 };
23824
23825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23826 if (obj0) {
23827 ecode1 = SWIG_AsVal_int(obj0, &val1);
23828 if (!SWIG_IsOK(ecode1)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23830 }
23831 arg1 = static_cast< int >(val1);
23832 }
23833 if (obj1) {
23834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23835 if (!SWIG_IsOK(res2)) {
23836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23837 }
23838 arg2 = reinterpret_cast< wxDC * >(argp2);
23839 }
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23854 PyObject *resultobj = 0;
23855 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23856 wxDC *result = 0 ;
23857 void *argp1 = 0 ;
23858 int res1 = 0 ;
23859 PyObject *swig_obj[1] ;
23860
23861 if (!args) SWIG_fail;
23862 swig_obj[0] = args;
23863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23864 if (!SWIG_IsOK(res1)) {
23865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23866 }
23867 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23871 wxPyEndAllowThreads(__tstate);
23872 if (PyErr_Occurred()) SWIG_fail;
23873 }
23874 {
23875 resultobj = wxPyMake_wxObject(result, (bool)0);
23876 }
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *obj;
23885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23886 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23887 return SWIG_Py_Void();
23888 }
23889
23890 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23891 return SWIG_Python_InitShadowInstance(args);
23892 }
23893
23894 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj = 0;
23896 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23897 int arg2 = (int) 0 ;
23898 wxFocusEvent *result = 0 ;
23899 int val1 ;
23900 int ecode1 = 0 ;
23901 int val2 ;
23902 int ecode2 = 0 ;
23903 PyObject * obj0 = 0 ;
23904 PyObject * obj1 = 0 ;
23905 char * kwnames[] = {
23906 (char *) "type",(char *) "winid", NULL
23907 };
23908
23909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23910 if (obj0) {
23911 ecode1 = SWIG_AsVal_int(obj0, &val1);
23912 if (!SWIG_IsOK(ecode1)) {
23913 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23914 }
23915 arg1 = static_cast< wxEventType >(val1);
23916 }
23917 if (obj1) {
23918 ecode2 = SWIG_AsVal_int(obj1, &val2);
23919 if (!SWIG_IsOK(ecode2)) {
23920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23921 }
23922 arg2 = static_cast< int >(val2);
23923 }
23924 {
23925 PyThreadState* __tstate = wxPyBeginAllowThreads();
23926 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23931 return resultobj;
23932 fail:
23933 return NULL;
23934 }
23935
23936
23937 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23938 PyObject *resultobj = 0;
23939 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23940 wxWindow *result = 0 ;
23941 void *argp1 = 0 ;
23942 int res1 = 0 ;
23943 PyObject *swig_obj[1] ;
23944
23945 if (!args) SWIG_fail;
23946 swig_obj[0] = args;
23947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23948 if (!SWIG_IsOK(res1)) {
23949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23950 }
23951 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23952 {
23953 PyThreadState* __tstate = wxPyBeginAllowThreads();
23954 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 {
23959 resultobj = wxPyMake_wxObject(result, (bool)0);
23960 }
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23970 wxWindow *arg2 = (wxWindow *) 0 ;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 void *argp2 = 0 ;
23974 int res2 = 0 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 char * kwnames[] = {
23978 (char *) "self",(char *) "win", NULL
23979 };
23980
23981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23983 if (!SWIG_IsOK(res1)) {
23984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23985 }
23986 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23988 if (!SWIG_IsOK(res2)) {
23989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23990 }
23991 arg2 = reinterpret_cast< wxWindow * >(argp2);
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 (arg1)->SetWindow(arg2);
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 resultobj = SWIG_Py_Void();
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *obj;
24007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24008 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24009 return SWIG_Py_Void();
24010 }
24011
24012 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24013 return SWIG_Python_InitShadowInstance(args);
24014 }
24015
24016 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj = 0;
24018 wxWindow *arg1 = (wxWindow *) NULL ;
24019 wxChildFocusEvent *result = 0 ;
24020 void *argp1 = 0 ;
24021 int res1 = 0 ;
24022 PyObject * obj0 = 0 ;
24023 char * kwnames[] = {
24024 (char *) "win", NULL
24025 };
24026
24027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24028 if (obj0) {
24029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24032 }
24033 arg1 = reinterpret_cast< wxWindow * >(argp1);
24034 }
24035 {
24036 PyThreadState* __tstate = wxPyBeginAllowThreads();
24037 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24049 PyObject *resultobj = 0;
24050 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24051 wxWindow *result = 0 ;
24052 void *argp1 = 0 ;
24053 int res1 = 0 ;
24054 PyObject *swig_obj[1] ;
24055
24056 if (!args) SWIG_fail;
24057 swig_obj[0] = args;
24058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24059 if (!SWIG_IsOK(res1)) {
24060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24061 }
24062 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 {
24070 resultobj = wxPyMake_wxObject(result, (bool)0);
24071 }
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24079 PyObject *obj;
24080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24081 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24082 return SWIG_Py_Void();
24083 }
24084
24085 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 return SWIG_Python_InitShadowInstance(args);
24087 }
24088
24089 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj = 0;
24091 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24092 bool arg2 = (bool) true ;
24093 int arg3 = (int) 0 ;
24094 wxActivateEvent *result = 0 ;
24095 int val1 ;
24096 int ecode1 = 0 ;
24097 bool val2 ;
24098 int ecode2 = 0 ;
24099 int val3 ;
24100 int ecode3 = 0 ;
24101 PyObject * obj0 = 0 ;
24102 PyObject * obj1 = 0 ;
24103 PyObject * obj2 = 0 ;
24104 char * kwnames[] = {
24105 (char *) "type",(char *) "active",(char *) "Id", NULL
24106 };
24107
24108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24109 if (obj0) {
24110 ecode1 = SWIG_AsVal_int(obj0, &val1);
24111 if (!SWIG_IsOK(ecode1)) {
24112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24113 }
24114 arg1 = static_cast< wxEventType >(val1);
24115 }
24116 if (obj1) {
24117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24118 if (!SWIG_IsOK(ecode2)) {
24119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24120 }
24121 arg2 = static_cast< bool >(val2);
24122 }
24123 if (obj2) {
24124 ecode3 = SWIG_AsVal_int(obj2, &val3);
24125 if (!SWIG_IsOK(ecode3)) {
24126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24127 }
24128 arg3 = static_cast< int >(val3);
24129 }
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24146 bool result;
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_wxActivateEvent, 0 | 0 );
24154 if (!SWIG_IsOK(res1)) {
24155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24156 }
24157 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 {
24165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *ActivateEvent_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_wxActivateEvent, SWIG_NewClientData(obj));
24177 return SWIG_Py_Void();
24178 }
24179
24180 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24181 return SWIG_Python_InitShadowInstance(args);
24182 }
24183
24184 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj = 0;
24186 int arg1 = (int) 0 ;
24187 wxInitDialogEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 PyObject * obj0 = 0 ;
24191 char * kwnames[] = {
24192 (char *) "Id", NULL
24193 };
24194
24195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24196 if (obj0) {
24197 ecode1 = SWIG_AsVal_int(obj0, &val1);
24198 if (!SWIG_IsOK(ecode1)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24200 }
24201 arg1 = static_cast< int >(val1);
24202 }
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24217 PyObject *obj;
24218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24219 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24220 return SWIG_Py_Void();
24221 }
24222
24223 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24224 return SWIG_Python_InitShadowInstance(args);
24225 }
24226
24227 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24230 int arg2 = (int) 0 ;
24231 wxMenu *arg3 = (wxMenu *) NULL ;
24232 wxMenuEvent *result = 0 ;
24233 int val1 ;
24234 int ecode1 = 0 ;
24235 int val2 ;
24236 int ecode2 = 0 ;
24237 void *argp3 = 0 ;
24238 int res3 = 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 PyObject * obj2 = 0 ;
24242 char * kwnames[] = {
24243 (char *) "type",(char *) "winid",(char *) "menu", NULL
24244 };
24245
24246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24247 if (obj0) {
24248 ecode1 = SWIG_AsVal_int(obj0, &val1);
24249 if (!SWIG_IsOK(ecode1)) {
24250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24251 }
24252 arg1 = static_cast< wxEventType >(val1);
24253 }
24254 if (obj1) {
24255 ecode2 = SWIG_AsVal_int(obj1, &val2);
24256 if (!SWIG_IsOK(ecode2)) {
24257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24258 }
24259 arg2 = static_cast< int >(val2);
24260 }
24261 if (obj2) {
24262 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24263 if (!SWIG_IsOK(res3)) {
24264 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24265 }
24266 arg3 = reinterpret_cast< wxMenu * >(argp3);
24267 }
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24284 int result;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 resultobj = SWIG_From_int(static_cast< int >(result));
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *resultobj = 0;
24311 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24312 bool result;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 PyObject *swig_obj[1] ;
24316
24317 if (!args) SWIG_fail;
24318 swig_obj[0] = args;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 {
24331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24332 }
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *resultobj = 0;
24341 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24342 wxMenu *result = 0 ;
24343 void *argp1 = 0 ;
24344 int res1 = 0 ;
24345 PyObject *swig_obj[1] ;
24346
24347 if (!args) SWIG_fail;
24348 swig_obj[0] = args;
24349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24350 if (!SWIG_IsOK(res1)) {
24351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24352 }
24353 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 {
24361 resultobj = wxPyMake_wxObject(result, (bool)0);
24362 }
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24370 PyObject *obj;
24371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24372 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24373 return SWIG_Py_Void();
24374 }
24375
24376 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 return SWIG_Python_InitShadowInstance(args);
24378 }
24379
24380 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj = 0;
24382 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24383 int arg2 = (int) 0 ;
24384 wxCloseEvent *result = 0 ;
24385 int val1 ;
24386 int ecode1 = 0 ;
24387 int val2 ;
24388 int ecode2 = 0 ;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char * kwnames[] = {
24392 (char *) "type",(char *) "winid", NULL
24393 };
24394
24395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24396 if (obj0) {
24397 ecode1 = SWIG_AsVal_int(obj0, &val1);
24398 if (!SWIG_IsOK(ecode1)) {
24399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24400 }
24401 arg1 = static_cast< wxEventType >(val1);
24402 }
24403 if (obj1) {
24404 ecode2 = SWIG_AsVal_int(obj1, &val2);
24405 if (!SWIG_IsOK(ecode2)) {
24406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24407 }
24408 arg2 = static_cast< int >(val2);
24409 }
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj = 0;
24425 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24426 bool arg2 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 bool val2 ;
24430 int ecode2 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char * kwnames[] = {
24434 (char *) "self",(char *) "logOff", NULL
24435 };
24436
24437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24439 if (!SWIG_IsOK(res1)) {
24440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24441 }
24442 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24444 if (!SWIG_IsOK(ecode2)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24446 }
24447 arg2 = static_cast< bool >(val2);
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetLoggingOff(arg2);
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_Py_Void();
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 PyObject *resultobj = 0;
24463 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24464 bool result;
24465 void *argp1 = 0 ;
24466 int res1 = 0 ;
24467 PyObject *swig_obj[1] ;
24468
24469 if (!args) SWIG_fail;
24470 swig_obj[0] = args;
24471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24472 if (!SWIG_IsOK(res1)) {
24473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24474 }
24475 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj = 0;
24493 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24494 bool arg2 = (bool) true ;
24495 void *argp1 = 0 ;
24496 int res1 = 0 ;
24497 bool val2 ;
24498 int ecode2 = 0 ;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 char * kwnames[] = {
24502 (char *) "self",(char *) "veto", NULL
24503 };
24504
24505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24507 if (!SWIG_IsOK(res1)) {
24508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24509 }
24510 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24511 if (obj1) {
24512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24513 if (!SWIG_IsOK(ecode2)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24515 }
24516 arg2 = static_cast< bool >(val2);
24517 }
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 (arg1)->Veto(arg2);
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_Py_Void();
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *resultobj = 0;
24533 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24534 bool result;
24535 void *argp1 = 0 ;
24536 int res1 = 0 ;
24537 PyObject *swig_obj[1] ;
24538
24539 if (!args) SWIG_fail;
24540 swig_obj[0] = args;
24541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24542 if (!SWIG_IsOK(res1)) {
24543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24544 }
24545 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 {
24553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24554 }
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24562 PyObject *resultobj = 0;
24563 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24564 bool arg2 ;
24565 void *argp1 = 0 ;
24566 int res1 = 0 ;
24567 bool val2 ;
24568 int ecode2 = 0 ;
24569 PyObject * obj0 = 0 ;
24570 PyObject * obj1 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "self",(char *) "canVeto", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24579 }
24580 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24582 if (!SWIG_IsOK(ecode2)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24584 }
24585 arg2 = static_cast< bool >(val2);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 (arg1)->SetCanVeto(arg2);
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_Py_Void();
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24602 bool result;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 PyObject *swig_obj[1] ;
24606
24607 if (!args) SWIG_fail;
24608 swig_obj[0] = args;
24609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24612 }
24613 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 {
24621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24622 }
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *obj;
24631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24632 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24633 return SWIG_Py_Void();
24634 }
24635
24636 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24637 return SWIG_Python_InitShadowInstance(args);
24638 }
24639
24640 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = 0;
24642 int arg1 = (int) 0 ;
24643 bool arg2 = (bool) false ;
24644 wxShowEvent *result = 0 ;
24645 int val1 ;
24646 int ecode1 = 0 ;
24647 bool val2 ;
24648 int ecode2 = 0 ;
24649 PyObject * obj0 = 0 ;
24650 PyObject * obj1 = 0 ;
24651 char * kwnames[] = {
24652 (char *) "winid",(char *) "show", NULL
24653 };
24654
24655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24656 if (obj0) {
24657 ecode1 = SWIG_AsVal_int(obj0, &val1);
24658 if (!SWIG_IsOK(ecode1)) {
24659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24660 }
24661 arg1 = static_cast< int >(val1);
24662 }
24663 if (obj1) {
24664 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24665 if (!SWIG_IsOK(ecode2)) {
24666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24667 }
24668 arg2 = static_cast< bool >(val2);
24669 }
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj = 0;
24685 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24686 bool arg2 ;
24687 void *argp1 = 0 ;
24688 int res1 = 0 ;
24689 bool val2 ;
24690 int ecode2 = 0 ;
24691 PyObject * obj0 = 0 ;
24692 PyObject * obj1 = 0 ;
24693 char * kwnames[] = {
24694 (char *) "self",(char *) "show", NULL
24695 };
24696
24697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24699 if (!SWIG_IsOK(res1)) {
24700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24701 }
24702 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24704 if (!SWIG_IsOK(ecode2)) {
24705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24706 }
24707 arg2 = static_cast< bool >(val2);
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 (arg1)->SetShow(arg2);
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 resultobj = SWIG_Py_Void();
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24722 PyObject *resultobj = 0;
24723 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24724 bool 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_wxShowEvent, 0 | 0 );
24732 if (!SWIG_IsOK(res1)) {
24733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24734 }
24735 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 PyObject *obj;
24753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24754 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24755 return SWIG_Py_Void();
24756 }
24757
24758 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24759 return SWIG_Python_InitShadowInstance(args);
24760 }
24761
24762 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj = 0;
24764 int arg1 = (int) 0 ;
24765 bool arg2 = (bool) true ;
24766 wxIconizeEvent *result = 0 ;
24767 int val1 ;
24768 int ecode1 = 0 ;
24769 bool val2 ;
24770 int ecode2 = 0 ;
24771 PyObject * obj0 = 0 ;
24772 PyObject * obj1 = 0 ;
24773 char * kwnames[] = {
24774 (char *) "id",(char *) "iconized", NULL
24775 };
24776
24777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24778 if (obj0) {
24779 ecode1 = SWIG_AsVal_int(obj0, &val1);
24780 if (!SWIG_IsOK(ecode1)) {
24781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24782 }
24783 arg1 = static_cast< int >(val1);
24784 }
24785 if (obj1) {
24786 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24787 if (!SWIG_IsOK(ecode2)) {
24788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24789 }
24790 arg2 = static_cast< bool >(val2);
24791 }
24792 {
24793 PyThreadState* __tstate = wxPyBeginAllowThreads();
24794 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24806 PyObject *resultobj = 0;
24807 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24808 bool result;
24809 void *argp1 = 0 ;
24810 int res1 = 0 ;
24811 PyObject *swig_obj[1] ;
24812
24813 if (!args) SWIG_fail;
24814 swig_obj[0] = args;
24815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24816 if (!SWIG_IsOK(res1)) {
24817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24818 }
24819 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 result = (bool)(arg1)->Iconized();
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 {
24827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24828 }
24829 return resultobj;
24830 fail:
24831 return NULL;
24832 }
24833
24834
24835 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24836 PyObject *obj;
24837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24838 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24839 return SWIG_Py_Void();
24840 }
24841
24842 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843 return SWIG_Python_InitShadowInstance(args);
24844 }
24845
24846 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24847 PyObject *resultobj = 0;
24848 int arg1 = (int) 0 ;
24849 wxMaximizeEvent *result = 0 ;
24850 int val1 ;
24851 int ecode1 = 0 ;
24852 PyObject * obj0 = 0 ;
24853 char * kwnames[] = {
24854 (char *) "id", NULL
24855 };
24856
24857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24858 if (obj0) {
24859 ecode1 = SWIG_AsVal_int(obj0, &val1);
24860 if (!SWIG_IsOK(ecode1)) {
24861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24862 }
24863 arg1 = static_cast< int >(val1);
24864 }
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24879 PyObject *obj;
24880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24881 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24882 return SWIG_Py_Void();
24883 }
24884
24885 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24886 return SWIG_Python_InitShadowInstance(args);
24887 }
24888
24889 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24892 wxPoint result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24902 }
24903 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (arg1)->GetPosition();
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *resultobj = 0;
24919 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24920 int result;
24921 void *argp1 = 0 ;
24922 int res1 = 0 ;
24923 PyObject *swig_obj[1] ;
24924
24925 if (!args) SWIG_fail;
24926 swig_obj[0] = args;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (int)(arg1)->GetNumberOfFiles();
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 resultobj = SWIG_From_int(static_cast< int >(result));
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24948 PyObject *result = 0 ;
24949 void *argp1 = 0 ;
24950 int res1 = 0 ;
24951 PyObject *swig_obj[1] ;
24952
24953 if (!args) SWIG_fail;
24954 swig_obj[0] = args;
24955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24958 }
24959 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 resultobj = result;
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24974 PyObject *obj;
24975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24976 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24977 return SWIG_Py_Void();
24978 }
24979
24980 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24981 PyObject *resultobj = 0;
24982 int arg1 = (int) 0 ;
24983 wxUpdateUIEvent *result = 0 ;
24984 int val1 ;
24985 int ecode1 = 0 ;
24986 PyObject * obj0 = 0 ;
24987 char * kwnames[] = {
24988 (char *) "commandId", NULL
24989 };
24990
24991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24992 if (obj0) {
24993 ecode1 = SWIG_AsVal_int(obj0, &val1);
24994 if (!SWIG_IsOK(ecode1)) {
24995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24996 }
24997 arg1 = static_cast< int >(val1);
24998 }
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25013 PyObject *resultobj = 0;
25014 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25015 bool result;
25016 void *argp1 = 0 ;
25017 int res1 = 0 ;
25018 PyObject *swig_obj[1] ;
25019
25020 if (!args) SWIG_fail;
25021 swig_obj[0] = args;
25022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25023 if (!SWIG_IsOK(res1)) {
25024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25025 }
25026 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 {
25034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25035 }
25036 return resultobj;
25037 fail:
25038 return NULL;
25039 }
25040
25041
25042 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25043 PyObject *resultobj = 0;
25044 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25045 bool result;
25046 void *argp1 = 0 ;
25047 int res1 = 0 ;
25048 PyObject *swig_obj[1] ;
25049
25050 if (!args) SWIG_fail;
25051 swig_obj[0] = args;
25052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25053 if (!SWIG_IsOK(res1)) {
25054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25055 }
25056 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25057 {
25058 PyThreadState* __tstate = wxPyBeginAllowThreads();
25059 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25060 wxPyEndAllowThreads(__tstate);
25061 if (PyErr_Occurred()) SWIG_fail;
25062 }
25063 {
25064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25065 }
25066 return resultobj;
25067 fail:
25068 return NULL;
25069 }
25070
25071
25072 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25073 PyObject *resultobj = 0;
25074 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25075 bool result;
25076 void *argp1 = 0 ;
25077 int res1 = 0 ;
25078 PyObject *swig_obj[1] ;
25079
25080 if (!args) SWIG_fail;
25081 swig_obj[0] = args;
25082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25083 if (!SWIG_IsOK(res1)) {
25084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25085 }
25086 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 {
25094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25095 }
25096 return resultobj;
25097 fail:
25098 return NULL;
25099 }
25100
25101
25102 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25103 PyObject *resultobj = 0;
25104 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25105 wxString result;
25106 void *argp1 = 0 ;
25107 int res1 = 0 ;
25108 PyObject *swig_obj[1] ;
25109
25110 if (!args) SWIG_fail;
25111 swig_obj[0] = args;
25112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25115 }
25116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 #if wxUSE_UNICODE
25125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25126 #else
25127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25128 #endif
25129 }
25130 return resultobj;
25131 fail:
25132 return NULL;
25133 }
25134
25135
25136 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25137 PyObject *resultobj = 0;
25138 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25139 bool result;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 PyObject *swig_obj[1] ;
25143
25144 if (!args) SWIG_fail;
25145 swig_obj[0] = args;
25146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25147 if (!SWIG_IsOK(res1)) {
25148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25149 }
25150 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 {
25158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25159 }
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25167 PyObject *resultobj = 0;
25168 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25169 bool result;
25170 void *argp1 = 0 ;
25171 int res1 = 0 ;
25172 PyObject *swig_obj[1] ;
25173
25174 if (!args) SWIG_fail;
25175 swig_obj[0] = args;
25176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25177 if (!SWIG_IsOK(res1)) {
25178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25179 }
25180 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25189 }
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *resultobj = 0;
25198 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25199 bool result;
25200 void *argp1 = 0 ;
25201 int res1 = 0 ;
25202 PyObject *swig_obj[1] ;
25203
25204 if (!args) SWIG_fail;
25205 swig_obj[0] = args;
25206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25207 if (!SWIG_IsOK(res1)) {
25208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25209 }
25210 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25227 PyObject *resultobj = 0;
25228 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25229 bool result;
25230 void *argp1 = 0 ;
25231 int res1 = 0 ;
25232 PyObject *swig_obj[1] ;
25233
25234 if (!args) SWIG_fail;
25235 swig_obj[0] = args;
25236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25237 if (!SWIG_IsOK(res1)) {
25238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25239 }
25240 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 {
25248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25249 }
25250 return resultobj;
25251 fail:
25252 return NULL;
25253 }
25254
25255
25256 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj = 0;
25258 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25259 bool arg2 ;
25260 void *argp1 = 0 ;
25261 int res1 = 0 ;
25262 bool val2 ;
25263 int ecode2 = 0 ;
25264 PyObject * obj0 = 0 ;
25265 PyObject * obj1 = 0 ;
25266 char * kwnames[] = {
25267 (char *) "self",(char *) "check", NULL
25268 };
25269
25270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25272 if (!SWIG_IsOK(res1)) {
25273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25274 }
25275 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25277 if (!SWIG_IsOK(ecode2)) {
25278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25279 }
25280 arg2 = static_cast< bool >(val2);
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 (arg1)->Check(arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_Py_Void();
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj = 0;
25296 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25297 bool arg2 ;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 bool val2 ;
25301 int ecode2 = 0 ;
25302 PyObject * obj0 = 0 ;
25303 PyObject * obj1 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "self",(char *) "enable", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25310 if (!SWIG_IsOK(res1)) {
25311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25312 }
25313 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25315 if (!SWIG_IsOK(ecode2)) {
25316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25317 }
25318 arg2 = static_cast< bool >(val2);
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 (arg1)->Enable(arg2);
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 resultobj = SWIG_Py_Void();
25326 return resultobj;
25327 fail:
25328 return NULL;
25329 }
25330
25331
25332 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj = 0;
25334 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25335 bool arg2 ;
25336 void *argp1 = 0 ;
25337 int res1 = 0 ;
25338 bool val2 ;
25339 int ecode2 = 0 ;
25340 PyObject * obj0 = 0 ;
25341 PyObject * obj1 = 0 ;
25342 char * kwnames[] = {
25343 (char *) "self",(char *) "show", NULL
25344 };
25345
25346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25348 if (!SWIG_IsOK(res1)) {
25349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25350 }
25351 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25353 if (!SWIG_IsOK(ecode2)) {
25354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25355 }
25356 arg2 = static_cast< bool >(val2);
25357 {
25358 PyThreadState* __tstate = wxPyBeginAllowThreads();
25359 (arg1)->Show(arg2);
25360 wxPyEndAllowThreads(__tstate);
25361 if (PyErr_Occurred()) SWIG_fail;
25362 }
25363 resultobj = SWIG_Py_Void();
25364 return resultobj;
25365 fail:
25366 return NULL;
25367 }
25368
25369
25370 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25371 PyObject *resultobj = 0;
25372 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25373 wxString *arg2 = 0 ;
25374 void *argp1 = 0 ;
25375 int res1 = 0 ;
25376 bool temp2 = false ;
25377 PyObject * obj0 = 0 ;
25378 PyObject * obj1 = 0 ;
25379 char * kwnames[] = {
25380 (char *) "self",(char *) "text", NULL
25381 };
25382
25383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25387 }
25388 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25389 {
25390 arg2 = wxString_in_helper(obj1);
25391 if (arg2 == NULL) SWIG_fail;
25392 temp2 = true;
25393 }
25394 {
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 (arg1)->SetText((wxString const &)*arg2);
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 resultobj = SWIG_Py_Void();
25401 {
25402 if (temp2)
25403 delete arg2;
25404 }
25405 return resultobj;
25406 fail:
25407 {
25408 if (temp2)
25409 delete arg2;
25410 }
25411 return NULL;
25412 }
25413
25414
25415 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25416 PyObject *resultobj = 0;
25417 long arg1 ;
25418 long val1 ;
25419 int ecode1 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 char * kwnames[] = {
25422 (char *) "updateInterval", NULL
25423 };
25424
25425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25426 ecode1 = SWIG_AsVal_long(obj0, &val1);
25427 if (!SWIG_IsOK(ecode1)) {
25428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25429 }
25430 arg1 = static_cast< long >(val1);
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 wxUpdateUIEvent::SetUpdateInterval(arg1);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_Py_Void();
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 long result;
25447
25448 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 resultobj = SWIG_From_long(static_cast< long >(result));
25456 return resultobj;
25457 fail:
25458 return NULL;
25459 }
25460
25461
25462 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25463 PyObject *resultobj = 0;
25464 wxWindow *arg1 = (wxWindow *) 0 ;
25465 bool result;
25466 void *argp1 = 0 ;
25467 int res1 = 0 ;
25468 PyObject * obj0 = 0 ;
25469 char * kwnames[] = {
25470 (char *) "win", NULL
25471 };
25472
25473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25477 }
25478 arg1 = reinterpret_cast< wxWindow * >(argp1);
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 {
25486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25487 }
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 wxUpdateUIEvent::ResetUpdateTime();
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 resultobj = SWIG_Py_Void();
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25512 PyObject *resultobj = 0;
25513 wxUpdateUIMode arg1 ;
25514 int val1 ;
25515 int ecode1 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 char * kwnames[] = {
25518 (char *) "mode", NULL
25519 };
25520
25521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25522 ecode1 = SWIG_AsVal_int(obj0, &val1);
25523 if (!SWIG_IsOK(ecode1)) {
25524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25525 }
25526 arg1 = static_cast< wxUpdateUIMode >(val1);
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 wxUpdateUIEvent::SetMode(arg1);
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 resultobj = SWIG_Py_Void();
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxUpdateUIMode result;
25543
25544 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25548 wxPyEndAllowThreads(__tstate);
25549 if (PyErr_Occurred()) SWIG_fail;
25550 }
25551 resultobj = SWIG_From_int(static_cast< int >(result));
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 PyObject *obj;
25560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25561 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25562 return SWIG_Py_Void();
25563 }
25564
25565 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 return SWIG_Python_InitShadowInstance(args);
25567 }
25568
25569 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25570 PyObject *resultobj = 0;
25571 wxSysColourChangedEvent *result = 0 ;
25572
25573 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *obj;
25589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25590 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25591 return SWIG_Py_Void();
25592 }
25593
25594 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25595 return SWIG_Python_InitShadowInstance(args);
25596 }
25597
25598 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj = 0;
25600 int arg1 = (int) 0 ;
25601 wxWindow *arg2 = (wxWindow *) NULL ;
25602 wxMouseCaptureChangedEvent *result = 0 ;
25603 int val1 ;
25604 int ecode1 = 0 ;
25605 void *argp2 = 0 ;
25606 int res2 = 0 ;
25607 PyObject * obj0 = 0 ;
25608 PyObject * obj1 = 0 ;
25609 char * kwnames[] = {
25610 (char *) "winid",(char *) "gainedCapture", NULL
25611 };
25612
25613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25614 if (obj0) {
25615 ecode1 = SWIG_AsVal_int(obj0, &val1);
25616 if (!SWIG_IsOK(ecode1)) {
25617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25618 }
25619 arg1 = static_cast< int >(val1);
25620 }
25621 if (obj1) {
25622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25623 if (!SWIG_IsOK(res2)) {
25624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25625 }
25626 arg2 = reinterpret_cast< wxWindow * >(argp2);
25627 }
25628 {
25629 PyThreadState* __tstate = wxPyBeginAllowThreads();
25630 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25635 return resultobj;
25636 fail:
25637 return NULL;
25638 }
25639
25640
25641 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25642 PyObject *resultobj = 0;
25643 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25644 wxWindow *result = 0 ;
25645 void *argp1 = 0 ;
25646 int res1 = 0 ;
25647 PyObject *swig_obj[1] ;
25648
25649 if (!args) SWIG_fail;
25650 swig_obj[0] = args;
25651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25652 if (!SWIG_IsOK(res1)) {
25653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25654 }
25655 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 {
25663 resultobj = wxPyMake_wxObject(result, (bool)0);
25664 }
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25672 PyObject *obj;
25673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25675 return SWIG_Py_Void();
25676 }
25677
25678 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25679 return SWIG_Python_InitShadowInstance(args);
25680 }
25681
25682 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25683 PyObject *resultobj = 0;
25684 int arg1 = (int) 0 ;
25685 wxMouseCaptureLostEvent *result = 0 ;
25686 int val1 ;
25687 int ecode1 = 0 ;
25688 PyObject * obj0 = 0 ;
25689 char * kwnames[] = {
25690 (char *) "winid", NULL
25691 };
25692
25693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25694 if (obj0) {
25695 ecode1 = SWIG_AsVal_int(obj0, &val1);
25696 if (!SWIG_IsOK(ecode1)) {
25697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25698 }
25699 arg1 = static_cast< int >(val1);
25700 }
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25704 wxPyEndAllowThreads(__tstate);
25705 if (PyErr_Occurred()) SWIG_fail;
25706 }
25707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *obj;
25716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25717 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25718 return SWIG_Py_Void();
25719 }
25720
25721 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25722 return SWIG_Python_InitShadowInstance(args);
25723 }
25724
25725 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25726 PyObject *resultobj = 0;
25727 wxDisplayChangedEvent *result = 0 ;
25728
25729 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25744 PyObject *obj;
25745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25746 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25747 return SWIG_Py_Void();
25748 }
25749
25750 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25751 return SWIG_Python_InitShadowInstance(args);
25752 }
25753
25754 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25755 PyObject *resultobj = 0;
25756 int arg1 = (int) 0 ;
25757 wxPaletteChangedEvent *result = 0 ;
25758 int val1 ;
25759 int ecode1 = 0 ;
25760 PyObject * obj0 = 0 ;
25761 char * kwnames[] = {
25762 (char *) "id", NULL
25763 };
25764
25765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25766 if (obj0) {
25767 ecode1 = SWIG_AsVal_int(obj0, &val1);
25768 if (!SWIG_IsOK(ecode1)) {
25769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25770 }
25771 arg1 = static_cast< int >(val1);
25772 }
25773 {
25774 PyThreadState* __tstate = wxPyBeginAllowThreads();
25775 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25776 wxPyEndAllowThreads(__tstate);
25777 if (PyErr_Occurred()) SWIG_fail;
25778 }
25779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25780 return resultobj;
25781 fail:
25782 return NULL;
25783 }
25784
25785
25786 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25787 PyObject *resultobj = 0;
25788 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25789 wxWindow *arg2 = (wxWindow *) 0 ;
25790 void *argp1 = 0 ;
25791 int res1 = 0 ;
25792 void *argp2 = 0 ;
25793 int res2 = 0 ;
25794 PyObject * obj0 = 0 ;
25795 PyObject * obj1 = 0 ;
25796 char * kwnames[] = {
25797 (char *) "self",(char *) "win", NULL
25798 };
25799
25800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25802 if (!SWIG_IsOK(res1)) {
25803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25804 }
25805 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25807 if (!SWIG_IsOK(res2)) {
25808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25809 }
25810 arg2 = reinterpret_cast< wxWindow * >(argp2);
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 (arg1)->SetChangedWindow(arg2);
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 resultobj = SWIG_Py_Void();
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25825 PyObject *resultobj = 0;
25826 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25827 wxWindow *result = 0 ;
25828 void *argp1 = 0 ;
25829 int res1 = 0 ;
25830 PyObject *swig_obj[1] ;
25831
25832 if (!args) SWIG_fail;
25833 swig_obj[0] = args;
25834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25835 if (!SWIG_IsOK(res1)) {
25836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25837 }
25838 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25839 {
25840 PyThreadState* __tstate = wxPyBeginAllowThreads();
25841 result = (wxWindow *)(arg1)->GetChangedWindow();
25842 wxPyEndAllowThreads(__tstate);
25843 if (PyErr_Occurred()) SWIG_fail;
25844 }
25845 {
25846 resultobj = wxPyMake_wxObject(result, (bool)0);
25847 }
25848 return resultobj;
25849 fail:
25850 return NULL;
25851 }
25852
25853
25854 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25855 PyObject *obj;
25856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25857 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25858 return SWIG_Py_Void();
25859 }
25860
25861 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25862 return SWIG_Python_InitShadowInstance(args);
25863 }
25864
25865 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj = 0;
25867 int arg1 = (int) 0 ;
25868 wxQueryNewPaletteEvent *result = 0 ;
25869 int val1 ;
25870 int ecode1 = 0 ;
25871 PyObject * obj0 = 0 ;
25872 char * kwnames[] = {
25873 (char *) "winid", NULL
25874 };
25875
25876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25877 if (obj0) {
25878 ecode1 = SWIG_AsVal_int(obj0, &val1);
25879 if (!SWIG_IsOK(ecode1)) {
25880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25881 }
25882 arg1 = static_cast< int >(val1);
25883 }
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25898 PyObject *resultobj = 0;
25899 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25900 bool arg2 ;
25901 void *argp1 = 0 ;
25902 int res1 = 0 ;
25903 bool val2 ;
25904 int ecode2 = 0 ;
25905 PyObject * obj0 = 0 ;
25906 PyObject * obj1 = 0 ;
25907 char * kwnames[] = {
25908 (char *) "self",(char *) "realized", NULL
25909 };
25910
25911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25913 if (!SWIG_IsOK(res1)) {
25914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25915 }
25916 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25918 if (!SWIG_IsOK(ecode2)) {
25919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25920 }
25921 arg2 = static_cast< bool >(val2);
25922 {
25923 PyThreadState* __tstate = wxPyBeginAllowThreads();
25924 (arg1)->SetPaletteRealized(arg2);
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 resultobj = SWIG_Py_Void();
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936 PyObject *resultobj = 0;
25937 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25938 bool result;
25939 void *argp1 = 0 ;
25940 int res1 = 0 ;
25941 PyObject *swig_obj[1] ;
25942
25943 if (!args) SWIG_fail;
25944 swig_obj[0] = args;
25945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25946 if (!SWIG_IsOK(res1)) {
25947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25948 }
25949 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 {
25957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25958 }
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25966 PyObject *obj;
25967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25968 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25969 return SWIG_Py_Void();
25970 }
25971
25972 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 return SWIG_Python_InitShadowInstance(args);
25974 }
25975
25976 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25977 PyObject *resultobj = 0;
25978 wxNavigationKeyEvent *result = 0 ;
25979
25980 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25981 {
25982 PyThreadState* __tstate = wxPyBeginAllowThreads();
25983 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25995 PyObject *resultobj = 0;
25996 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25997 bool result;
25998 void *argp1 = 0 ;
25999 int res1 = 0 ;
26000 PyObject *swig_obj[1] ;
26001
26002 if (!args) SWIG_fail;
26003 swig_obj[0] = args;
26004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26005 if (!SWIG_IsOK(res1)) {
26006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26007 }
26008 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26012 wxPyEndAllowThreads(__tstate);
26013 if (PyErr_Occurred()) SWIG_fail;
26014 }
26015 {
26016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26017 }
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj = 0;
26026 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26027 bool arg2 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 bool val2 ;
26031 int ecode2 = 0 ;
26032 PyObject * obj0 = 0 ;
26033 PyObject * obj1 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "self",(char *) "forward", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26042 }
26043 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26045 if (!SWIG_IsOK(ecode2)) {
26046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26047 }
26048 arg2 = static_cast< bool >(val2);
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 (arg1)->SetDirection(arg2);
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_Py_Void();
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26063 PyObject *resultobj = 0;
26064 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26065 bool result;
26066 void *argp1 = 0 ;
26067 int res1 = 0 ;
26068 PyObject *swig_obj[1] ;
26069
26070 if (!args) SWIG_fail;
26071 swig_obj[0] = args;
26072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26073 if (!SWIG_IsOK(res1)) {
26074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26075 }
26076 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 {
26084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26085 }
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj = 0;
26094 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26095 bool arg2 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 bool val2 ;
26099 int ecode2 = 0 ;
26100 PyObject * obj0 = 0 ;
26101 PyObject * obj1 = 0 ;
26102 char * kwnames[] = {
26103 (char *) "self",(char *) "ischange", NULL
26104 };
26105
26106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26108 if (!SWIG_IsOK(res1)) {
26109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26110 }
26111 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26113 if (!SWIG_IsOK(ecode2)) {
26114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26115 }
26116 arg2 = static_cast< bool >(val2);
26117 {
26118 PyThreadState* __tstate = wxPyBeginAllowThreads();
26119 (arg1)->SetWindowChange(arg2);
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 resultobj = SWIG_Py_Void();
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26131 PyObject *resultobj = 0;
26132 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26133 bool result;
26134 void *argp1 = 0 ;
26135 int res1 = 0 ;
26136 PyObject *swig_obj[1] ;
26137
26138 if (!args) SWIG_fail;
26139 swig_obj[0] = args;
26140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26143 }
26144 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 {
26152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26153 }
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj = 0;
26162 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26163 bool arg2 ;
26164 void *argp1 = 0 ;
26165 int res1 = 0 ;
26166 bool val2 ;
26167 int ecode2 = 0 ;
26168 PyObject * obj0 = 0 ;
26169 PyObject * obj1 = 0 ;
26170 char * kwnames[] = {
26171 (char *) "self",(char *) "bIs", NULL
26172 };
26173
26174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26176 if (!SWIG_IsOK(res1)) {
26177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26178 }
26179 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26181 if (!SWIG_IsOK(ecode2)) {
26182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26183 }
26184 arg2 = static_cast< bool >(val2);
26185 {
26186 PyThreadState* __tstate = wxPyBeginAllowThreads();
26187 (arg1)->SetFromTab(arg2);
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 resultobj = SWIG_Py_Void();
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26199 PyObject *resultobj = 0;
26200 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26201 long arg2 ;
26202 void *argp1 = 0 ;
26203 int res1 = 0 ;
26204 long val2 ;
26205 int ecode2 = 0 ;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 char * kwnames[] = {
26209 (char *) "self",(char *) "flags", NULL
26210 };
26211
26212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26214 if (!SWIG_IsOK(res1)) {
26215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26216 }
26217 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26218 ecode2 = SWIG_AsVal_long(obj1, &val2);
26219 if (!SWIG_IsOK(ecode2)) {
26220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26221 }
26222 arg2 = static_cast< long >(val2);
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 (arg1)->SetFlags(arg2);
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 resultobj = SWIG_Py_Void();
26230 return resultobj;
26231 fail:
26232 return NULL;
26233 }
26234
26235
26236 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26237 PyObject *resultobj = 0;
26238 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26239 wxWindow *result = 0 ;
26240 void *argp1 = 0 ;
26241 int res1 = 0 ;
26242 PyObject *swig_obj[1] ;
26243
26244 if (!args) SWIG_fail;
26245 swig_obj[0] = args;
26246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26247 if (!SWIG_IsOK(res1)) {
26248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26249 }
26250 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26251 {
26252 PyThreadState* __tstate = wxPyBeginAllowThreads();
26253 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26254 wxPyEndAllowThreads(__tstate);
26255 if (PyErr_Occurred()) SWIG_fail;
26256 }
26257 {
26258 resultobj = wxPyMake_wxObject(result, (bool)0);
26259 }
26260 return resultobj;
26261 fail:
26262 return NULL;
26263 }
26264
26265
26266 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26267 PyObject *resultobj = 0;
26268 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26269 wxWindow *arg2 = (wxWindow *) 0 ;
26270 void *argp1 = 0 ;
26271 int res1 = 0 ;
26272 void *argp2 = 0 ;
26273 int res2 = 0 ;
26274 PyObject * obj0 = 0 ;
26275 PyObject * obj1 = 0 ;
26276 char * kwnames[] = {
26277 (char *) "self",(char *) "win", NULL
26278 };
26279
26280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26282 if (!SWIG_IsOK(res1)) {
26283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26284 }
26285 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26287 if (!SWIG_IsOK(res2)) {
26288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26289 }
26290 arg2 = reinterpret_cast< wxWindow * >(argp2);
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 (arg1)->SetCurrentFocus(arg2);
26294 wxPyEndAllowThreads(__tstate);
26295 if (PyErr_Occurred()) SWIG_fail;
26296 }
26297 resultobj = SWIG_Py_Void();
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *obj;
26306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26307 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26308 return SWIG_Py_Void();
26309 }
26310
26311 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 return SWIG_Python_InitShadowInstance(args);
26313 }
26314
26315 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj = 0;
26317 wxWindow *arg1 = (wxWindow *) NULL ;
26318 wxWindowCreateEvent *result = 0 ;
26319 void *argp1 = 0 ;
26320 int res1 = 0 ;
26321 PyObject * obj0 = 0 ;
26322 char * kwnames[] = {
26323 (char *) "win", NULL
26324 };
26325
26326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26327 if (obj0) {
26328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26331 }
26332 arg1 = reinterpret_cast< wxWindow * >(argp1);
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26348 PyObject *resultobj = 0;
26349 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26350 wxWindow *result = 0 ;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 PyObject *swig_obj[1] ;
26354
26355 if (!args) SWIG_fail;
26356 swig_obj[0] = args;
26357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26360 }
26361 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26362 {
26363 PyThreadState* __tstate = wxPyBeginAllowThreads();
26364 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 resultobj = wxPyMake_wxObject(result, (bool)0);
26370 }
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 PyObject *obj;
26379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26380 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26381 return SWIG_Py_Void();
26382 }
26383
26384 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26385 return SWIG_Python_InitShadowInstance(args);
26386 }
26387
26388 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26389 PyObject *resultobj = 0;
26390 wxWindow *arg1 = (wxWindow *) NULL ;
26391 wxWindowDestroyEvent *result = 0 ;
26392 void *argp1 = 0 ;
26393 int res1 = 0 ;
26394 PyObject * obj0 = 0 ;
26395 char * kwnames[] = {
26396 (char *) "win", NULL
26397 };
26398
26399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26400 if (obj0) {
26401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26402 if (!SWIG_IsOK(res1)) {
26403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26404 }
26405 arg1 = reinterpret_cast< wxWindow * >(argp1);
26406 }
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26421 PyObject *resultobj = 0;
26422 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26423 wxWindow *result = 0 ;
26424 void *argp1 = 0 ;
26425 int res1 = 0 ;
26426 PyObject *swig_obj[1] ;
26427
26428 if (!args) SWIG_fail;
26429 swig_obj[0] = args;
26430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26431 if (!SWIG_IsOK(res1)) {
26432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26433 }
26434 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26435 {
26436 PyThreadState* __tstate = wxPyBeginAllowThreads();
26437 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 {
26442 resultobj = wxPyMake_wxObject(result, (bool)0);
26443 }
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26451 PyObject *obj;
26452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26453 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26454 return SWIG_Py_Void();
26455 }
26456
26457 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26458 return SWIG_Python_InitShadowInstance(args);
26459 }
26460
26461 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj = 0;
26463 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26464 int arg2 = (int) 0 ;
26465 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26466 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26467 wxContextMenuEvent *result = 0 ;
26468 int val1 ;
26469 int ecode1 = 0 ;
26470 int val2 ;
26471 int ecode2 = 0 ;
26472 wxPoint temp3 ;
26473 PyObject * obj0 = 0 ;
26474 PyObject * obj1 = 0 ;
26475 PyObject * obj2 = 0 ;
26476 char * kwnames[] = {
26477 (char *) "type",(char *) "winid",(char *) "pt", NULL
26478 };
26479
26480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26481 if (obj0) {
26482 ecode1 = SWIG_AsVal_int(obj0, &val1);
26483 if (!SWIG_IsOK(ecode1)) {
26484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26485 }
26486 arg1 = static_cast< wxEventType >(val1);
26487 }
26488 if (obj1) {
26489 ecode2 = SWIG_AsVal_int(obj1, &val2);
26490 if (!SWIG_IsOK(ecode2)) {
26491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26492 }
26493 arg2 = static_cast< int >(val2);
26494 }
26495 if (obj2) {
26496 {
26497 arg3 = &temp3;
26498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26499 }
26500 }
26501 {
26502 PyThreadState* __tstate = wxPyBeginAllowThreads();
26503 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26504 wxPyEndAllowThreads(__tstate);
26505 if (PyErr_Occurred()) SWIG_fail;
26506 }
26507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26508 return resultobj;
26509 fail:
26510 return NULL;
26511 }
26512
26513
26514 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26515 PyObject *resultobj = 0;
26516 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26517 wxPoint *result = 0 ;
26518 void *argp1 = 0 ;
26519 int res1 = 0 ;
26520 PyObject *swig_obj[1] ;
26521
26522 if (!args) SWIG_fail;
26523 swig_obj[0] = args;
26524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26525 if (!SWIG_IsOK(res1)) {
26526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26527 }
26528 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26529 {
26530 PyThreadState* __tstate = wxPyBeginAllowThreads();
26531 {
26532 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26533 result = (wxPoint *) &_result_ref;
26534 }
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj = 0;
26547 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26548 wxPoint *arg2 = 0 ;
26549 void *argp1 = 0 ;
26550 int res1 = 0 ;
26551 wxPoint temp2 ;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554 char * kwnames[] = {
26555 (char *) "self",(char *) "pos", NULL
26556 };
26557
26558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26560 if (!SWIG_IsOK(res1)) {
26561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26562 }
26563 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26564 {
26565 arg2 = &temp2;
26566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26567 }
26568 {
26569 PyThreadState* __tstate = wxPyBeginAllowThreads();
26570 (arg1)->SetPosition((wxPoint const &)*arg2);
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 resultobj = SWIG_Py_Void();
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26582 PyObject *obj;
26583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26584 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26585 return SWIG_Py_Void();
26586 }
26587
26588 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26589 return SWIG_Python_InitShadowInstance(args);
26590 }
26591
26592 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26593 PyObject *resultobj = 0;
26594 wxIdleEvent *result = 0 ;
26595
26596 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26597 {
26598 PyThreadState* __tstate = wxPyBeginAllowThreads();
26599 result = (wxIdleEvent *)new wxIdleEvent();
26600 wxPyEndAllowThreads(__tstate);
26601 if (PyErr_Occurred()) SWIG_fail;
26602 }
26603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26604 return resultobj;
26605 fail:
26606 return NULL;
26607 }
26608
26609
26610 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26611 PyObject *resultobj = 0;
26612 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26613 bool arg2 = (bool) true ;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 bool val2 ;
26617 int ecode2 = 0 ;
26618 PyObject * obj0 = 0 ;
26619 PyObject * obj1 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "self",(char *) "needMore", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26626 if (!SWIG_IsOK(res1)) {
26627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26628 }
26629 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26630 if (obj1) {
26631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26632 if (!SWIG_IsOK(ecode2)) {
26633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26634 }
26635 arg2 = static_cast< bool >(val2);
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 (arg1)->RequestMore(arg2);
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 resultobj = SWIG_Py_Void();
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26651 PyObject *resultobj = 0;
26652 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26653 bool result;
26654 void *argp1 = 0 ;
26655 int res1 = 0 ;
26656 PyObject *swig_obj[1] ;
26657
26658 if (!args) SWIG_fail;
26659 swig_obj[0] = args;
26660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26661 if (!SWIG_IsOK(res1)) {
26662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26663 }
26664 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 {
26672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26673 }
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26681 PyObject *resultobj = 0;
26682 wxIdleMode arg1 ;
26683 int val1 ;
26684 int ecode1 = 0 ;
26685 PyObject * obj0 = 0 ;
26686 char * kwnames[] = {
26687 (char *) "mode", NULL
26688 };
26689
26690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26691 ecode1 = SWIG_AsVal_int(obj0, &val1);
26692 if (!SWIG_IsOK(ecode1)) {
26693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26694 }
26695 arg1 = static_cast< wxIdleMode >(val1);
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 wxIdleEvent::SetMode(arg1);
26699 wxPyEndAllowThreads(__tstate);
26700 if (PyErr_Occurred()) SWIG_fail;
26701 }
26702 resultobj = SWIG_Py_Void();
26703 return resultobj;
26704 fail:
26705 return NULL;
26706 }
26707
26708
26709 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26710 PyObject *resultobj = 0;
26711 wxIdleMode result;
26712
26713 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26714 {
26715 PyThreadState* __tstate = wxPyBeginAllowThreads();
26716 result = (wxIdleMode)wxIdleEvent::GetMode();
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 resultobj = SWIG_From_int(static_cast< int >(result));
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26728 PyObject *resultobj = 0;
26729 wxWindow *arg1 = (wxWindow *) 0 ;
26730 bool result;
26731 void *argp1 = 0 ;
26732 int res1 = 0 ;
26733 PyObject * obj0 = 0 ;
26734 char * kwnames[] = {
26735 (char *) "win", NULL
26736 };
26737
26738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26740 if (!SWIG_IsOK(res1)) {
26741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26742 }
26743 arg1 = reinterpret_cast< wxWindow * >(argp1);
26744 {
26745 PyThreadState* __tstate = wxPyBeginAllowThreads();
26746 result = (bool)wxIdleEvent::CanSend(arg1);
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 {
26751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26752 }
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *IdleEvent_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_wxIdleEvent, SWIG_NewClientData(obj));
26763 return SWIG_Py_Void();
26764 }
26765
26766 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26767 return SWIG_Python_InitShadowInstance(args);
26768 }
26769
26770 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26773 int arg2 = (int) 0 ;
26774 wxClipboardTextEvent *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 *) "type",(char *) "winid", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",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_ClipboardTextEvent" "', 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_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26797 }
26798 arg2 = static_cast< int >(val2);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *obj;
26815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26816 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26817 return SWIG_Py_Void();
26818 }
26819
26820 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26821 return SWIG_Python_InitShadowInstance(args);
26822 }
26823
26824 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj = 0;
26826 int arg1 = (int) 0 ;
26827 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26828 wxPyEvent *result = 0 ;
26829 int val1 ;
26830 int ecode1 = 0 ;
26831 int val2 ;
26832 int ecode2 = 0 ;
26833 PyObject * obj0 = 0 ;
26834 PyObject * obj1 = 0 ;
26835 char * kwnames[] = {
26836 (char *) "winid",(char *) "eventType", NULL
26837 };
26838
26839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26840 if (obj0) {
26841 ecode1 = SWIG_AsVal_int(obj0, &val1);
26842 if (!SWIG_IsOK(ecode1)) {
26843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26844 }
26845 arg1 = static_cast< int >(val1);
26846 }
26847 if (obj1) {
26848 ecode2 = SWIG_AsVal_int(obj1, &val2);
26849 if (!SWIG_IsOK(ecode2)) {
26850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26851 }
26852 arg2 = static_cast< wxEventType >(val2);
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26868 PyObject *resultobj = 0;
26869 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26870 void *argp1 = 0 ;
26871 int res1 = 0 ;
26872 PyObject *swig_obj[1] ;
26873
26874 if (!args) SWIG_fail;
26875 swig_obj[0] = args;
26876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26877 if (!SWIG_IsOK(res1)) {
26878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26879 }
26880 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 delete arg1;
26884
26885 wxPyEndAllowThreads(__tstate);
26886 if (PyErr_Occurred()) SWIG_fail;
26887 }
26888 resultobj = SWIG_Py_Void();
26889 return resultobj;
26890 fail:
26891 return NULL;
26892 }
26893
26894
26895 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26896 PyObject *resultobj = 0;
26897 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26898 PyObject *arg2 = (PyObject *) 0 ;
26899 void *argp1 = 0 ;
26900 int res1 = 0 ;
26901 PyObject * obj0 = 0 ;
26902 PyObject * obj1 = 0 ;
26903 char * kwnames[] = {
26904 (char *) "self",(char *) "self", NULL
26905 };
26906
26907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26911 }
26912 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26913 arg2 = obj1;
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 (arg1)->SetSelf(arg2);
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 resultobj = SWIG_Py_Void();
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26928 PyObject *resultobj = 0;
26929 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26930 PyObject *result = 0 ;
26931 void *argp1 = 0 ;
26932 int res1 = 0 ;
26933 PyObject *swig_obj[1] ;
26934
26935 if (!args) SWIG_fail;
26936 swig_obj[0] = args;
26937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26938 if (!SWIG_IsOK(res1)) {
26939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26940 }
26941 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = (PyObject *)(arg1)->GetSelf();
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 resultobj = result;
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 PyObject *obj;
26957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26958 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26959 return SWIG_Py_Void();
26960 }
26961
26962 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26963 return SWIG_Python_InitShadowInstance(args);
26964 }
26965
26966 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26967 PyObject *resultobj = 0;
26968 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26969 int arg2 = (int) 0 ;
26970 wxPyCommandEvent *result = 0 ;
26971 int val1 ;
26972 int ecode1 = 0 ;
26973 int val2 ;
26974 int ecode2 = 0 ;
26975 PyObject * obj0 = 0 ;
26976 PyObject * obj1 = 0 ;
26977 char * kwnames[] = {
26978 (char *) "eventType",(char *) "id", NULL
26979 };
26980
26981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26982 if (obj0) {
26983 ecode1 = SWIG_AsVal_int(obj0, &val1);
26984 if (!SWIG_IsOK(ecode1)) {
26985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26986 }
26987 arg1 = static_cast< wxEventType >(val1);
26988 }
26989 if (obj1) {
26990 ecode2 = SWIG_AsVal_int(obj1, &val2);
26991 if (!SWIG_IsOK(ecode2)) {
26992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26993 }
26994 arg2 = static_cast< int >(val2);
26995 }
26996 {
26997 PyThreadState* __tstate = wxPyBeginAllowThreads();
26998 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26999 wxPyEndAllowThreads(__tstate);
27000 if (PyErr_Occurred()) SWIG_fail;
27001 }
27002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27003 return resultobj;
27004 fail:
27005 return NULL;
27006 }
27007
27008
27009 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27010 PyObject *resultobj = 0;
27011 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27012 void *argp1 = 0 ;
27013 int res1 = 0 ;
27014 PyObject *swig_obj[1] ;
27015
27016 if (!args) SWIG_fail;
27017 swig_obj[0] = args;
27018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27019 if (!SWIG_IsOK(res1)) {
27020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27021 }
27022 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 delete arg1;
27026
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 resultobj = SWIG_Py_Void();
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27038 PyObject *resultobj = 0;
27039 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27040 PyObject *arg2 = (PyObject *) 0 ;
27041 void *argp1 = 0 ;
27042 int res1 = 0 ;
27043 PyObject * obj0 = 0 ;
27044 PyObject * obj1 = 0 ;
27045 char * kwnames[] = {
27046 (char *) "self",(char *) "self", NULL
27047 };
27048
27049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27051 if (!SWIG_IsOK(res1)) {
27052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27053 }
27054 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27055 arg2 = obj1;
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 (arg1)->SetSelf(arg2);
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 resultobj = SWIG_Py_Void();
27063 return resultobj;
27064 fail:
27065 return NULL;
27066 }
27067
27068
27069 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27070 PyObject *resultobj = 0;
27071 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27072 PyObject *result = 0 ;
27073 void *argp1 = 0 ;
27074 int res1 = 0 ;
27075 PyObject *swig_obj[1] ;
27076
27077 if (!args) SWIG_fail;
27078 swig_obj[0] = args;
27079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27080 if (!SWIG_IsOK(res1)) {
27081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27082 }
27083 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = (PyObject *)(arg1)->GetSelf();
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 resultobj = result;
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27098 PyObject *obj;
27099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27100 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27101 return SWIG_Py_Void();
27102 }
27103
27104 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27105 return SWIG_Python_InitShadowInstance(args);
27106 }
27107
27108 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27109 PyObject *resultobj = 0;
27110 wxWindow *arg1 = (wxWindow *) 0 ;
27111 wxDateTime *arg2 = 0 ;
27112 wxEventType arg3 ;
27113 wxDateEvent *result = 0 ;
27114 void *argp1 = 0 ;
27115 int res1 = 0 ;
27116 void *argp2 = 0 ;
27117 int res2 = 0 ;
27118 int val3 ;
27119 int ecode3 = 0 ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 PyObject * obj2 = 0 ;
27123 char * kwnames[] = {
27124 (char *) "win",(char *) "dt",(char *) "type", NULL
27125 };
27126
27127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27129 if (!SWIG_IsOK(res1)) {
27130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27131 }
27132 arg1 = reinterpret_cast< wxWindow * >(argp1);
27133 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27134 if (!SWIG_IsOK(res2)) {
27135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27136 }
27137 if (!argp2) {
27138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27139 }
27140 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27141 ecode3 = SWIG_AsVal_int(obj2, &val3);
27142 if (!SWIG_IsOK(ecode3)) {
27143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27144 }
27145 arg3 = static_cast< wxEventType >(val3);
27146 {
27147 PyThreadState* __tstate = wxPyBeginAllowThreads();
27148 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27153 return resultobj;
27154 fail:
27155 return NULL;
27156 }
27157
27158
27159 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27160 PyObject *resultobj = 0;
27161 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27162 wxDateTime *result = 0 ;
27163 void *argp1 = 0 ;
27164 int res1 = 0 ;
27165 PyObject *swig_obj[1] ;
27166
27167 if (!args) SWIG_fail;
27168 swig_obj[0] = args;
27169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27170 if (!SWIG_IsOK(res1)) {
27171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27172 }
27173 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 {
27177 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27178 result = (wxDateTime *) &_result_ref;
27179 }
27180 wxPyEndAllowThreads(__tstate);
27181 if (PyErr_Occurred()) SWIG_fail;
27182 }
27183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27184 return resultobj;
27185 fail:
27186 return NULL;
27187 }
27188
27189
27190 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27191 PyObject *resultobj = 0;
27192 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27193 wxDateTime *arg2 = 0 ;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 void *argp2 = 0 ;
27197 int res2 = 0 ;
27198 PyObject * obj0 = 0 ;
27199 PyObject * obj1 = 0 ;
27200 char * kwnames[] = {
27201 (char *) "self",(char *) "date", NULL
27202 };
27203
27204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27206 if (!SWIG_IsOK(res1)) {
27207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27208 }
27209 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27210 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27211 if (!SWIG_IsOK(res2)) {
27212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27213 }
27214 if (!argp2) {
27215 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27216 }
27217 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27218 {
27219 PyThreadState* __tstate = wxPyBeginAllowThreads();
27220 (arg1)->SetDate((wxDateTime const &)*arg2);
27221 wxPyEndAllowThreads(__tstate);
27222 if (PyErr_Occurred()) SWIG_fail;
27223 }
27224 resultobj = SWIG_Py_Void();
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27232 PyObject *obj;
27233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27234 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27235 return SWIG_Py_Void();
27236 }
27237
27238 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27239 return SWIG_Python_InitShadowInstance(args);
27240 }
27241
27242 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27243 PyObject *resultobj = 0;
27244 wxPyApp *result = 0 ;
27245
27246 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27247 {
27248 PyThreadState* __tstate = wxPyBeginAllowThreads();
27249 result = (wxPyApp *)new_wxPyApp();
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27261 PyObject *resultobj = 0;
27262 wxPyApp *arg1 = (wxPyApp *) 0 ;
27263 void *argp1 = 0 ;
27264 int res1 = 0 ;
27265 PyObject *swig_obj[1] ;
27266
27267 if (!args) SWIG_fail;
27268 swig_obj[0] = args;
27269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27270 if (!SWIG_IsOK(res1)) {
27271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27272 }
27273 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 delete arg1;
27277
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 resultobj = SWIG_Py_Void();
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27289 PyObject *resultobj = 0;
27290 wxPyApp *arg1 = (wxPyApp *) 0 ;
27291 PyObject *arg2 = (PyObject *) 0 ;
27292 PyObject *arg3 = (PyObject *) 0 ;
27293 bool arg4 ;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 bool val4 ;
27297 int ecode4 = 0 ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 PyObject * obj2 = 0 ;
27301 PyObject * obj3 = 0 ;
27302 char * kwnames[] = {
27303 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27304 };
27305
27306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27310 }
27311 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27312 arg2 = obj1;
27313 arg3 = obj2;
27314 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27315 if (!SWIG_IsOK(ecode4)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27317 }
27318 arg4 = static_cast< bool >(val4);
27319 {
27320 PyThreadState* __tstate = wxPyBeginAllowThreads();
27321 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 resultobj = SWIG_Py_Void();
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27333 PyObject *resultobj = 0;
27334 wxPyApp *arg1 = (wxPyApp *) 0 ;
27335 wxString result;
27336 void *argp1 = 0 ;
27337 int res1 = 0 ;
27338 PyObject *swig_obj[1] ;
27339
27340 if (!args) SWIG_fail;
27341 swig_obj[0] = args;
27342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27345 }
27346 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 result = ((wxPyApp const *)arg1)->GetAppName();
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 {
27354 #if wxUSE_UNICODE
27355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27356 #else
27357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27358 #endif
27359 }
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27367 PyObject *resultobj = 0;
27368 wxPyApp *arg1 = (wxPyApp *) 0 ;
27369 wxString *arg2 = 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 bool temp2 = false ;
27373 PyObject * obj0 = 0 ;
27374 PyObject * obj1 = 0 ;
27375 char * kwnames[] = {
27376 (char *) "self",(char *) "name", NULL
27377 };
27378
27379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27383 }
27384 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27385 {
27386 arg2 = wxString_in_helper(obj1);
27387 if (arg2 == NULL) SWIG_fail;
27388 temp2 = true;
27389 }
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 (arg1)->SetAppName((wxString const &)*arg2);
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 resultobj = SWIG_Py_Void();
27397 {
27398 if (temp2)
27399 delete arg2;
27400 }
27401 return resultobj;
27402 fail:
27403 {
27404 if (temp2)
27405 delete arg2;
27406 }
27407 return NULL;
27408 }
27409
27410
27411 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27412 PyObject *resultobj = 0;
27413 wxPyApp *arg1 = (wxPyApp *) 0 ;
27414 wxString result;
27415 void *argp1 = 0 ;
27416 int res1 = 0 ;
27417 PyObject *swig_obj[1] ;
27418
27419 if (!args) SWIG_fail;
27420 swig_obj[0] = args;
27421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27422 if (!SWIG_IsOK(res1)) {
27423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27424 }
27425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = ((wxPyApp const *)arg1)->GetClassName();
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 {
27433 #if wxUSE_UNICODE
27434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27435 #else
27436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27437 #endif
27438 }
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj = 0;
27447 wxPyApp *arg1 = (wxPyApp *) 0 ;
27448 wxString *arg2 = 0 ;
27449 void *argp1 = 0 ;
27450 int res1 = 0 ;
27451 bool temp2 = false ;
27452 PyObject * obj0 = 0 ;
27453 PyObject * obj1 = 0 ;
27454 char * kwnames[] = {
27455 (char *) "self",(char *) "name", NULL
27456 };
27457
27458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27460 if (!SWIG_IsOK(res1)) {
27461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27462 }
27463 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27464 {
27465 arg2 = wxString_in_helper(obj1);
27466 if (arg2 == NULL) SWIG_fail;
27467 temp2 = true;
27468 }
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 (arg1)->SetClassName((wxString const &)*arg2);
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 resultobj = SWIG_Py_Void();
27476 {
27477 if (temp2)
27478 delete arg2;
27479 }
27480 return resultobj;
27481 fail:
27482 {
27483 if (temp2)
27484 delete arg2;
27485 }
27486 return NULL;
27487 }
27488
27489
27490 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27491 PyObject *resultobj = 0;
27492 wxPyApp *arg1 = (wxPyApp *) 0 ;
27493 wxString *result = 0 ;
27494 void *argp1 = 0 ;
27495 int res1 = 0 ;
27496 PyObject *swig_obj[1] ;
27497
27498 if (!args) SWIG_fail;
27499 swig_obj[0] = args;
27500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27501 if (!SWIG_IsOK(res1)) {
27502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27503 }
27504 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 {
27508 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27509 result = (wxString *) &_result_ref;
27510 }
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 {
27515 #if wxUSE_UNICODE
27516 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27517 #else
27518 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27519 #endif
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 wxPyApp *arg1 = (wxPyApp *) 0 ;
27530 wxString *arg2 = 0 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 bool temp2 = false ;
27534 PyObject * obj0 = 0 ;
27535 PyObject * obj1 = 0 ;
27536 char * kwnames[] = {
27537 (char *) "self",(char *) "name", NULL
27538 };
27539
27540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27542 if (!SWIG_IsOK(res1)) {
27543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27544 }
27545 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27546 {
27547 arg2 = wxString_in_helper(obj1);
27548 if (arg2 == NULL) SWIG_fail;
27549 temp2 = true;
27550 }
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 (arg1)->SetVendorName((wxString const &)*arg2);
27554 wxPyEndAllowThreads(__tstate);
27555 if (PyErr_Occurred()) SWIG_fail;
27556 }
27557 resultobj = SWIG_Py_Void();
27558 {
27559 if (temp2)
27560 delete arg2;
27561 }
27562 return resultobj;
27563 fail:
27564 {
27565 if (temp2)
27566 delete arg2;
27567 }
27568 return NULL;
27569 }
27570
27571
27572 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27573 PyObject *resultobj = 0;
27574 wxPyApp *arg1 = (wxPyApp *) 0 ;
27575 wxAppTraits *result = 0 ;
27576 void *argp1 = 0 ;
27577 int res1 = 0 ;
27578 PyObject *swig_obj[1] ;
27579
27580 if (!args) SWIG_fail;
27581 swig_obj[0] = args;
27582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27583 if (!SWIG_IsOK(res1)) {
27584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27585 }
27586 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27587 {
27588 PyThreadState* __tstate = wxPyBeginAllowThreads();
27589 result = (wxAppTraits *)(arg1)->GetTraits();
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27601 PyObject *resultobj = 0;
27602 wxPyApp *arg1 = (wxPyApp *) 0 ;
27603 void *argp1 = 0 ;
27604 int res1 = 0 ;
27605 PyObject *swig_obj[1] ;
27606
27607 if (!args) SWIG_fail;
27608 swig_obj[0] = args;
27609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27610 if (!SWIG_IsOK(res1)) {
27611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27612 }
27613 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27614 {
27615 PyThreadState* __tstate = wxPyBeginAllowThreads();
27616 (arg1)->ProcessPendingEvents();
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 resultobj = SWIG_Py_Void();
27621 return resultobj;
27622 fail:
27623 return NULL;
27624 }
27625
27626
27627 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27628 PyObject *resultobj = 0;
27629 wxPyApp *arg1 = (wxPyApp *) 0 ;
27630 bool arg2 = (bool) false ;
27631 bool result;
27632 void *argp1 = 0 ;
27633 int res1 = 0 ;
27634 bool val2 ;
27635 int ecode2 = 0 ;
27636 PyObject * obj0 = 0 ;
27637 PyObject * obj1 = 0 ;
27638 char * kwnames[] = {
27639 (char *) "self",(char *) "onlyIfNeeded", NULL
27640 };
27641
27642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 if (obj1) {
27649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27650 if (!SWIG_IsOK(ecode2)) {
27651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27652 }
27653 arg2 = static_cast< bool >(val2);
27654 }
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = (bool)(arg1)->Yield(arg2);
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 {
27662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27663 }
27664 return resultobj;
27665 fail:
27666 return NULL;
27667 }
27668
27669
27670 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27671 PyObject *resultobj = 0;
27672 wxPyApp *arg1 = (wxPyApp *) 0 ;
27673 void *argp1 = 0 ;
27674 int res1 = 0 ;
27675 PyObject *swig_obj[1] ;
27676
27677 if (!args) SWIG_fail;
27678 swig_obj[0] = args;
27679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27680 if (!SWIG_IsOK(res1)) {
27681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27682 }
27683 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->WakeUpIdle();
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 resultobj = SWIG_Py_Void();
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27698 PyObject *resultobj = 0;
27699 bool result;
27700
27701 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27702 {
27703 PyThreadState* __tstate = wxPyBeginAllowThreads();
27704 result = (bool)wxPyApp::IsMainLoopRunning();
27705 wxPyEndAllowThreads(__tstate);
27706 if (PyErr_Occurred()) SWIG_fail;
27707 }
27708 {
27709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27710 }
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27718 PyObject *resultobj = 0;
27719 wxPyApp *arg1 = (wxPyApp *) 0 ;
27720 int result;
27721 void *argp1 = 0 ;
27722 int res1 = 0 ;
27723 PyObject *swig_obj[1] ;
27724
27725 if (!args) SWIG_fail;
27726 swig_obj[0] = args;
27727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27728 if (!SWIG_IsOK(res1)) {
27729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27730 }
27731 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 result = (int)(arg1)->MainLoop();
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_From_int(static_cast< int >(result));
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxPyApp *arg1 = (wxPyApp *) 0 ;
27748 void *argp1 = 0 ;
27749 int res1 = 0 ;
27750 PyObject *swig_obj[1] ;
27751
27752 if (!args) SWIG_fail;
27753 swig_obj[0] = args;
27754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27755 if (!SWIG_IsOK(res1)) {
27756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27757 }
27758 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 (arg1)->Exit();
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 resultobj = SWIG_Py_Void();
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27773 PyObject *resultobj = 0;
27774 wxPyApp *arg1 = (wxPyApp *) 0 ;
27775 wxLayoutDirection result;
27776 void *argp1 = 0 ;
27777 int res1 = 0 ;
27778 PyObject *swig_obj[1] ;
27779
27780 if (!args) SWIG_fail;
27781 swig_obj[0] = args;
27782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27783 if (!SWIG_IsOK(res1)) {
27784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27785 }
27786 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27787 {
27788 PyThreadState* __tstate = wxPyBeginAllowThreads();
27789 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 resultobj = SWIG_From_int(static_cast< int >(result));
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27801 PyObject *resultobj = 0;
27802 wxPyApp *arg1 = (wxPyApp *) 0 ;
27803 void *argp1 = 0 ;
27804 int res1 = 0 ;
27805 PyObject *swig_obj[1] ;
27806
27807 if (!args) SWIG_fail;
27808 swig_obj[0] = args;
27809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27810 if (!SWIG_IsOK(res1)) {
27811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27812 }
27813 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->ExitMainLoop();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 resultobj = SWIG_Py_Void();
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27828 PyObject *resultobj = 0;
27829 wxPyApp *arg1 = (wxPyApp *) 0 ;
27830 bool result;
27831 void *argp1 = 0 ;
27832 int res1 = 0 ;
27833 PyObject *swig_obj[1] ;
27834
27835 if (!args) SWIG_fail;
27836 swig_obj[0] = args;
27837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27838 if (!SWIG_IsOK(res1)) {
27839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27840 }
27841 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (bool)(arg1)->Pending();
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 {
27849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27850 }
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27858 PyObject *resultobj = 0;
27859 wxPyApp *arg1 = (wxPyApp *) 0 ;
27860 bool result;
27861 void *argp1 = 0 ;
27862 int res1 = 0 ;
27863 PyObject *swig_obj[1] ;
27864
27865 if (!args) SWIG_fail;
27866 swig_obj[0] = args;
27867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27868 if (!SWIG_IsOK(res1)) {
27869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27870 }
27871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (bool)(arg1)->Dispatch();
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 {
27879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27880 }
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27888 PyObject *resultobj = 0;
27889 wxPyApp *arg1 = (wxPyApp *) 0 ;
27890 bool result;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 PyObject *swig_obj[1] ;
27894
27895 if (!args) SWIG_fail;
27896 swig_obj[0] = args;
27897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27898 if (!SWIG_IsOK(res1)) {
27899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27900 }
27901 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27902 {
27903 PyThreadState* __tstate = wxPyBeginAllowThreads();
27904 result = (bool)(arg1)->ProcessIdle();
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 {
27909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27910 }
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27918 PyObject *resultobj = 0;
27919 wxPyApp *arg1 = (wxPyApp *) 0 ;
27920 wxWindow *arg2 = (wxWindow *) 0 ;
27921 wxIdleEvent *arg3 = 0 ;
27922 bool result;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 void *argp2 = 0 ;
27926 int res2 = 0 ;
27927 void *argp3 = 0 ;
27928 int res3 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 PyObject * obj2 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "win",(char *) "event", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27940 }
27941 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27943 if (!SWIG_IsOK(res2)) {
27944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27945 }
27946 arg2 = reinterpret_cast< wxWindow * >(argp2);
27947 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27948 if (!SWIG_IsOK(res3)) {
27949 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27950 }
27951 if (!argp3) {
27952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27953 }
27954 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27955 {
27956 PyThreadState* __tstate = wxPyBeginAllowThreads();
27957 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27958 wxPyEndAllowThreads(__tstate);
27959 if (PyErr_Occurred()) SWIG_fail;
27960 }
27961 {
27962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27963 }
27964 return resultobj;
27965 fail:
27966 return NULL;
27967 }
27968
27969
27970 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27971 PyObject *resultobj = 0;
27972 wxPyApp *arg1 = (wxPyApp *) 0 ;
27973 bool result;
27974 void *argp1 = 0 ;
27975 int res1 = 0 ;
27976 PyObject *swig_obj[1] ;
27977
27978 if (!args) SWIG_fail;
27979 swig_obj[0] = args;
27980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27981 if (!SWIG_IsOK(res1)) {
27982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27983 }
27984 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27985 {
27986 PyThreadState* __tstate = wxPyBeginAllowThreads();
27987 result = (bool)((wxPyApp const *)arg1)->IsActive();
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 {
27992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27993 }
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28001 PyObject *resultobj = 0;
28002 wxPyApp *arg1 = (wxPyApp *) 0 ;
28003 wxWindow *arg2 = (wxWindow *) 0 ;
28004 void *argp1 = 0 ;
28005 int res1 = 0 ;
28006 void *argp2 = 0 ;
28007 int res2 = 0 ;
28008 PyObject * obj0 = 0 ;
28009 PyObject * obj1 = 0 ;
28010 char * kwnames[] = {
28011 (char *) "self",(char *) "win", NULL
28012 };
28013
28014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28016 if (!SWIG_IsOK(res1)) {
28017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28018 }
28019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28021 if (!SWIG_IsOK(res2)) {
28022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28023 }
28024 arg2 = reinterpret_cast< wxWindow * >(argp2);
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 (arg1)->SetTopWindow(arg2);
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 resultobj = SWIG_Py_Void();
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28039 PyObject *resultobj = 0;
28040 wxPyApp *arg1 = (wxPyApp *) 0 ;
28041 wxWindow *result = 0 ;
28042 void *argp1 = 0 ;
28043 int res1 = 0 ;
28044 PyObject *swig_obj[1] ;
28045
28046 if (!args) SWIG_fail;
28047 swig_obj[0] = args;
28048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28049 if (!SWIG_IsOK(res1)) {
28050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28051 }
28052 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 {
28060 resultobj = wxPyMake_wxObject(result, (bool)0);
28061 }
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28069 PyObject *resultobj = 0;
28070 wxPyApp *arg1 = (wxPyApp *) 0 ;
28071 bool arg2 ;
28072 void *argp1 = 0 ;
28073 int res1 = 0 ;
28074 bool val2 ;
28075 int ecode2 = 0 ;
28076 PyObject * obj0 = 0 ;
28077 PyObject * obj1 = 0 ;
28078 char * kwnames[] = {
28079 (char *) "self",(char *) "flag", NULL
28080 };
28081
28082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28084 if (!SWIG_IsOK(res1)) {
28085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28086 }
28087 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28089 if (!SWIG_IsOK(ecode2)) {
28090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28091 }
28092 arg2 = static_cast< bool >(val2);
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 (arg1)->SetExitOnFrameDelete(arg2);
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 resultobj = SWIG_Py_Void();
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28107 PyObject *resultobj = 0;
28108 wxPyApp *arg1 = (wxPyApp *) 0 ;
28109 bool result;
28110 void *argp1 = 0 ;
28111 int res1 = 0 ;
28112 PyObject *swig_obj[1] ;
28113
28114 if (!args) SWIG_fail;
28115 swig_obj[0] = args;
28116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28117 if (!SWIG_IsOK(res1)) {
28118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28119 }
28120 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 {
28128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28129 }
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28137 PyObject *resultobj = 0;
28138 wxPyApp *arg1 = (wxPyApp *) 0 ;
28139 bool arg2 ;
28140 void *argp1 = 0 ;
28141 int res1 = 0 ;
28142 bool val2 ;
28143 int ecode2 = 0 ;
28144 PyObject * obj0 = 0 ;
28145 PyObject * obj1 = 0 ;
28146 char * kwnames[] = {
28147 (char *) "self",(char *) "flag", NULL
28148 };
28149
28150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28152 if (!SWIG_IsOK(res1)) {
28153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28154 }
28155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28157 if (!SWIG_IsOK(ecode2)) {
28158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28159 }
28160 arg2 = static_cast< bool >(val2);
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 (arg1)->SetUseBestVisual(arg2);
28164 wxPyEndAllowThreads(__tstate);
28165 if (PyErr_Occurred()) SWIG_fail;
28166 }
28167 resultobj = SWIG_Py_Void();
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28175 PyObject *resultobj = 0;
28176 wxPyApp *arg1 = (wxPyApp *) 0 ;
28177 bool result;
28178 void *argp1 = 0 ;
28179 int res1 = 0 ;
28180 PyObject *swig_obj[1] ;
28181
28182 if (!args) SWIG_fail;
28183 swig_obj[0] = args;
28184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28185 if (!SWIG_IsOK(res1)) {
28186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28187 }
28188 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 {
28196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28197 }
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28205 PyObject *resultobj = 0;
28206 wxPyApp *arg1 = (wxPyApp *) 0 ;
28207 int arg2 ;
28208 void *argp1 = 0 ;
28209 int res1 = 0 ;
28210 int val2 ;
28211 int ecode2 = 0 ;
28212 PyObject * obj0 = 0 ;
28213 PyObject * obj1 = 0 ;
28214 char * kwnames[] = {
28215 (char *) "self",(char *) "mode", NULL
28216 };
28217
28218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28220 if (!SWIG_IsOK(res1)) {
28221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28222 }
28223 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28224 ecode2 = SWIG_AsVal_int(obj1, &val2);
28225 if (!SWIG_IsOK(ecode2)) {
28226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28227 }
28228 arg2 = static_cast< int >(val2);
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 (arg1)->SetPrintMode(arg2);
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_Py_Void();
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *resultobj = 0;
28244 wxPyApp *arg1 = (wxPyApp *) 0 ;
28245 int result;
28246 void *argp1 = 0 ;
28247 int res1 = 0 ;
28248 PyObject *swig_obj[1] ;
28249
28250 if (!args) SWIG_fail;
28251 swig_obj[0] = args;
28252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28253 if (!SWIG_IsOK(res1)) {
28254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28255 }
28256 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 resultobj = SWIG_From_int(static_cast< int >(result));
28264 return resultobj;
28265 fail:
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28271 PyObject *resultobj = 0;
28272 wxPyApp *arg1 = (wxPyApp *) 0 ;
28273 int arg2 ;
28274 void *argp1 = 0 ;
28275 int res1 = 0 ;
28276 int val2 ;
28277 int ecode2 = 0 ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 char * kwnames[] = {
28281 (char *) "self",(char *) "mode", NULL
28282 };
28283
28284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28286 if (!SWIG_IsOK(res1)) {
28287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28288 }
28289 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28290 ecode2 = SWIG_AsVal_int(obj1, &val2);
28291 if (!SWIG_IsOK(ecode2)) {
28292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28293 }
28294 arg2 = static_cast< int >(val2);
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 (arg1)->SetAssertMode(arg2);
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 resultobj = SWIG_Py_Void();
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28309 PyObject *resultobj = 0;
28310 wxPyApp *arg1 = (wxPyApp *) 0 ;
28311 int result;
28312 void *argp1 = 0 ;
28313 int res1 = 0 ;
28314 PyObject *swig_obj[1] ;
28315
28316 if (!args) SWIG_fail;
28317 swig_obj[0] = args;
28318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28319 if (!SWIG_IsOK(res1)) {
28320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28321 }
28322 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (int)(arg1)->GetAssertMode();
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_From_int(static_cast< int >(result));
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *resultobj = 0;
28338 bool result;
28339
28340 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 {
28348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28349 }
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28357 PyObject *resultobj = 0;
28358 long result;
28359
28360 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28361 {
28362 PyThreadState* __tstate = wxPyBeginAllowThreads();
28363 result = (long)wxPyApp::GetMacAboutMenuItemId();
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 resultobj = SWIG_From_long(static_cast< long >(result));
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28375 PyObject *resultobj = 0;
28376 long result;
28377
28378 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28379 {
28380 PyThreadState* __tstate = wxPyBeginAllowThreads();
28381 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 resultobj = SWIG_From_long(static_cast< long >(result));
28386 return resultobj;
28387 fail:
28388 return NULL;
28389 }
28390
28391
28392 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28393 PyObject *resultobj = 0;
28394 long result;
28395
28396 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28397 {
28398 PyThreadState* __tstate = wxPyBeginAllowThreads();
28399 result = (long)wxPyApp::GetMacExitMenuItemId();
28400 wxPyEndAllowThreads(__tstate);
28401 if (PyErr_Occurred()) SWIG_fail;
28402 }
28403 resultobj = SWIG_From_long(static_cast< long >(result));
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28411 PyObject *resultobj = 0;
28412 wxString result;
28413
28414 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = wxPyApp::GetMacHelpMenuTitleName();
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 #if wxUSE_UNICODE
28423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28424 #else
28425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28426 #endif
28427 }
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28435 PyObject *resultobj = 0;
28436 bool arg1 ;
28437 bool val1 ;
28438 int ecode1 = 0 ;
28439 PyObject * obj0 = 0 ;
28440 char * kwnames[] = {
28441 (char *) "val", NULL
28442 };
28443
28444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28445 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28446 if (!SWIG_IsOK(ecode1)) {
28447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28448 }
28449 arg1 = static_cast< bool >(val1);
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_Py_Void();
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28464 PyObject *resultobj = 0;
28465 long arg1 ;
28466 long val1 ;
28467 int ecode1 = 0 ;
28468 PyObject * obj0 = 0 ;
28469 char * kwnames[] = {
28470 (char *) "val", NULL
28471 };
28472
28473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28474 ecode1 = SWIG_AsVal_long(obj0, &val1);
28475 if (!SWIG_IsOK(ecode1)) {
28476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28477 }
28478 arg1 = static_cast< long >(val1);
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 wxPyApp::SetMacAboutMenuItemId(arg1);
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_Py_Void();
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28493 PyObject *resultobj = 0;
28494 long arg1 ;
28495 long val1 ;
28496 int ecode1 = 0 ;
28497 PyObject * obj0 = 0 ;
28498 char * kwnames[] = {
28499 (char *) "val", NULL
28500 };
28501
28502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28503 ecode1 = SWIG_AsVal_long(obj0, &val1);
28504 if (!SWIG_IsOK(ecode1)) {
28505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28506 }
28507 arg1 = static_cast< long >(val1);
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 resultobj = SWIG_Py_Void();
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj = 0;
28523 long arg1 ;
28524 long val1 ;
28525 int ecode1 = 0 ;
28526 PyObject * obj0 = 0 ;
28527 char * kwnames[] = {
28528 (char *) "val", NULL
28529 };
28530
28531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28532 ecode1 = SWIG_AsVal_long(obj0, &val1);
28533 if (!SWIG_IsOK(ecode1)) {
28534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28535 }
28536 arg1 = static_cast< long >(val1);
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 wxPyApp::SetMacExitMenuItemId(arg1);
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_Py_Void();
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj = 0;
28552 wxString *arg1 = 0 ;
28553 bool temp1 = false ;
28554 PyObject * obj0 = 0 ;
28555 char * kwnames[] = {
28556 (char *) "val", NULL
28557 };
28558
28559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28560 {
28561 arg1 = wxString_in_helper(obj0);
28562 if (arg1 == NULL) SWIG_fail;
28563 temp1 = true;
28564 }
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 resultobj = SWIG_Py_Void();
28572 {
28573 if (temp1)
28574 delete arg1;
28575 }
28576 return resultobj;
28577 fail:
28578 {
28579 if (temp1)
28580 delete arg1;
28581 }
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *resultobj = 0;
28588 wxPyApp *arg1 = (wxPyApp *) 0 ;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28598 }
28599 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 (arg1)->_BootstrapApp();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 resultobj = SWIG_Py_Void();
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28614 PyObject *resultobj = 0;
28615 int result;
28616
28617 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 result = (int)wxPyApp_GetComCtl32Version();
28621 wxPyEndAllowThreads(__tstate);
28622 if (PyErr_Occurred()) SWIG_fail;
28623 }
28624 resultobj = SWIG_From_int(static_cast< int >(result));
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *resultobj = 0;
28633 bool result;
28634
28635 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (bool)wxPyApp_IsDisplayAvailable();
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 {
28643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28644 }
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28652 PyObject *obj;
28653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28654 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28655 return SWIG_Py_Void();
28656 }
28657
28658 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28659 return SWIG_Python_InitShadowInstance(args);
28660 }
28661
28662 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28663 PyObject *resultobj = 0;
28664
28665 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 wxExit();
28669 wxPyEndAllowThreads(__tstate);
28670 if (PyErr_Occurred()) SWIG_fail;
28671 }
28672 resultobj = SWIG_Py_Void();
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28680 PyObject *resultobj = 0;
28681 bool result;
28682
28683 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 result = (bool)wxYield();
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 {
28691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 bool result;
28702
28703 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = (bool)wxYieldIfNeeded();
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 {
28711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28712 }
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj = 0;
28721 wxWindow *arg1 = (wxWindow *) NULL ;
28722 bool arg2 = (bool) false ;
28723 bool result;
28724 void *argp1 = 0 ;
28725 int res1 = 0 ;
28726 bool val2 ;
28727 int ecode2 = 0 ;
28728 PyObject * obj0 = 0 ;
28729 PyObject * obj1 = 0 ;
28730 char * kwnames[] = {
28731 (char *) "win",(char *) "onlyIfNeeded", NULL
28732 };
28733
28734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28735 if (obj0) {
28736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28737 if (!SWIG_IsOK(res1)) {
28738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28739 }
28740 arg1 = reinterpret_cast< wxWindow * >(argp1);
28741 }
28742 if (obj1) {
28743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28744 if (!SWIG_IsOK(ecode2)) {
28745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28746 }
28747 arg2 = static_cast< bool >(val2);
28748 }
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (bool)wxSafeYield(arg1,arg2);
28752 wxPyEndAllowThreads(__tstate);
28753 if (PyErr_Occurred()) SWIG_fail;
28754 }
28755 {
28756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28757 }
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766
28767 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 wxWakeUpIdle();
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 resultobj = SWIG_Py_Void();
28775 return resultobj;
28776 fail:
28777 return NULL;
28778 }
28779
28780
28781 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28782 PyObject *resultobj = 0;
28783 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28784 wxEvent *arg2 = 0 ;
28785 void *argp1 = 0 ;
28786 int res1 = 0 ;
28787 void *argp2 = 0 ;
28788 int res2 = 0 ;
28789 PyObject * obj0 = 0 ;
28790 PyObject * obj1 = 0 ;
28791 char * kwnames[] = {
28792 (char *) "dest",(char *) "event", NULL
28793 };
28794
28795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28797 if (!SWIG_IsOK(res1)) {
28798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28799 }
28800 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28802 if (!SWIG_IsOK(res2)) {
28803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28804 }
28805 if (!argp2) {
28806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28807 }
28808 arg2 = reinterpret_cast< wxEvent * >(argp2);
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 wxPostEvent(arg1,*arg2);
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 resultobj = SWIG_Py_Void();
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28823 PyObject *resultobj = 0;
28824
28825 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 wxApp_CleanUp();
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 resultobj = SWIG_Py_Void();
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28840 PyObject *resultobj = 0;
28841 wxPyApp *result = 0 ;
28842
28843 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (wxPyApp *)wxPyGetApp();
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 {
28851 resultobj = wxPyMake_wxObject(result, 0);
28852 }
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28860 PyObject *resultobj = 0;
28861 char *arg1 = (char *) 0 ;
28862 int res1 ;
28863 char *buf1 = 0 ;
28864 int alloc1 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 char * kwnames[] = {
28867 (char *) "encoding", NULL
28868 };
28869
28870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28871 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28874 }
28875 arg1 = buf1;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 wxSetDefaultPyEncoding((char const *)arg1);
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_Py_Void();
28883 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28884 return resultobj;
28885 fail:
28886 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28892 PyObject *resultobj = 0;
28893 char *result = 0 ;
28894
28895 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 result = (char *)wxGetDefaultPyEncoding();
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_FromCharPtr(result);
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28910 PyObject *resultobj = 0;
28911 wxEventLoop *result = 0 ;
28912
28913 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 result = (wxEventLoop *)new wxEventLoop();
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 PyObject *swig_obj[1] ;
28933
28934 if (!args) SWIG_fail;
28935 swig_obj[0] = args;
28936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28937 if (!SWIG_IsOK(res1)) {
28938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28939 }
28940 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 delete arg1;
28944
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 resultobj = SWIG_Py_Void();
28949 return resultobj;
28950 fail:
28951 return NULL;
28952 }
28953
28954
28955 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28956 PyObject *resultobj = 0;
28957 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28958 int result;
28959 void *argp1 = 0 ;
28960 int res1 = 0 ;
28961 PyObject *swig_obj[1] ;
28962
28963 if (!args) SWIG_fail;
28964 swig_obj[0] = args;
28965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28966 if (!SWIG_IsOK(res1)) {
28967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28968 }
28969 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (int)(arg1)->Run();
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 resultobj = SWIG_From_int(static_cast< int >(result));
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28986 int arg2 = (int) 0 ;
28987 void *argp1 = 0 ;
28988 int res1 = 0 ;
28989 int val2 ;
28990 int ecode2 = 0 ;
28991 PyObject * obj0 = 0 ;
28992 PyObject * obj1 = 0 ;
28993 char * kwnames[] = {
28994 (char *) "self",(char *) "rc", NULL
28995 };
28996
28997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28999 if (!SWIG_IsOK(res1)) {
29000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29001 }
29002 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29003 if (obj1) {
29004 ecode2 = SWIG_AsVal_int(obj1, &val2);
29005 if (!SWIG_IsOK(ecode2)) {
29006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29007 }
29008 arg2 = static_cast< int >(val2);
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 (arg1)->Exit(arg2);
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_Py_Void();
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 PyObject *resultobj = 0;
29025 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29026 bool result;
29027 void *argp1 = 0 ;
29028 int res1 = 0 ;
29029 PyObject *swig_obj[1] ;
29030
29031 if (!args) SWIG_fail;
29032 swig_obj[0] = args;
29033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29034 if (!SWIG_IsOK(res1)) {
29035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29036 }
29037 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (bool)((wxEventLoop const *)arg1)->Pending();
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 {
29045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29046 }
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29054 PyObject *resultobj = 0;
29055 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29056 bool result;
29057 void *argp1 = 0 ;
29058 int res1 = 0 ;
29059 PyObject *swig_obj[1] ;
29060
29061 if (!args) SWIG_fail;
29062 swig_obj[0] = args;
29063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29064 if (!SWIG_IsOK(res1)) {
29065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29066 }
29067 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = (bool)(arg1)->Dispatch();
29071 wxPyEndAllowThreads(__tstate);
29072 if (PyErr_Occurred()) SWIG_fail;
29073 }
29074 {
29075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29076 }
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29084 PyObject *resultobj = 0;
29085 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29086 bool result;
29087 void *argp1 = 0 ;
29088 int res1 = 0 ;
29089 PyObject *swig_obj[1] ;
29090
29091 if (!args) SWIG_fail;
29092 swig_obj[0] = args;
29093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29096 }
29097 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 {
29105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29106 }
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29114 PyObject *resultobj = 0;
29115 wxEventLoop *result = 0 ;
29116
29117 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29118 {
29119 PyThreadState* __tstate = wxPyBeginAllowThreads();
29120 result = (wxEventLoop *)wxEventLoop::GetActive();
29121 wxPyEndAllowThreads(__tstate);
29122 if (PyErr_Occurred()) SWIG_fail;
29123 }
29124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29125 return resultobj;
29126 fail:
29127 return NULL;
29128 }
29129
29130
29131 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj = 0;
29133 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29134 void *argp1 = 0 ;
29135 int res1 = 0 ;
29136 PyObject * obj0 = 0 ;
29137 char * kwnames[] = {
29138 (char *) "loop", NULL
29139 };
29140
29141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29143 if (!SWIG_IsOK(res1)) {
29144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29145 }
29146 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 wxEventLoop::SetActive(arg1);
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_Py_Void();
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29161 PyObject *obj;
29162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29163 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29164 return SWIG_Py_Void();
29165 }
29166
29167 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 return SWIG_Python_InitShadowInstance(args);
29169 }
29170
29171 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29172 PyObject *resultobj = 0;
29173 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29174 wxEventLoopActivator *result = 0 ;
29175 void *argp1 = 0 ;
29176 int res1 = 0 ;
29177 PyObject * obj0 = 0 ;
29178 char * kwnames[] = {
29179 (char *) "evtLoop", NULL
29180 };
29181
29182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29184 if (!SWIG_IsOK(res1)) {
29185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29186 }
29187 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29202 PyObject *resultobj = 0;
29203 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29204 void *argp1 = 0 ;
29205 int res1 = 0 ;
29206 PyObject *swig_obj[1] ;
29207
29208 if (!args) SWIG_fail;
29209 swig_obj[0] = args;
29210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29211 if (!SWIG_IsOK(res1)) {
29212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29213 }
29214 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 delete arg1;
29218
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 resultobj = SWIG_Py_Void();
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29230 PyObject *obj;
29231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29232 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29233 return SWIG_Py_Void();
29234 }
29235
29236 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29237 return SWIG_Python_InitShadowInstance(args);
29238 }
29239
29240 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29241 PyObject *resultobj = 0;
29242 int arg1 = (int) 0 ;
29243 int arg2 = (int) 0 ;
29244 int arg3 = (int) 0 ;
29245 wxAcceleratorEntry *result = 0 ;
29246 int val1 ;
29247 int ecode1 = 0 ;
29248 int val2 ;
29249 int ecode2 = 0 ;
29250 int val3 ;
29251 int ecode3 = 0 ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 PyObject * obj2 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29260 if (obj0) {
29261 ecode1 = SWIG_AsVal_int(obj0, &val1);
29262 if (!SWIG_IsOK(ecode1)) {
29263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29264 }
29265 arg1 = static_cast< int >(val1);
29266 }
29267 if (obj1) {
29268 ecode2 = SWIG_AsVal_int(obj1, &val2);
29269 if (!SWIG_IsOK(ecode2)) {
29270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29271 }
29272 arg2 = static_cast< int >(val2);
29273 }
29274 if (obj2) {
29275 ecode3 = SWIG_AsVal_int(obj2, &val3);
29276 if (!SWIG_IsOK(ecode3)) {
29277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29278 }
29279 arg3 = static_cast< int >(val3);
29280 }
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29295 PyObject *resultobj = 0;
29296 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29297 void *argp1 = 0 ;
29298 int res1 = 0 ;
29299 PyObject *swig_obj[1] ;
29300
29301 if (!args) SWIG_fail;
29302 swig_obj[0] = args;
29303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29306 }
29307 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 delete arg1;
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 resultobj = SWIG_Py_Void();
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj = 0;
29324 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29325 int arg2 ;
29326 int arg3 ;
29327 int arg4 ;
29328 void *argp1 = 0 ;
29329 int res1 = 0 ;
29330 int val2 ;
29331 int ecode2 = 0 ;
29332 int val3 ;
29333 int ecode3 = 0 ;
29334 int val4 ;
29335 int ecode4 = 0 ;
29336 PyObject * obj0 = 0 ;
29337 PyObject * obj1 = 0 ;
29338 PyObject * obj2 = 0 ;
29339 PyObject * obj3 = 0 ;
29340 char * kwnames[] = {
29341 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29342 };
29343
29344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29346 if (!SWIG_IsOK(res1)) {
29347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29348 }
29349 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29350 ecode2 = SWIG_AsVal_int(obj1, &val2);
29351 if (!SWIG_IsOK(ecode2)) {
29352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29353 }
29354 arg2 = static_cast< int >(val2);
29355 ecode3 = SWIG_AsVal_int(obj2, &val3);
29356 if (!SWIG_IsOK(ecode3)) {
29357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29358 }
29359 arg3 = static_cast< int >(val3);
29360 ecode4 = SWIG_AsVal_int(obj3, &val4);
29361 if (!SWIG_IsOK(ecode4)) {
29362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29363 }
29364 arg4 = static_cast< int >(val4);
29365 {
29366 PyThreadState* __tstate = wxPyBeginAllowThreads();
29367 (arg1)->Set(arg2,arg3,arg4);
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 resultobj = SWIG_Py_Void();
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj = 0;
29380 wxString *arg1 = 0 ;
29381 wxAcceleratorEntry *result = 0 ;
29382 bool temp1 = false ;
29383 PyObject * obj0 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "str", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29389 {
29390 arg1 = wxString_in_helper(obj0);
29391 if (arg1 == NULL) SWIG_fail;
29392 temp1 = true;
29393 }
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29401 {
29402 if (temp1)
29403 delete arg1;
29404 }
29405 return resultobj;
29406 fail:
29407 {
29408 if (temp1)
29409 delete arg1;
29410 }
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29418 int result;
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_wxAcceleratorEntry, 0 | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29428 }
29429 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (int)(arg1)->GetFlags();
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 resultobj = SWIG_From_int(static_cast< int >(result));
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29444 PyObject *resultobj = 0;
29445 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29446 int result;
29447 void *argp1 = 0 ;
29448 int res1 = 0 ;
29449 PyObject *swig_obj[1] ;
29450
29451 if (!args) SWIG_fail;
29452 swig_obj[0] = args;
29453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29454 if (!SWIG_IsOK(res1)) {
29455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29456 }
29457 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = (int)(arg1)->GetKeyCode();
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 resultobj = SWIG_From_int(static_cast< int >(result));
29465 return resultobj;
29466 fail:
29467 return NULL;
29468 }
29469
29470
29471 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29472 PyObject *resultobj = 0;
29473 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29474 int result;
29475 void *argp1 = 0 ;
29476 int res1 = 0 ;
29477 PyObject *swig_obj[1] ;
29478
29479 if (!args) SWIG_fail;
29480 swig_obj[0] = args;
29481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29482 if (!SWIG_IsOK(res1)) {
29483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29484 }
29485 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 result = (int)(arg1)->GetCommand();
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 resultobj = SWIG_From_int(static_cast< int >(result));
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29500 PyObject *resultobj = 0;
29501 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29502 bool result;
29503 void *argp1 = 0 ;
29504 int res1 = 0 ;
29505 PyObject *swig_obj[1] ;
29506
29507 if (!args) SWIG_fail;
29508 swig_obj[0] = args;
29509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29510 if (!SWIG_IsOK(res1)) {
29511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29512 }
29513 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29530 PyObject *resultobj = 0;
29531 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29532 wxString result;
29533 void *argp1 = 0 ;
29534 int res1 = 0 ;
29535 PyObject *swig_obj[1] ;
29536
29537 if (!args) SWIG_fail;
29538 swig_obj[0] = args;
29539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29542 }
29543 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 {
29551 #if wxUSE_UNICODE
29552 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29553 #else
29554 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29555 #endif
29556 }
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj = 0;
29565 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29566 wxString *arg2 = 0 ;
29567 bool result;
29568 void *argp1 = 0 ;
29569 int res1 = 0 ;
29570 bool temp2 = false ;
29571 PyObject * obj0 = 0 ;
29572 PyObject * obj1 = 0 ;
29573 char * kwnames[] = {
29574 (char *) "self",(char *) "str", NULL
29575 };
29576
29577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29579 if (!SWIG_IsOK(res1)) {
29580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29581 }
29582 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29583 {
29584 arg2 = wxString_in_helper(obj1);
29585 if (arg2 == NULL) SWIG_fail;
29586 temp2 = true;
29587 }
29588 {
29589 PyThreadState* __tstate = wxPyBeginAllowThreads();
29590 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29591 wxPyEndAllowThreads(__tstate);
29592 if (PyErr_Occurred()) SWIG_fail;
29593 }
29594 {
29595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29596 }
29597 {
29598 if (temp2)
29599 delete arg2;
29600 }
29601 return resultobj;
29602 fail:
29603 {
29604 if (temp2)
29605 delete arg2;
29606 }
29607 return NULL;
29608 }
29609
29610
29611 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29612 PyObject *obj;
29613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29614 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29615 return SWIG_Py_Void();
29616 }
29617
29618 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29619 return SWIG_Python_InitShadowInstance(args);
29620 }
29621
29622 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29623 PyObject *resultobj = 0;
29624 int arg1 ;
29625 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29626 wxAcceleratorTable *result = 0 ;
29627 PyObject * obj0 = 0 ;
29628 char * kwnames[] = {
29629 (char *) "n", NULL
29630 };
29631
29632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29633 {
29634 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29635 if (arg2) arg1 = PyList_Size(obj0);
29636 else arg1 = 0;
29637 }
29638 {
29639 PyThreadState* __tstate = wxPyBeginAllowThreads();
29640 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29641 wxPyEndAllowThreads(__tstate);
29642 if (PyErr_Occurred()) SWIG_fail;
29643 }
29644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29645 return resultobj;
29646 fail:
29647 return NULL;
29648 }
29649
29650
29651 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652 PyObject *resultobj = 0;
29653 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29654 void *argp1 = 0 ;
29655 int res1 = 0 ;
29656 PyObject *swig_obj[1] ;
29657
29658 if (!args) SWIG_fail;
29659 swig_obj[0] = args;
29660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29661 if (!SWIG_IsOK(res1)) {
29662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29663 }
29664 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29665 {
29666 PyThreadState* __tstate = wxPyBeginAllowThreads();
29667 delete arg1;
29668
29669 wxPyEndAllowThreads(__tstate);
29670 if (PyErr_Occurred()) SWIG_fail;
29671 }
29672 resultobj = SWIG_Py_Void();
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 PyObject *resultobj = 0;
29681 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29682 bool result;
29683 void *argp1 = 0 ;
29684 int res1 = 0 ;
29685 PyObject *swig_obj[1] ;
29686
29687 if (!args) SWIG_fail;
29688 swig_obj[0] = args;
29689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29690 if (!SWIG_IsOK(res1)) {
29691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29692 }
29693 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29710 PyObject *obj;
29711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29712 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29713 return SWIG_Py_Void();
29714 }
29715
29716 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29717 return SWIG_Python_InitShadowInstance(args);
29718 }
29719
29720 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29721 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29722 return 1;
29723 }
29724
29725
29726 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29727 PyObject *pyobj = 0;
29728
29729 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29730 return pyobj;
29731 }
29732
29733
29734 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29735 PyObject *resultobj = 0;
29736 wxString *arg1 = 0 ;
29737 wxAcceleratorEntry *result = 0 ;
29738 bool temp1 = false ;
29739 PyObject * obj0 = 0 ;
29740 char * kwnames[] = {
29741 (char *) "label", NULL
29742 };
29743
29744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29745 {
29746 arg1 = wxString_in_helper(obj0);
29747 if (arg1 == NULL) SWIG_fail;
29748 temp1 = true;
29749 }
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29757 {
29758 if (temp1)
29759 delete arg1;
29760 }
29761 return resultobj;
29762 fail:
29763 {
29764 if (temp1)
29765 delete arg1;
29766 }
29767 return NULL;
29768 }
29769
29770
29771 SWIGINTERN int PanelNameStr_set(PyObject *) {
29772 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29773 return 1;
29774 }
29775
29776
29777 SWIGINTERN PyObject *PanelNameStr_get(void) {
29778 PyObject *pyobj = 0;
29779
29780 {
29781 #if wxUSE_UNICODE
29782 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29783 #else
29784 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29785 #endif
29786 }
29787 return pyobj;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29792 PyObject *resultobj = 0;
29793 wxVisualAttributes *result = 0 ;
29794
29795 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (wxVisualAttributes *)new_wxVisualAttributes();
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29812 void *argp1 = 0 ;
29813 int res1 = 0 ;
29814 PyObject *swig_obj[1] ;
29815
29816 if (!args) SWIG_fail;
29817 swig_obj[0] = args;
29818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29821 }
29822 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 delete_wxVisualAttributes(arg1);
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 resultobj = SWIG_Py_Void();
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29838 PyObject *resultobj = 0;
29839 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29840 wxFont *arg2 = (wxFont *) 0 ;
29841 void *argp1 = 0 ;
29842 int res1 = 0 ;
29843 void *argp2 = 0 ;
29844 int res2 = 0 ;
29845 PyObject *swig_obj[2] ;
29846
29847 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29851 }
29852 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29853 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29854 if (!SWIG_IsOK(res2)) {
29855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29856 }
29857 arg2 = reinterpret_cast< wxFont * >(argp2);
29858 if (arg1) (arg1)->font = *arg2;
29859
29860 resultobj = SWIG_Py_Void();
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29868 PyObject *resultobj = 0;
29869 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29870 wxFont *result = 0 ;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 PyObject *swig_obj[1] ;
29874
29875 if (!args) SWIG_fail;
29876 swig_obj[0] = args;
29877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29878 if (!SWIG_IsOK(res1)) {
29879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29880 }
29881 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29882 result = (wxFont *)& ((arg1)->font);
29883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 PyObject *resultobj = 0;
29892 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29893 wxColour *arg2 = (wxColour *) 0 ;
29894 void *argp1 = 0 ;
29895 int res1 = 0 ;
29896 void *argp2 = 0 ;
29897 int res2 = 0 ;
29898 PyObject *swig_obj[2] ;
29899
29900 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29904 }
29905 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29906 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29907 if (!SWIG_IsOK(res2)) {
29908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29909 }
29910 arg2 = reinterpret_cast< wxColour * >(argp2);
29911 if (arg1) (arg1)->colFg = *arg2;
29912
29913 resultobj = SWIG_Py_Void();
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29921 PyObject *resultobj = 0;
29922 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29923 wxColour *result = 0 ;
29924 void *argp1 = 0 ;
29925 int res1 = 0 ;
29926 PyObject *swig_obj[1] ;
29927
29928 if (!args) SWIG_fail;
29929 swig_obj[0] = args;
29930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29931 if (!SWIG_IsOK(res1)) {
29932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29933 }
29934 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29935 result = (wxColour *)& ((arg1)->colFg);
29936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29944 PyObject *resultobj = 0;
29945 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29946 wxColour *arg2 = (wxColour *) 0 ;
29947 void *argp1 = 0 ;
29948 int res1 = 0 ;
29949 void *argp2 = 0 ;
29950 int res2 = 0 ;
29951 PyObject *swig_obj[2] ;
29952
29953 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29955 if (!SWIG_IsOK(res1)) {
29956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29957 }
29958 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29959 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29960 if (!SWIG_IsOK(res2)) {
29961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29962 }
29963 arg2 = reinterpret_cast< wxColour * >(argp2);
29964 if (arg1) (arg1)->colBg = *arg2;
29965
29966 resultobj = SWIG_Py_Void();
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29974 PyObject *resultobj = 0;
29975 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29976 wxColour *result = 0 ;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29986 }
29987 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29988 result = (wxColour *)& ((arg1)->colBg);
29989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29997 PyObject *obj;
29998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29999 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30000 return SWIG_Py_Void();
30001 }
30002
30003 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30004 return SWIG_Python_InitShadowInstance(args);
30005 }
30006
30007 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj = 0;
30009 wxWindow *arg1 = (wxWindow *) 0 ;
30010 int arg2 = (int) (int)-1 ;
30011 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30012 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30013 wxSize const &arg4_defvalue = wxDefaultSize ;
30014 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30015 long arg5 = (long) 0 ;
30016 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30017 wxString *arg6 = (wxString *) &arg6_defvalue ;
30018 wxWindow *result = 0 ;
30019 void *argp1 = 0 ;
30020 int res1 = 0 ;
30021 int val2 ;
30022 int ecode2 = 0 ;
30023 wxPoint temp3 ;
30024 wxSize temp4 ;
30025 long val5 ;
30026 int ecode5 = 0 ;
30027 bool temp6 = false ;
30028 PyObject * obj0 = 0 ;
30029 PyObject * obj1 = 0 ;
30030 PyObject * obj2 = 0 ;
30031 PyObject * obj3 = 0 ;
30032 PyObject * obj4 = 0 ;
30033 PyObject * obj5 = 0 ;
30034 char * kwnames[] = {
30035 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30036 };
30037
30038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30042 }
30043 arg1 = reinterpret_cast< wxWindow * >(argp1);
30044 if (obj1) {
30045 ecode2 = SWIG_AsVal_int(obj1, &val2);
30046 if (!SWIG_IsOK(ecode2)) {
30047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30048 }
30049 arg2 = static_cast< int >(val2);
30050 }
30051 if (obj2) {
30052 {
30053 arg3 = &temp3;
30054 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30055 }
30056 }
30057 if (obj3) {
30058 {
30059 arg4 = &temp4;
30060 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30061 }
30062 }
30063 if (obj4) {
30064 ecode5 = SWIG_AsVal_long(obj4, &val5);
30065 if (!SWIG_IsOK(ecode5)) {
30066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30067 }
30068 arg5 = static_cast< long >(val5);
30069 }
30070 if (obj5) {
30071 {
30072 arg6 = wxString_in_helper(obj5);
30073 if (arg6 == NULL) SWIG_fail;
30074 temp6 = true;
30075 }
30076 }
30077 {
30078 if (!wxPyCheckForApp()) SWIG_fail;
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30085 {
30086 if (temp6)
30087 delete arg6;
30088 }
30089 return resultobj;
30090 fail:
30091 {
30092 if (temp6)
30093 delete arg6;
30094 }
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 wxWindow *result = 0 ;
30102
30103 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30104 {
30105 if (!wxPyCheckForApp()) SWIG_fail;
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (wxWindow *)new wxWindow();
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxWindow *arg2 = (wxWindow *) 0 ;
30122 int arg3 = (int) (int)-1 ;
30123 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30124 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30125 wxSize const &arg5_defvalue = wxDefaultSize ;
30126 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30127 long arg6 = (long) 0 ;
30128 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30129 wxString *arg7 = (wxString *) &arg7_defvalue ;
30130 bool result;
30131 void *argp1 = 0 ;
30132 int res1 = 0 ;
30133 void *argp2 = 0 ;
30134 int res2 = 0 ;
30135 int val3 ;
30136 int ecode3 = 0 ;
30137 wxPoint temp4 ;
30138 wxSize temp5 ;
30139 long val6 ;
30140 int ecode6 = 0 ;
30141 bool temp7 = false ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 PyObject * obj2 = 0 ;
30145 PyObject * obj3 = 0 ;
30146 PyObject * obj4 = 0 ;
30147 PyObject * obj5 = 0 ;
30148 PyObject * obj6 = 0 ;
30149 char * kwnames[] = {
30150 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30151 };
30152
30153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30155 if (!SWIG_IsOK(res1)) {
30156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30157 }
30158 arg1 = reinterpret_cast< wxWindow * >(argp1);
30159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30160 if (!SWIG_IsOK(res2)) {
30161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30162 }
30163 arg2 = reinterpret_cast< wxWindow * >(argp2);
30164 if (obj2) {
30165 ecode3 = SWIG_AsVal_int(obj2, &val3);
30166 if (!SWIG_IsOK(ecode3)) {
30167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30168 }
30169 arg3 = static_cast< int >(val3);
30170 }
30171 if (obj3) {
30172 {
30173 arg4 = &temp4;
30174 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30175 }
30176 }
30177 if (obj4) {
30178 {
30179 arg5 = &temp5;
30180 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30181 }
30182 }
30183 if (obj5) {
30184 ecode6 = SWIG_AsVal_long(obj5, &val6);
30185 if (!SWIG_IsOK(ecode6)) {
30186 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30187 }
30188 arg6 = static_cast< long >(val6);
30189 }
30190 if (obj6) {
30191 {
30192 arg7 = wxString_in_helper(obj6);
30193 if (arg7 == NULL) SWIG_fail;
30194 temp7 = true;
30195 }
30196 }
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30200 wxPyEndAllowThreads(__tstate);
30201 if (PyErr_Occurred()) SWIG_fail;
30202 }
30203 {
30204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30205 }
30206 {
30207 if (temp7)
30208 delete arg7;
30209 }
30210 return resultobj;
30211 fail:
30212 {
30213 if (temp7)
30214 delete arg7;
30215 }
30216 return NULL;
30217 }
30218
30219
30220 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30221 PyObject *resultobj = 0;
30222 wxWindow *arg1 = (wxWindow *) 0 ;
30223 bool arg2 = (bool) false ;
30224 bool result;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 bool val2 ;
30228 int ecode2 = 0 ;
30229 PyObject * obj0 = 0 ;
30230 PyObject * obj1 = 0 ;
30231 char * kwnames[] = {
30232 (char *) "self",(char *) "force", NULL
30233 };
30234
30235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30237 if (!SWIG_IsOK(res1)) {
30238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30239 }
30240 arg1 = reinterpret_cast< wxWindow * >(argp1);
30241 if (obj1) {
30242 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30243 if (!SWIG_IsOK(ecode2)) {
30244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30245 }
30246 arg2 = static_cast< bool >(val2);
30247 }
30248 {
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 result = (bool)(arg1)->Close(arg2);
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 {
30255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30264 PyObject *resultobj = 0;
30265 wxWindow *arg1 = (wxWindow *) 0 ;
30266 bool result;
30267 void *argp1 = 0 ;
30268 int res1 = 0 ;
30269 PyObject *swig_obj[1] ;
30270
30271 if (!args) SWIG_fail;
30272 swig_obj[0] = args;
30273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30274 if (!SWIG_IsOK(res1)) {
30275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30276 }
30277 arg1 = reinterpret_cast< wxWindow * >(argp1);
30278 {
30279 PyThreadState* __tstate = wxPyBeginAllowThreads();
30280 result = (bool)(arg1)->Destroy();
30281 wxPyEndAllowThreads(__tstate);
30282 if (PyErr_Occurred()) SWIG_fail;
30283 }
30284 {
30285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30286 }
30287 return resultobj;
30288 fail:
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30294 PyObject *resultobj = 0;
30295 wxWindow *arg1 = (wxWindow *) 0 ;
30296 bool result;
30297 void *argp1 = 0 ;
30298 int res1 = 0 ;
30299 PyObject *swig_obj[1] ;
30300
30301 if (!args) SWIG_fail;
30302 swig_obj[0] = args;
30303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30304 if (!SWIG_IsOK(res1)) {
30305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30306 }
30307 arg1 = reinterpret_cast< wxWindow * >(argp1);
30308 {
30309 PyThreadState* __tstate = wxPyBeginAllowThreads();
30310 result = (bool)(arg1)->DestroyChildren();
30311 wxPyEndAllowThreads(__tstate);
30312 if (PyErr_Occurred()) SWIG_fail;
30313 }
30314 {
30315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30316 }
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30324 PyObject *resultobj = 0;
30325 wxWindow *arg1 = (wxWindow *) 0 ;
30326 bool result;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 PyObject *swig_obj[1] ;
30330
30331 if (!args) SWIG_fail;
30332 swig_obj[0] = args;
30333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30334 if (!SWIG_IsOK(res1)) {
30335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30336 }
30337 arg1 = reinterpret_cast< wxWindow * >(argp1);
30338 {
30339 PyThreadState* __tstate = wxPyBeginAllowThreads();
30340 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30341 wxPyEndAllowThreads(__tstate);
30342 if (PyErr_Occurred()) SWIG_fail;
30343 }
30344 {
30345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30346 }
30347 return resultobj;
30348 fail:
30349 return NULL;
30350 }
30351
30352
30353 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj = 0;
30355 wxWindow *arg1 = (wxWindow *) 0 ;
30356 wxString *arg2 = 0 ;
30357 void *argp1 = 0 ;
30358 int res1 = 0 ;
30359 bool temp2 = false ;
30360 PyObject * obj0 = 0 ;
30361 PyObject * obj1 = 0 ;
30362 char * kwnames[] = {
30363 (char *) "self",(char *) "label", NULL
30364 };
30365
30366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30368 if (!SWIG_IsOK(res1)) {
30369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30370 }
30371 arg1 = reinterpret_cast< wxWindow * >(argp1);
30372 {
30373 arg2 = wxString_in_helper(obj1);
30374 if (arg2 == NULL) SWIG_fail;
30375 temp2 = true;
30376 }
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 (arg1)->SetLabel((wxString const &)*arg2);
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 resultobj = SWIG_Py_Void();
30384 {
30385 if (temp2)
30386 delete arg2;
30387 }
30388 return resultobj;
30389 fail:
30390 {
30391 if (temp2)
30392 delete arg2;
30393 }
30394 return NULL;
30395 }
30396
30397
30398 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30399 PyObject *resultobj = 0;
30400 wxWindow *arg1 = (wxWindow *) 0 ;
30401 wxString result;
30402 void *argp1 = 0 ;
30403 int res1 = 0 ;
30404 PyObject *swig_obj[1] ;
30405
30406 if (!args) SWIG_fail;
30407 swig_obj[0] = args;
30408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30409 if (!SWIG_IsOK(res1)) {
30410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30411 }
30412 arg1 = reinterpret_cast< wxWindow * >(argp1);
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = ((wxWindow const *)arg1)->GetLabel();
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 {
30420 #if wxUSE_UNICODE
30421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30422 #else
30423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30424 #endif
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj = 0;
30434 wxWindow *arg1 = (wxWindow *) 0 ;
30435 wxString *arg2 = 0 ;
30436 void *argp1 = 0 ;
30437 int res1 = 0 ;
30438 bool temp2 = false ;
30439 PyObject * obj0 = 0 ;
30440 PyObject * obj1 = 0 ;
30441 char * kwnames[] = {
30442 (char *) "self",(char *) "name", NULL
30443 };
30444
30445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30447 if (!SWIG_IsOK(res1)) {
30448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30449 }
30450 arg1 = reinterpret_cast< wxWindow * >(argp1);
30451 {
30452 arg2 = wxString_in_helper(obj1);
30453 if (arg2 == NULL) SWIG_fail;
30454 temp2 = true;
30455 }
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 (arg1)->SetName((wxString const &)*arg2);
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_Py_Void();
30463 {
30464 if (temp2)
30465 delete arg2;
30466 }
30467 return resultobj;
30468 fail:
30469 {
30470 if (temp2)
30471 delete arg2;
30472 }
30473 return NULL;
30474 }
30475
30476
30477 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30478 PyObject *resultobj = 0;
30479 wxWindow *arg1 = (wxWindow *) 0 ;
30480 wxString result;
30481 void *argp1 = 0 ;
30482 int res1 = 0 ;
30483 PyObject *swig_obj[1] ;
30484
30485 if (!args) SWIG_fail;
30486 swig_obj[0] = args;
30487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30488 if (!SWIG_IsOK(res1)) {
30489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30490 }
30491 arg1 = reinterpret_cast< wxWindow * >(argp1);
30492 {
30493 PyThreadState* __tstate = wxPyBeginAllowThreads();
30494 result = ((wxWindow const *)arg1)->GetName();
30495 wxPyEndAllowThreads(__tstate);
30496 if (PyErr_Occurred()) SWIG_fail;
30497 }
30498 {
30499 #if wxUSE_UNICODE
30500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30501 #else
30502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30503 #endif
30504 }
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj = 0;
30513 wxWindow *arg1 = (wxWindow *) 0 ;
30514 wxWindowVariant arg2 ;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 int val2 ;
30518 int ecode2 = 0 ;
30519 PyObject * obj0 = 0 ;
30520 PyObject * obj1 = 0 ;
30521 char * kwnames[] = {
30522 (char *) "self",(char *) "variant", NULL
30523 };
30524
30525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30527 if (!SWIG_IsOK(res1)) {
30528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30529 }
30530 arg1 = reinterpret_cast< wxWindow * >(argp1);
30531 ecode2 = SWIG_AsVal_int(obj1, &val2);
30532 if (!SWIG_IsOK(ecode2)) {
30533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30534 }
30535 arg2 = static_cast< wxWindowVariant >(val2);
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 (arg1)->SetWindowVariant(arg2);
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 resultobj = SWIG_Py_Void();
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30550 PyObject *resultobj = 0;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 wxWindowVariant result;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 PyObject *swig_obj[1] ;
30556
30557 if (!args) SWIG_fail;
30558 swig_obj[0] = args;
30559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30562 }
30563 arg1 = reinterpret_cast< wxWindow * >(argp1);
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30567 wxPyEndAllowThreads(__tstate);
30568 if (PyErr_Occurred()) SWIG_fail;
30569 }
30570 resultobj = SWIG_From_int(static_cast< int >(result));
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj = 0;
30579 wxWindow *arg1 = (wxWindow *) 0 ;
30580 int arg2 ;
30581 void *argp1 = 0 ;
30582 int res1 = 0 ;
30583 int val2 ;
30584 int ecode2 = 0 ;
30585 PyObject * obj0 = 0 ;
30586 PyObject * obj1 = 0 ;
30587 char * kwnames[] = {
30588 (char *) "self",(char *) "winid", NULL
30589 };
30590
30591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30593 if (!SWIG_IsOK(res1)) {
30594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30595 }
30596 arg1 = reinterpret_cast< wxWindow * >(argp1);
30597 ecode2 = SWIG_AsVal_int(obj1, &val2);
30598 if (!SWIG_IsOK(ecode2)) {
30599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30600 }
30601 arg2 = static_cast< int >(val2);
30602 {
30603 PyThreadState* __tstate = wxPyBeginAllowThreads();
30604 (arg1)->SetId(arg2);
30605 wxPyEndAllowThreads(__tstate);
30606 if (PyErr_Occurred()) SWIG_fail;
30607 }
30608 resultobj = SWIG_Py_Void();
30609 return resultobj;
30610 fail:
30611 return NULL;
30612 }
30613
30614
30615 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30616 PyObject *resultobj = 0;
30617 wxWindow *arg1 = (wxWindow *) 0 ;
30618 int result;
30619 void *argp1 = 0 ;
30620 int res1 = 0 ;
30621 PyObject *swig_obj[1] ;
30622
30623 if (!args) SWIG_fail;
30624 swig_obj[0] = args;
30625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30626 if (!SWIG_IsOK(res1)) {
30627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30628 }
30629 arg1 = reinterpret_cast< wxWindow * >(argp1);
30630 {
30631 PyThreadState* __tstate = wxPyBeginAllowThreads();
30632 result = (int)((wxWindow const *)arg1)->GetId();
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 resultobj = SWIG_From_int(static_cast< int >(result));
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30644 PyObject *resultobj = 0;
30645 int result;
30646
30647 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 result = (int)wxWindow::NewControlId();
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 resultobj = SWIG_From_int(static_cast< int >(result));
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj = 0;
30663 int arg1 ;
30664 int result;
30665 int val1 ;
30666 int ecode1 = 0 ;
30667 PyObject * obj0 = 0 ;
30668 char * kwnames[] = {
30669 (char *) "winid", NULL
30670 };
30671
30672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30673 ecode1 = SWIG_AsVal_int(obj0, &val1);
30674 if (!SWIG_IsOK(ecode1)) {
30675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30676 }
30677 arg1 = static_cast< int >(val1);
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 result = (int)wxWindow::NextControlId(arg1);
30681 wxPyEndAllowThreads(__tstate);
30682 if (PyErr_Occurred()) SWIG_fail;
30683 }
30684 resultobj = SWIG_From_int(static_cast< int >(result));
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30692 PyObject *resultobj = 0;
30693 int arg1 ;
30694 int result;
30695 int val1 ;
30696 int ecode1 = 0 ;
30697 PyObject * obj0 = 0 ;
30698 char * kwnames[] = {
30699 (char *) "winid", NULL
30700 };
30701
30702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30703 ecode1 = SWIG_AsVal_int(obj0, &val1);
30704 if (!SWIG_IsOK(ecode1)) {
30705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30706 }
30707 arg1 = static_cast< int >(val1);
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (int)wxWindow::PrevControlId(arg1);
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_From_int(static_cast< int >(result));
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30722 PyObject *resultobj = 0;
30723 wxWindow *arg1 = (wxWindow *) 0 ;
30724 wxLayoutDirection result;
30725 void *argp1 = 0 ;
30726 int res1 = 0 ;
30727 PyObject *swig_obj[1] ;
30728
30729 if (!args) SWIG_fail;
30730 swig_obj[0] = args;
30731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30732 if (!SWIG_IsOK(res1)) {
30733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30734 }
30735 arg1 = reinterpret_cast< wxWindow * >(argp1);
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_From_int(static_cast< int >(result));
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30750 PyObject *resultobj = 0;
30751 wxWindow *arg1 = (wxWindow *) 0 ;
30752 wxLayoutDirection arg2 ;
30753 void *argp1 = 0 ;
30754 int res1 = 0 ;
30755 int val2 ;
30756 int ecode2 = 0 ;
30757 PyObject * obj0 = 0 ;
30758 PyObject * obj1 = 0 ;
30759 char * kwnames[] = {
30760 (char *) "self",(char *) "dir", NULL
30761 };
30762
30763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30765 if (!SWIG_IsOK(res1)) {
30766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30767 }
30768 arg1 = reinterpret_cast< wxWindow * >(argp1);
30769 ecode2 = SWIG_AsVal_int(obj1, &val2);
30770 if (!SWIG_IsOK(ecode2)) {
30771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30772 }
30773 arg2 = static_cast< wxLayoutDirection >(val2);
30774 {
30775 PyThreadState* __tstate = wxPyBeginAllowThreads();
30776 (arg1)->SetLayoutDirection(arg2);
30777 wxPyEndAllowThreads(__tstate);
30778 if (PyErr_Occurred()) SWIG_fail;
30779 }
30780 resultobj = SWIG_Py_Void();
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30788 PyObject *resultobj = 0;
30789 wxWindow *arg1 = (wxWindow *) 0 ;
30790 int arg2 ;
30791 int arg3 ;
30792 int arg4 ;
30793 int result;
30794 void *argp1 = 0 ;
30795 int res1 = 0 ;
30796 int val2 ;
30797 int ecode2 = 0 ;
30798 int val3 ;
30799 int ecode3 = 0 ;
30800 int val4 ;
30801 int ecode4 = 0 ;
30802 PyObject * obj0 = 0 ;
30803 PyObject * obj1 = 0 ;
30804 PyObject * obj2 = 0 ;
30805 PyObject * obj3 = 0 ;
30806 char * kwnames[] = {
30807 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30808 };
30809
30810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30812 if (!SWIG_IsOK(res1)) {
30813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30814 }
30815 arg1 = reinterpret_cast< wxWindow * >(argp1);
30816 ecode2 = SWIG_AsVal_int(obj1, &val2);
30817 if (!SWIG_IsOK(ecode2)) {
30818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30819 }
30820 arg2 = static_cast< int >(val2);
30821 ecode3 = SWIG_AsVal_int(obj2, &val3);
30822 if (!SWIG_IsOK(ecode3)) {
30823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30824 }
30825 arg3 = static_cast< int >(val3);
30826 ecode4 = SWIG_AsVal_int(obj3, &val4);
30827 if (!SWIG_IsOK(ecode4)) {
30828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30829 }
30830 arg4 = static_cast< int >(val4);
30831 {
30832 PyThreadState* __tstate = wxPyBeginAllowThreads();
30833 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30834 wxPyEndAllowThreads(__tstate);
30835 if (PyErr_Occurred()) SWIG_fail;
30836 }
30837 resultobj = SWIG_From_int(static_cast< int >(result));
30838 return resultobj;
30839 fail:
30840 return NULL;
30841 }
30842
30843
30844 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30845 PyObject *resultobj = 0;
30846 wxWindow *arg1 = (wxWindow *) 0 ;
30847 wxSize *arg2 = 0 ;
30848 void *argp1 = 0 ;
30849 int res1 = 0 ;
30850 wxSize temp2 ;
30851 PyObject * obj0 = 0 ;
30852 PyObject * obj1 = 0 ;
30853 char * kwnames[] = {
30854 (char *) "self",(char *) "size", NULL
30855 };
30856
30857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30859 if (!SWIG_IsOK(res1)) {
30860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30861 }
30862 arg1 = reinterpret_cast< wxWindow * >(argp1);
30863 {
30864 arg2 = &temp2;
30865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30866 }
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 (arg1)->SetSize((wxSize const &)*arg2);
30870 wxPyEndAllowThreads(__tstate);
30871 if (PyErr_Occurred()) SWIG_fail;
30872 }
30873 resultobj = SWIG_Py_Void();
30874 return resultobj;
30875 fail:
30876 return NULL;
30877 }
30878
30879
30880 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30881 PyObject *resultobj = 0;
30882 wxWindow *arg1 = (wxWindow *) 0 ;
30883 int arg2 ;
30884 int arg3 ;
30885 int arg4 ;
30886 int arg5 ;
30887 int arg6 = (int) wxSIZE_AUTO ;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 int val2 ;
30891 int ecode2 = 0 ;
30892 int val3 ;
30893 int ecode3 = 0 ;
30894 int val4 ;
30895 int ecode4 = 0 ;
30896 int val5 ;
30897 int ecode5 = 0 ;
30898 int val6 ;
30899 int ecode6 = 0 ;
30900 PyObject * obj0 = 0 ;
30901 PyObject * obj1 = 0 ;
30902 PyObject * obj2 = 0 ;
30903 PyObject * obj3 = 0 ;
30904 PyObject * obj4 = 0 ;
30905 PyObject * obj5 = 0 ;
30906 char * kwnames[] = {
30907 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30908 };
30909
30910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30912 if (!SWIG_IsOK(res1)) {
30913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30914 }
30915 arg1 = reinterpret_cast< wxWindow * >(argp1);
30916 ecode2 = SWIG_AsVal_int(obj1, &val2);
30917 if (!SWIG_IsOK(ecode2)) {
30918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30919 }
30920 arg2 = static_cast< int >(val2);
30921 ecode3 = SWIG_AsVal_int(obj2, &val3);
30922 if (!SWIG_IsOK(ecode3)) {
30923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30924 }
30925 arg3 = static_cast< int >(val3);
30926 ecode4 = SWIG_AsVal_int(obj3, &val4);
30927 if (!SWIG_IsOK(ecode4)) {
30928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30929 }
30930 arg4 = static_cast< int >(val4);
30931 ecode5 = SWIG_AsVal_int(obj4, &val5);
30932 if (!SWIG_IsOK(ecode5)) {
30933 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30934 }
30935 arg5 = static_cast< int >(val5);
30936 if (obj5) {
30937 ecode6 = SWIG_AsVal_int(obj5, &val6);
30938 if (!SWIG_IsOK(ecode6)) {
30939 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30940 }
30941 arg6 = static_cast< int >(val6);
30942 }
30943 {
30944 PyThreadState* __tstate = wxPyBeginAllowThreads();
30945 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 resultobj = SWIG_Py_Void();
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj = 0;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 wxRect *arg2 = 0 ;
30960 int arg3 = (int) wxSIZE_AUTO ;
30961 void *argp1 = 0 ;
30962 int res1 = 0 ;
30963 wxRect temp2 ;
30964 int val3 ;
30965 int ecode3 = 0 ;
30966 PyObject * obj0 = 0 ;
30967 PyObject * obj1 = 0 ;
30968 PyObject * obj2 = 0 ;
30969 char * kwnames[] = {
30970 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30971 };
30972
30973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30975 if (!SWIG_IsOK(res1)) {
30976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30977 }
30978 arg1 = reinterpret_cast< wxWindow * >(argp1);
30979 {
30980 arg2 = &temp2;
30981 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30982 }
30983 if (obj2) {
30984 ecode3 = SWIG_AsVal_int(obj2, &val3);
30985 if (!SWIG_IsOK(ecode3)) {
30986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30987 }
30988 arg3 = static_cast< int >(val3);
30989 }
30990 {
30991 PyThreadState* __tstate = wxPyBeginAllowThreads();
30992 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30993 wxPyEndAllowThreads(__tstate);
30994 if (PyErr_Occurred()) SWIG_fail;
30995 }
30996 resultobj = SWIG_Py_Void();
30997 return resultobj;
30998 fail:
30999 return NULL;
31000 }
31001
31002
31003 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31004 PyObject *resultobj = 0;
31005 wxWindow *arg1 = (wxWindow *) 0 ;
31006 int arg2 ;
31007 int arg3 ;
31008 void *argp1 = 0 ;
31009 int res1 = 0 ;
31010 int val2 ;
31011 int ecode2 = 0 ;
31012 int val3 ;
31013 int ecode3 = 0 ;
31014 PyObject * obj0 = 0 ;
31015 PyObject * obj1 = 0 ;
31016 PyObject * obj2 = 0 ;
31017 char * kwnames[] = {
31018 (char *) "self",(char *) "width",(char *) "height", NULL
31019 };
31020
31021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31023 if (!SWIG_IsOK(res1)) {
31024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31025 }
31026 arg1 = reinterpret_cast< wxWindow * >(argp1);
31027 ecode2 = SWIG_AsVal_int(obj1, &val2);
31028 if (!SWIG_IsOK(ecode2)) {
31029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31030 }
31031 arg2 = static_cast< int >(val2);
31032 ecode3 = SWIG_AsVal_int(obj2, &val3);
31033 if (!SWIG_IsOK(ecode3)) {
31034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31035 }
31036 arg3 = static_cast< int >(val3);
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 (arg1)->SetSize(arg2,arg3);
31040 wxPyEndAllowThreads(__tstate);
31041 if (PyErr_Occurred()) SWIG_fail;
31042 }
31043 resultobj = SWIG_Py_Void();
31044 return resultobj;
31045 fail:
31046 return NULL;
31047 }
31048
31049
31050 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31051 PyObject *resultobj = 0;
31052 wxWindow *arg1 = (wxWindow *) 0 ;
31053 wxPoint *arg2 = 0 ;
31054 int arg3 = (int) wxSIZE_USE_EXISTING ;
31055 void *argp1 = 0 ;
31056 int res1 = 0 ;
31057 wxPoint temp2 ;
31058 int val3 ;
31059 int ecode3 = 0 ;
31060 PyObject * obj0 = 0 ;
31061 PyObject * obj1 = 0 ;
31062 PyObject * obj2 = 0 ;
31063 char * kwnames[] = {
31064 (char *) "self",(char *) "pt",(char *) "flags", NULL
31065 };
31066
31067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31069 if (!SWIG_IsOK(res1)) {
31070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31071 }
31072 arg1 = reinterpret_cast< wxWindow * >(argp1);
31073 {
31074 arg2 = &temp2;
31075 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31076 }
31077 if (obj2) {
31078 ecode3 = SWIG_AsVal_int(obj2, &val3);
31079 if (!SWIG_IsOK(ecode3)) {
31080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31081 }
31082 arg3 = static_cast< int >(val3);
31083 }
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 (arg1)->Move((wxPoint const &)*arg2,arg3);
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 resultobj = SWIG_Py_Void();
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj = 0;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 int arg2 ;
31101 int arg3 ;
31102 int arg4 = (int) wxSIZE_USE_EXISTING ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 int val2 ;
31106 int ecode2 = 0 ;
31107 int val3 ;
31108 int ecode3 = 0 ;
31109 int val4 ;
31110 int ecode4 = 0 ;
31111 PyObject * obj0 = 0 ;
31112 PyObject * obj1 = 0 ;
31113 PyObject * obj2 = 0 ;
31114 PyObject * obj3 = 0 ;
31115 char * kwnames[] = {
31116 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31117 };
31118
31119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31121 if (!SWIG_IsOK(res1)) {
31122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31123 }
31124 arg1 = reinterpret_cast< wxWindow * >(argp1);
31125 ecode2 = SWIG_AsVal_int(obj1, &val2);
31126 if (!SWIG_IsOK(ecode2)) {
31127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31128 }
31129 arg2 = static_cast< int >(val2);
31130 ecode3 = SWIG_AsVal_int(obj2, &val3);
31131 if (!SWIG_IsOK(ecode3)) {
31132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31133 }
31134 arg3 = static_cast< int >(val3);
31135 if (obj3) {
31136 ecode4 = SWIG_AsVal_int(obj3, &val4);
31137 if (!SWIG_IsOK(ecode4)) {
31138 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31139 }
31140 arg4 = static_cast< int >(val4);
31141 }
31142 {
31143 PyThreadState* __tstate = wxPyBeginAllowThreads();
31144 (arg1)->Move(arg2,arg3,arg4);
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 resultobj = SWIG_Py_Void();
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj = 0;
31157 wxWindow *arg1 = (wxWindow *) 0 ;
31158 wxSize const &arg2_defvalue = wxDefaultSize ;
31159 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31160 void *argp1 = 0 ;
31161 int res1 = 0 ;
31162 wxSize temp2 ;
31163 PyObject * obj0 = 0 ;
31164 PyObject * obj1 = 0 ;
31165 char * kwnames[] = {
31166 (char *) "self",(char *) "size", NULL
31167 };
31168
31169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31171 if (!SWIG_IsOK(res1)) {
31172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31173 }
31174 arg1 = reinterpret_cast< wxWindow * >(argp1);
31175 if (obj1) {
31176 {
31177 arg2 = &temp2;
31178 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31179 }
31180 }
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_Py_Void();
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31195 PyObject *resultobj = 0;
31196 wxWindow *arg1 = (wxWindow *) 0 ;
31197 void *argp1 = 0 ;
31198 int res1 = 0 ;
31199 PyObject *swig_obj[1] ;
31200
31201 if (!args) SWIG_fail;
31202 swig_obj[0] = args;
31203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31204 if (!SWIG_IsOK(res1)) {
31205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31206 }
31207 arg1 = reinterpret_cast< wxWindow * >(argp1);
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 (arg1)->Raise();
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_Py_Void();
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31222 PyObject *resultobj = 0;
31223 wxWindow *arg1 = (wxWindow *) 0 ;
31224 void *argp1 = 0 ;
31225 int res1 = 0 ;
31226 PyObject *swig_obj[1] ;
31227
31228 if (!args) SWIG_fail;
31229 swig_obj[0] = args;
31230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31231 if (!SWIG_IsOK(res1)) {
31232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31233 }
31234 arg1 = reinterpret_cast< wxWindow * >(argp1);
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 (arg1)->Lower();
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_Py_Void();
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj = 0;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 wxSize *arg2 = 0 ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 wxSize temp2 ;
31255 PyObject * obj0 = 0 ;
31256 PyObject * obj1 = 0 ;
31257 char * kwnames[] = {
31258 (char *) "self",(char *) "size", NULL
31259 };
31260
31261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31263 if (!SWIG_IsOK(res1)) {
31264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31265 }
31266 arg1 = reinterpret_cast< wxWindow * >(argp1);
31267 {
31268 arg2 = &temp2;
31269 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31270 }
31271 {
31272 PyThreadState* __tstate = wxPyBeginAllowThreads();
31273 (arg1)->SetClientSize((wxSize const &)*arg2);
31274 wxPyEndAllowThreads(__tstate);
31275 if (PyErr_Occurred()) SWIG_fail;
31276 }
31277 resultobj = SWIG_Py_Void();
31278 return resultobj;
31279 fail:
31280 return NULL;
31281 }
31282
31283
31284 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31285 PyObject *resultobj = 0;
31286 wxWindow *arg1 = (wxWindow *) 0 ;
31287 int arg2 ;
31288 int arg3 ;
31289 void *argp1 = 0 ;
31290 int res1 = 0 ;
31291 int val2 ;
31292 int ecode2 = 0 ;
31293 int val3 ;
31294 int ecode3 = 0 ;
31295 PyObject * obj0 = 0 ;
31296 PyObject * obj1 = 0 ;
31297 PyObject * obj2 = 0 ;
31298 char * kwnames[] = {
31299 (char *) "self",(char *) "width",(char *) "height", NULL
31300 };
31301
31302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31304 if (!SWIG_IsOK(res1)) {
31305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31306 }
31307 arg1 = reinterpret_cast< wxWindow * >(argp1);
31308 ecode2 = SWIG_AsVal_int(obj1, &val2);
31309 if (!SWIG_IsOK(ecode2)) {
31310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31311 }
31312 arg2 = static_cast< int >(val2);
31313 ecode3 = SWIG_AsVal_int(obj2, &val3);
31314 if (!SWIG_IsOK(ecode3)) {
31315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31316 }
31317 arg3 = static_cast< int >(val3);
31318 {
31319 PyThreadState* __tstate = wxPyBeginAllowThreads();
31320 (arg1)->SetClientSize(arg2,arg3);
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 resultobj = SWIG_Py_Void();
31325 return resultobj;
31326 fail:
31327 return NULL;
31328 }
31329
31330
31331 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31332 PyObject *resultobj = 0;
31333 wxWindow *arg1 = (wxWindow *) 0 ;
31334 wxRect *arg2 = 0 ;
31335 void *argp1 = 0 ;
31336 int res1 = 0 ;
31337 wxRect temp2 ;
31338 PyObject * obj0 = 0 ;
31339 PyObject * obj1 = 0 ;
31340 char * kwnames[] = {
31341 (char *) "self",(char *) "rect", NULL
31342 };
31343
31344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31346 if (!SWIG_IsOK(res1)) {
31347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31348 }
31349 arg1 = reinterpret_cast< wxWindow * >(argp1);
31350 {
31351 arg2 = &temp2;
31352 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31353 }
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 (arg1)->SetClientSize((wxRect const &)*arg2);
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 resultobj = SWIG_Py_Void();
31361 return resultobj;
31362 fail:
31363 return NULL;
31364 }
31365
31366
31367 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31368 PyObject *resultobj = 0;
31369 wxWindow *arg1 = (wxWindow *) 0 ;
31370 wxPoint result;
31371 void *argp1 = 0 ;
31372 int res1 = 0 ;
31373 PyObject *swig_obj[1] ;
31374
31375 if (!args) SWIG_fail;
31376 swig_obj[0] = args;
31377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31378 if (!SWIG_IsOK(res1)) {
31379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31380 }
31381 arg1 = reinterpret_cast< wxWindow * >(argp1);
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = ((wxWindow const *)arg1)->GetPosition();
31385 wxPyEndAllowThreads(__tstate);
31386 if (PyErr_Occurred()) SWIG_fail;
31387 }
31388 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31389 return resultobj;
31390 fail:
31391 return NULL;
31392 }
31393
31394
31395 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31396 PyObject *resultobj = 0;
31397 wxWindow *arg1 = (wxWindow *) 0 ;
31398 int *arg2 = (int *) 0 ;
31399 int *arg3 = (int *) 0 ;
31400 void *argp1 = 0 ;
31401 int res1 = 0 ;
31402 int temp2 ;
31403 int res2 = SWIG_TMPOBJ ;
31404 int temp3 ;
31405 int res3 = SWIG_TMPOBJ ;
31406 PyObject *swig_obj[1] ;
31407
31408 arg2 = &temp2;
31409 arg3 = &temp3;
31410 if (!args) SWIG_fail;
31411 swig_obj[0] = args;
31412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31413 if (!SWIG_IsOK(res1)) {
31414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31415 }
31416 arg1 = reinterpret_cast< wxWindow * >(argp1);
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 resultobj = SWIG_Py_Void();
31424 if (SWIG_IsTmpObj(res2)) {
31425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31426 } else {
31427 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31429 }
31430 if (SWIG_IsTmpObj(res3)) {
31431 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31432 } else {
31433 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31434 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31435 }
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 PyObject *resultobj = 0;
31444 wxWindow *arg1 = (wxWindow *) 0 ;
31445 wxPoint result;
31446 void *argp1 = 0 ;
31447 int res1 = 0 ;
31448 PyObject *swig_obj[1] ;
31449
31450 if (!args) SWIG_fail;
31451 swig_obj[0] = args;
31452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31453 if (!SWIG_IsOK(res1)) {
31454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31455 }
31456 arg1 = reinterpret_cast< wxWindow * >(argp1);
31457 {
31458 PyThreadState* __tstate = wxPyBeginAllowThreads();
31459 result = ((wxWindow const *)arg1)->GetScreenPosition();
31460 wxPyEndAllowThreads(__tstate);
31461 if (PyErr_Occurred()) SWIG_fail;
31462 }
31463 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31464 return resultobj;
31465 fail:
31466 return NULL;
31467 }
31468
31469
31470 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31471 PyObject *resultobj = 0;
31472 wxWindow *arg1 = (wxWindow *) 0 ;
31473 int *arg2 = (int *) 0 ;
31474 int *arg3 = (int *) 0 ;
31475 void *argp1 = 0 ;
31476 int res1 = 0 ;
31477 int temp2 ;
31478 int res2 = SWIG_TMPOBJ ;
31479 int temp3 ;
31480 int res3 = SWIG_TMPOBJ ;
31481 PyObject *swig_obj[1] ;
31482
31483 arg2 = &temp2;
31484 arg3 = &temp3;
31485 if (!args) SWIG_fail;
31486 swig_obj[0] = args;
31487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31488 if (!SWIG_IsOK(res1)) {
31489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31490 }
31491 arg1 = reinterpret_cast< wxWindow * >(argp1);
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31495 wxPyEndAllowThreads(__tstate);
31496 if (PyErr_Occurred()) SWIG_fail;
31497 }
31498 resultobj = SWIG_Py_Void();
31499 if (SWIG_IsTmpObj(res2)) {
31500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31501 } else {
31502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31504 }
31505 if (SWIG_IsTmpObj(res3)) {
31506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31507 } else {
31508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31510 }
31511 return resultobj;
31512 fail:
31513 return NULL;
31514 }
31515
31516
31517 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31518 PyObject *resultobj = 0;
31519 wxWindow *arg1 = (wxWindow *) 0 ;
31520 wxRect result;
31521 void *argp1 = 0 ;
31522 int res1 = 0 ;
31523 PyObject *swig_obj[1] ;
31524
31525 if (!args) SWIG_fail;
31526 swig_obj[0] = args;
31527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31528 if (!SWIG_IsOK(res1)) {
31529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31530 }
31531 arg1 = reinterpret_cast< wxWindow * >(argp1);
31532 {
31533 PyThreadState* __tstate = wxPyBeginAllowThreads();
31534 result = ((wxWindow const *)arg1)->GetScreenRect();
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31539 return resultobj;
31540 fail:
31541 return NULL;
31542 }
31543
31544
31545 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31546 PyObject *resultobj = 0;
31547 wxWindow *arg1 = (wxWindow *) 0 ;
31548 wxSize result;
31549 void *argp1 = 0 ;
31550 int res1 = 0 ;
31551 PyObject *swig_obj[1] ;
31552
31553 if (!args) SWIG_fail;
31554 swig_obj[0] = args;
31555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31556 if (!SWIG_IsOK(res1)) {
31557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31558 }
31559 arg1 = reinterpret_cast< wxWindow * >(argp1);
31560 {
31561 PyThreadState* __tstate = wxPyBeginAllowThreads();
31562 result = ((wxWindow const *)arg1)->GetSize();
31563 wxPyEndAllowThreads(__tstate);
31564 if (PyErr_Occurred()) SWIG_fail;
31565 }
31566 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31567 return resultobj;
31568 fail:
31569 return NULL;
31570 }
31571
31572
31573 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31574 PyObject *resultobj = 0;
31575 wxWindow *arg1 = (wxWindow *) 0 ;
31576 int *arg2 = (int *) 0 ;
31577 int *arg3 = (int *) 0 ;
31578 void *argp1 = 0 ;
31579 int res1 = 0 ;
31580 int temp2 ;
31581 int res2 = SWIG_TMPOBJ ;
31582 int temp3 ;
31583 int res3 = SWIG_TMPOBJ ;
31584 PyObject *swig_obj[1] ;
31585
31586 arg2 = &temp2;
31587 arg3 = &temp3;
31588 if (!args) SWIG_fail;
31589 swig_obj[0] = args;
31590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31591 if (!SWIG_IsOK(res1)) {
31592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31593 }
31594 arg1 = reinterpret_cast< wxWindow * >(argp1);
31595 {
31596 PyThreadState* __tstate = wxPyBeginAllowThreads();
31597 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31598 wxPyEndAllowThreads(__tstate);
31599 if (PyErr_Occurred()) SWIG_fail;
31600 }
31601 resultobj = SWIG_Py_Void();
31602 if (SWIG_IsTmpObj(res2)) {
31603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31604 } else {
31605 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31607 }
31608 if (SWIG_IsTmpObj(res3)) {
31609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31610 } else {
31611 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31613 }
31614 return resultobj;
31615 fail:
31616 return NULL;
31617 }
31618
31619
31620 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31621 PyObject *resultobj = 0;
31622 wxWindow *arg1 = (wxWindow *) 0 ;
31623 wxRect result;
31624 void *argp1 = 0 ;
31625 int res1 = 0 ;
31626 PyObject *swig_obj[1] ;
31627
31628 if (!args) SWIG_fail;
31629 swig_obj[0] = args;
31630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31631 if (!SWIG_IsOK(res1)) {
31632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31633 }
31634 arg1 = reinterpret_cast< wxWindow * >(argp1);
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 result = ((wxWindow const *)arg1)->GetRect();
31638 wxPyEndAllowThreads(__tstate);
31639 if (PyErr_Occurred()) SWIG_fail;
31640 }
31641 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31642 return resultobj;
31643 fail:
31644 return NULL;
31645 }
31646
31647
31648 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31649 PyObject *resultobj = 0;
31650 wxWindow *arg1 = (wxWindow *) 0 ;
31651 wxSize result;
31652 void *argp1 = 0 ;
31653 int res1 = 0 ;
31654 PyObject *swig_obj[1] ;
31655
31656 if (!args) SWIG_fail;
31657 swig_obj[0] = args;
31658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31659 if (!SWIG_IsOK(res1)) {
31660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31661 }
31662 arg1 = reinterpret_cast< wxWindow * >(argp1);
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 result = ((wxWindow const *)arg1)->GetClientSize();
31666 wxPyEndAllowThreads(__tstate);
31667 if (PyErr_Occurred()) SWIG_fail;
31668 }
31669 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31670 return resultobj;
31671 fail:
31672 return NULL;
31673 }
31674
31675
31676 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31677 PyObject *resultobj = 0;
31678 wxWindow *arg1 = (wxWindow *) 0 ;
31679 int *arg2 = (int *) 0 ;
31680 int *arg3 = (int *) 0 ;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 int temp2 ;
31684 int res2 = SWIG_TMPOBJ ;
31685 int temp3 ;
31686 int res3 = SWIG_TMPOBJ ;
31687 PyObject *swig_obj[1] ;
31688
31689 arg2 = &temp2;
31690 arg3 = &temp3;
31691 if (!args) SWIG_fail;
31692 swig_obj[0] = args;
31693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31694 if (!SWIG_IsOK(res1)) {
31695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31696 }
31697 arg1 = reinterpret_cast< wxWindow * >(argp1);
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31701 wxPyEndAllowThreads(__tstate);
31702 if (PyErr_Occurred()) SWIG_fail;
31703 }
31704 resultobj = SWIG_Py_Void();
31705 if (SWIG_IsTmpObj(res2)) {
31706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31707 } else {
31708 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31710 }
31711 if (SWIG_IsTmpObj(res3)) {
31712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31713 } else {
31714 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31716 }
31717 return resultobj;
31718 fail:
31719 return NULL;
31720 }
31721
31722
31723 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31724 PyObject *resultobj = 0;
31725 wxWindow *arg1 = (wxWindow *) 0 ;
31726 wxPoint result;
31727 void *argp1 = 0 ;
31728 int res1 = 0 ;
31729 PyObject *swig_obj[1] ;
31730
31731 if (!args) SWIG_fail;
31732 swig_obj[0] = args;
31733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31734 if (!SWIG_IsOK(res1)) {
31735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31736 }
31737 arg1 = reinterpret_cast< wxWindow * >(argp1);
31738 {
31739 PyThreadState* __tstate = wxPyBeginAllowThreads();
31740 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31741 wxPyEndAllowThreads(__tstate);
31742 if (PyErr_Occurred()) SWIG_fail;
31743 }
31744 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31745 return resultobj;
31746 fail:
31747 return NULL;
31748 }
31749
31750
31751 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31752 PyObject *resultobj = 0;
31753 wxWindow *arg1 = (wxWindow *) 0 ;
31754 wxRect result;
31755 void *argp1 = 0 ;
31756 int res1 = 0 ;
31757 PyObject *swig_obj[1] ;
31758
31759 if (!args) SWIG_fail;
31760 swig_obj[0] = args;
31761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31762 if (!SWIG_IsOK(res1)) {
31763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31764 }
31765 arg1 = reinterpret_cast< wxWindow * >(argp1);
31766 {
31767 PyThreadState* __tstate = wxPyBeginAllowThreads();
31768 result = ((wxWindow const *)arg1)->GetClientRect();
31769 wxPyEndAllowThreads(__tstate);
31770 if (PyErr_Occurred()) SWIG_fail;
31771 }
31772 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31773 return resultobj;
31774 fail:
31775 return NULL;
31776 }
31777
31778
31779 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31780 PyObject *resultobj = 0;
31781 wxWindow *arg1 = (wxWindow *) 0 ;
31782 wxSize result;
31783 void *argp1 = 0 ;
31784 int res1 = 0 ;
31785 PyObject *swig_obj[1] ;
31786
31787 if (!args) SWIG_fail;
31788 swig_obj[0] = args;
31789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31790 if (!SWIG_IsOK(res1)) {
31791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31792 }
31793 arg1 = reinterpret_cast< wxWindow * >(argp1);
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 result = ((wxWindow const *)arg1)->GetBestSize();
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31808 PyObject *resultobj = 0;
31809 wxWindow *arg1 = (wxWindow *) 0 ;
31810 int *arg2 = (int *) 0 ;
31811 int *arg3 = (int *) 0 ;
31812 void *argp1 = 0 ;
31813 int res1 = 0 ;
31814 int temp2 ;
31815 int res2 = SWIG_TMPOBJ ;
31816 int temp3 ;
31817 int res3 = SWIG_TMPOBJ ;
31818 PyObject *swig_obj[1] ;
31819
31820 arg2 = &temp2;
31821 arg3 = &temp3;
31822 if (!args) SWIG_fail;
31823 swig_obj[0] = args;
31824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31825 if (!SWIG_IsOK(res1)) {
31826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31827 }
31828 arg1 = reinterpret_cast< wxWindow * >(argp1);
31829 {
31830 PyThreadState* __tstate = wxPyBeginAllowThreads();
31831 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 resultobj = SWIG_Py_Void();
31836 if (SWIG_IsTmpObj(res2)) {
31837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31838 } else {
31839 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31841 }
31842 if (SWIG_IsTmpObj(res3)) {
31843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31844 } else {
31845 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31847 }
31848 return resultobj;
31849 fail:
31850 return NULL;
31851 }
31852
31853
31854 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31855 PyObject *resultobj = 0;
31856 wxWindow *arg1 = (wxWindow *) 0 ;
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_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31866 }
31867 arg1 = reinterpret_cast< wxWindow * >(argp1);
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 (arg1)->InvalidateBestSize();
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_Py_Void();
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31882 PyObject *resultobj = 0;
31883 wxWindow *arg1 = (wxWindow *) 0 ;
31884 wxSize *arg2 = 0 ;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 wxSize temp2 ;
31888 PyObject * obj0 = 0 ;
31889 PyObject * obj1 = 0 ;
31890 char * kwnames[] = {
31891 (char *) "self",(char *) "size", NULL
31892 };
31893
31894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31896 if (!SWIG_IsOK(res1)) {
31897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31898 }
31899 arg1 = reinterpret_cast< wxWindow * >(argp1);
31900 {
31901 arg2 = &temp2;
31902 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31903 }
31904 {
31905 PyThreadState* __tstate = wxPyBeginAllowThreads();
31906 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31907 wxPyEndAllowThreads(__tstate);
31908 if (PyErr_Occurred()) SWIG_fail;
31909 }
31910 resultobj = SWIG_Py_Void();
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31918 PyObject *resultobj = 0;
31919 wxWindow *arg1 = (wxWindow *) 0 ;
31920 wxSize result;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 PyObject *swig_obj[1] ;
31924
31925 if (!args) SWIG_fail;
31926 swig_obj[0] = args;
31927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31928 if (!SWIG_IsOK(res1)) {
31929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31930 }
31931 arg1 = reinterpret_cast< wxWindow * >(argp1);
31932 {
31933 PyThreadState* __tstate = wxPyBeginAllowThreads();
31934 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31935 wxPyEndAllowThreads(__tstate);
31936 if (PyErr_Occurred()) SWIG_fail;
31937 }
31938 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31939 return resultobj;
31940 fail:
31941 return NULL;
31942 }
31943
31944
31945 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31946 PyObject *resultobj = 0;
31947 wxWindow *arg1 = (wxWindow *) 0 ;
31948 wxSize result;
31949 void *argp1 = 0 ;
31950 int res1 = 0 ;
31951 PyObject *swig_obj[1] ;
31952
31953 if (!args) SWIG_fail;
31954 swig_obj[0] = args;
31955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31974 PyObject *resultobj = 0;
31975 wxWindow *arg1 = (wxWindow *) 0 ;
31976 int arg2 = (int) wxBOTH ;
31977 void *argp1 = 0 ;
31978 int res1 = 0 ;
31979 int val2 ;
31980 int ecode2 = 0 ;
31981 PyObject * obj0 = 0 ;
31982 PyObject * obj1 = 0 ;
31983 char * kwnames[] = {
31984 (char *) "self",(char *) "direction", NULL
31985 };
31986
31987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31989 if (!SWIG_IsOK(res1)) {
31990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31991 }
31992 arg1 = reinterpret_cast< wxWindow * >(argp1);
31993 if (obj1) {
31994 ecode2 = SWIG_AsVal_int(obj1, &val2);
31995 if (!SWIG_IsOK(ecode2)) {
31996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31997 }
31998 arg2 = static_cast< int >(val2);
31999 }
32000 {
32001 PyThreadState* __tstate = wxPyBeginAllowThreads();
32002 (arg1)->Center(arg2);
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 resultobj = SWIG_Py_Void();
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32014 PyObject *resultobj = 0;
32015 wxWindow *arg1 = (wxWindow *) 0 ;
32016 int arg2 = (int) wxBOTH ;
32017 void *argp1 = 0 ;
32018 int res1 = 0 ;
32019 int val2 ;
32020 int ecode2 = 0 ;
32021 PyObject * obj0 = 0 ;
32022 PyObject * obj1 = 0 ;
32023 char * kwnames[] = {
32024 (char *) "self",(char *) "dir", NULL
32025 };
32026
32027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32029 if (!SWIG_IsOK(res1)) {
32030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32031 }
32032 arg1 = reinterpret_cast< wxWindow * >(argp1);
32033 if (obj1) {
32034 ecode2 = SWIG_AsVal_int(obj1, &val2);
32035 if (!SWIG_IsOK(ecode2)) {
32036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32037 }
32038 arg2 = static_cast< int >(val2);
32039 }
32040 {
32041 PyThreadState* __tstate = wxPyBeginAllowThreads();
32042 (arg1)->CenterOnParent(arg2);
32043 wxPyEndAllowThreads(__tstate);
32044 if (PyErr_Occurred()) SWIG_fail;
32045 }
32046 resultobj = SWIG_Py_Void();
32047 return resultobj;
32048 fail:
32049 return NULL;
32050 }
32051
32052
32053 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32054 PyObject *resultobj = 0;
32055 wxWindow *arg1 = (wxWindow *) 0 ;
32056 void *argp1 = 0 ;
32057 int res1 = 0 ;
32058 PyObject *swig_obj[1] ;
32059
32060 if (!args) SWIG_fail;
32061 swig_obj[0] = args;
32062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32063 if (!SWIG_IsOK(res1)) {
32064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32065 }
32066 arg1 = reinterpret_cast< wxWindow * >(argp1);
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 (arg1)->Fit();
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 resultobj = SWIG_Py_Void();
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32081 PyObject *resultobj = 0;
32082 wxWindow *arg1 = (wxWindow *) 0 ;
32083 void *argp1 = 0 ;
32084 int res1 = 0 ;
32085 PyObject *swig_obj[1] ;
32086
32087 if (!args) SWIG_fail;
32088 swig_obj[0] = args;
32089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32090 if (!SWIG_IsOK(res1)) {
32091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32092 }
32093 arg1 = reinterpret_cast< wxWindow * >(argp1);
32094 {
32095 PyThreadState* __tstate = wxPyBeginAllowThreads();
32096 (arg1)->FitInside();
32097 wxPyEndAllowThreads(__tstate);
32098 if (PyErr_Occurred()) SWIG_fail;
32099 }
32100 resultobj = SWIG_Py_Void();
32101 return resultobj;
32102 fail:
32103 return NULL;
32104 }
32105
32106
32107 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32108 PyObject *resultobj = 0;
32109 wxWindow *arg1 = (wxWindow *) 0 ;
32110 int arg2 ;
32111 int arg3 ;
32112 int arg4 = (int) -1 ;
32113 int arg5 = (int) -1 ;
32114 int arg6 = (int) -1 ;
32115 int arg7 = (int) -1 ;
32116 void *argp1 = 0 ;
32117 int res1 = 0 ;
32118 int val2 ;
32119 int ecode2 = 0 ;
32120 int val3 ;
32121 int ecode3 = 0 ;
32122 int val4 ;
32123 int ecode4 = 0 ;
32124 int val5 ;
32125 int ecode5 = 0 ;
32126 int val6 ;
32127 int ecode6 = 0 ;
32128 int val7 ;
32129 int ecode7 = 0 ;
32130 PyObject * obj0 = 0 ;
32131 PyObject * obj1 = 0 ;
32132 PyObject * obj2 = 0 ;
32133 PyObject * obj3 = 0 ;
32134 PyObject * obj4 = 0 ;
32135 PyObject * obj5 = 0 ;
32136 PyObject * obj6 = 0 ;
32137 char * kwnames[] = {
32138 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32139 };
32140
32141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32145 }
32146 arg1 = reinterpret_cast< wxWindow * >(argp1);
32147 ecode2 = SWIG_AsVal_int(obj1, &val2);
32148 if (!SWIG_IsOK(ecode2)) {
32149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32150 }
32151 arg2 = static_cast< int >(val2);
32152 ecode3 = SWIG_AsVal_int(obj2, &val3);
32153 if (!SWIG_IsOK(ecode3)) {
32154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32155 }
32156 arg3 = static_cast< int >(val3);
32157 if (obj3) {
32158 ecode4 = SWIG_AsVal_int(obj3, &val4);
32159 if (!SWIG_IsOK(ecode4)) {
32160 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32161 }
32162 arg4 = static_cast< int >(val4);
32163 }
32164 if (obj4) {
32165 ecode5 = SWIG_AsVal_int(obj4, &val5);
32166 if (!SWIG_IsOK(ecode5)) {
32167 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32168 }
32169 arg5 = static_cast< int >(val5);
32170 }
32171 if (obj5) {
32172 ecode6 = SWIG_AsVal_int(obj5, &val6);
32173 if (!SWIG_IsOK(ecode6)) {
32174 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32175 }
32176 arg6 = static_cast< int >(val6);
32177 }
32178 if (obj6) {
32179 ecode7 = SWIG_AsVal_int(obj6, &val7);
32180 if (!SWIG_IsOK(ecode7)) {
32181 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32182 }
32183 arg7 = static_cast< int >(val7);
32184 }
32185 {
32186 PyThreadState* __tstate = wxPyBeginAllowThreads();
32187 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32188 wxPyEndAllowThreads(__tstate);
32189 if (PyErr_Occurred()) SWIG_fail;
32190 }
32191 resultobj = SWIG_Py_Void();
32192 return resultobj;
32193 fail:
32194 return NULL;
32195 }
32196
32197
32198 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32199 PyObject *resultobj = 0;
32200 wxWindow *arg1 = (wxWindow *) 0 ;
32201 wxSize *arg2 = 0 ;
32202 wxSize const &arg3_defvalue = wxDefaultSize ;
32203 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32204 wxSize const &arg4_defvalue = wxDefaultSize ;
32205 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32206 void *argp1 = 0 ;
32207 int res1 = 0 ;
32208 wxSize temp2 ;
32209 wxSize temp3 ;
32210 wxSize temp4 ;
32211 PyObject * obj0 = 0 ;
32212 PyObject * obj1 = 0 ;
32213 PyObject * obj2 = 0 ;
32214 PyObject * obj3 = 0 ;
32215 char * kwnames[] = {
32216 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32217 };
32218
32219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32221 if (!SWIG_IsOK(res1)) {
32222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32223 }
32224 arg1 = reinterpret_cast< wxWindow * >(argp1);
32225 {
32226 arg2 = &temp2;
32227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32228 }
32229 if (obj2) {
32230 {
32231 arg3 = &temp3;
32232 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32233 }
32234 }
32235 if (obj3) {
32236 {
32237 arg4 = &temp4;
32238 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32239 }
32240 }
32241 {
32242 PyThreadState* __tstate = wxPyBeginAllowThreads();
32243 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32244 wxPyEndAllowThreads(__tstate);
32245 if (PyErr_Occurred()) SWIG_fail;
32246 }
32247 resultobj = SWIG_Py_Void();
32248 return resultobj;
32249 fail:
32250 return NULL;
32251 }
32252
32253
32254 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32255 PyObject *resultobj = 0;
32256 wxWindow *arg1 = (wxWindow *) 0 ;
32257 int arg2 ;
32258 int arg3 ;
32259 int arg4 = (int) -1 ;
32260 int arg5 = (int) -1 ;
32261 void *argp1 = 0 ;
32262 int res1 = 0 ;
32263 int val2 ;
32264 int ecode2 = 0 ;
32265 int val3 ;
32266 int ecode3 = 0 ;
32267 int val4 ;
32268 int ecode4 = 0 ;
32269 int val5 ;
32270 int ecode5 = 0 ;
32271 PyObject * obj0 = 0 ;
32272 PyObject * obj1 = 0 ;
32273 PyObject * obj2 = 0 ;
32274 PyObject * obj3 = 0 ;
32275 PyObject * obj4 = 0 ;
32276 char * kwnames[] = {
32277 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32278 };
32279
32280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32282 if (!SWIG_IsOK(res1)) {
32283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32284 }
32285 arg1 = reinterpret_cast< wxWindow * >(argp1);
32286 ecode2 = SWIG_AsVal_int(obj1, &val2);
32287 if (!SWIG_IsOK(ecode2)) {
32288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32289 }
32290 arg2 = static_cast< int >(val2);
32291 ecode3 = SWIG_AsVal_int(obj2, &val3);
32292 if (!SWIG_IsOK(ecode3)) {
32293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32294 }
32295 arg3 = static_cast< int >(val3);
32296 if (obj3) {
32297 ecode4 = SWIG_AsVal_int(obj3, &val4);
32298 if (!SWIG_IsOK(ecode4)) {
32299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32300 }
32301 arg4 = static_cast< int >(val4);
32302 }
32303 if (obj4) {
32304 ecode5 = SWIG_AsVal_int(obj4, &val5);
32305 if (!SWIG_IsOK(ecode5)) {
32306 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32307 }
32308 arg5 = static_cast< int >(val5);
32309 }
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32313 wxPyEndAllowThreads(__tstate);
32314 if (PyErr_Occurred()) SWIG_fail;
32315 }
32316 resultobj = SWIG_Py_Void();
32317 return resultobj;
32318 fail:
32319 return NULL;
32320 }
32321
32322
32323 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32324 PyObject *resultobj = 0;
32325 wxWindow *arg1 = (wxWindow *) 0 ;
32326 wxSize *arg2 = 0 ;
32327 wxSize const &arg3_defvalue = wxDefaultSize ;
32328 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32329 void *argp1 = 0 ;
32330 int res1 = 0 ;
32331 wxSize temp2 ;
32332 wxSize temp3 ;
32333 PyObject * obj0 = 0 ;
32334 PyObject * obj1 = 0 ;
32335 PyObject * obj2 = 0 ;
32336 char * kwnames[] = {
32337 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32338 };
32339
32340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32342 if (!SWIG_IsOK(res1)) {
32343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32344 }
32345 arg1 = reinterpret_cast< wxWindow * >(argp1);
32346 {
32347 arg2 = &temp2;
32348 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32349 }
32350 if (obj2) {
32351 {
32352 arg3 = &temp3;
32353 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32354 }
32355 }
32356 {
32357 PyThreadState* __tstate = wxPyBeginAllowThreads();
32358 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32359 wxPyEndAllowThreads(__tstate);
32360 if (PyErr_Occurred()) SWIG_fail;
32361 }
32362 resultobj = SWIG_Py_Void();
32363 return resultobj;
32364 fail:
32365 return NULL;
32366 }
32367
32368
32369 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32370 PyObject *resultobj = 0;
32371 wxWindow *arg1 = (wxWindow *) 0 ;
32372 wxSize result;
32373 void *argp1 = 0 ;
32374 int res1 = 0 ;
32375 PyObject *swig_obj[1] ;
32376
32377 if (!args) SWIG_fail;
32378 swig_obj[0] = args;
32379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32380 if (!SWIG_IsOK(res1)) {
32381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32382 }
32383 arg1 = reinterpret_cast< wxWindow * >(argp1);
32384 {
32385 PyThreadState* __tstate = wxPyBeginAllowThreads();
32386 result = ((wxWindow const *)arg1)->GetMaxSize();
32387 wxPyEndAllowThreads(__tstate);
32388 if (PyErr_Occurred()) SWIG_fail;
32389 }
32390 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32391 return resultobj;
32392 fail:
32393 return NULL;
32394 }
32395
32396
32397 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32398 PyObject *resultobj = 0;
32399 wxWindow *arg1 = (wxWindow *) 0 ;
32400 wxSize result;
32401 void *argp1 = 0 ;
32402 int res1 = 0 ;
32403 PyObject *swig_obj[1] ;
32404
32405 if (!args) SWIG_fail;
32406 swig_obj[0] = args;
32407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32408 if (!SWIG_IsOK(res1)) {
32409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32410 }
32411 arg1 = reinterpret_cast< wxWindow * >(argp1);
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 result = ((wxWindow const *)arg1)->GetMinSize();
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 wxSize *arg2 = 0 ;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 wxSize temp2 ;
32432 PyObject * obj0 = 0 ;
32433 PyObject * obj1 = 0 ;
32434 char * kwnames[] = {
32435 (char *) "self",(char *) "minSize", NULL
32436 };
32437
32438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32440 if (!SWIG_IsOK(res1)) {
32441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32442 }
32443 arg1 = reinterpret_cast< wxWindow * >(argp1);
32444 {
32445 arg2 = &temp2;
32446 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32447 }
32448 {
32449 PyThreadState* __tstate = wxPyBeginAllowThreads();
32450 (arg1)->SetMinSize((wxSize const &)*arg2);
32451 wxPyEndAllowThreads(__tstate);
32452 if (PyErr_Occurred()) SWIG_fail;
32453 }
32454 resultobj = SWIG_Py_Void();
32455 return resultobj;
32456 fail:
32457 return NULL;
32458 }
32459
32460
32461 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32462 PyObject *resultobj = 0;
32463 wxWindow *arg1 = (wxWindow *) 0 ;
32464 wxSize *arg2 = 0 ;
32465 void *argp1 = 0 ;
32466 int res1 = 0 ;
32467 wxSize temp2 ;
32468 PyObject * obj0 = 0 ;
32469 PyObject * obj1 = 0 ;
32470 char * kwnames[] = {
32471 (char *) "self",(char *) "maxSize", NULL
32472 };
32473
32474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32476 if (!SWIG_IsOK(res1)) {
32477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32478 }
32479 arg1 = reinterpret_cast< wxWindow * >(argp1);
32480 {
32481 arg2 = &temp2;
32482 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32483 }
32484 {
32485 PyThreadState* __tstate = wxPyBeginAllowThreads();
32486 (arg1)->SetMaxSize((wxSize const &)*arg2);
32487 wxPyEndAllowThreads(__tstate);
32488 if (PyErr_Occurred()) SWIG_fail;
32489 }
32490 resultobj = SWIG_Py_Void();
32491 return resultobj;
32492 fail:
32493 return NULL;
32494 }
32495
32496
32497 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32498 PyObject *resultobj = 0;
32499 wxWindow *arg1 = (wxWindow *) 0 ;
32500 int result;
32501 void *argp1 = 0 ;
32502 int res1 = 0 ;
32503 PyObject *swig_obj[1] ;
32504
32505 if (!args) SWIG_fail;
32506 swig_obj[0] = args;
32507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32508 if (!SWIG_IsOK(res1)) {
32509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32510 }
32511 arg1 = reinterpret_cast< wxWindow * >(argp1);
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32515 wxPyEndAllowThreads(__tstate);
32516 if (PyErr_Occurred()) SWIG_fail;
32517 }
32518 resultobj = SWIG_From_int(static_cast< int >(result));
32519 return resultobj;
32520 fail:
32521 return NULL;
32522 }
32523
32524
32525 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32526 PyObject *resultobj = 0;
32527 wxWindow *arg1 = (wxWindow *) 0 ;
32528 int result;
32529 void *argp1 = 0 ;
32530 int res1 = 0 ;
32531 PyObject *swig_obj[1] ;
32532
32533 if (!args) SWIG_fail;
32534 swig_obj[0] = args;
32535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32536 if (!SWIG_IsOK(res1)) {
32537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32538 }
32539 arg1 = reinterpret_cast< wxWindow * >(argp1);
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32543 wxPyEndAllowThreads(__tstate);
32544 if (PyErr_Occurred()) SWIG_fail;
32545 }
32546 resultobj = SWIG_From_int(static_cast< int >(result));
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32554 PyObject *resultobj = 0;
32555 wxWindow *arg1 = (wxWindow *) 0 ;
32556 int result;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 PyObject *swig_obj[1] ;
32560
32561 if (!args) SWIG_fail;
32562 swig_obj[0] = args;
32563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32564 if (!SWIG_IsOK(res1)) {
32565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32566 }
32567 arg1 = reinterpret_cast< wxWindow * >(argp1);
32568 {
32569 PyThreadState* __tstate = wxPyBeginAllowThreads();
32570 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32571 wxPyEndAllowThreads(__tstate);
32572 if (PyErr_Occurred()) SWIG_fail;
32573 }
32574 resultobj = SWIG_From_int(static_cast< int >(result));
32575 return resultobj;
32576 fail:
32577 return NULL;
32578 }
32579
32580
32581 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32582 PyObject *resultobj = 0;
32583 wxWindow *arg1 = (wxWindow *) 0 ;
32584 int result;
32585 void *argp1 = 0 ;
32586 int res1 = 0 ;
32587 PyObject *swig_obj[1] ;
32588
32589 if (!args) SWIG_fail;
32590 swig_obj[0] = args;
32591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32592 if (!SWIG_IsOK(res1)) {
32593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32594 }
32595 arg1 = reinterpret_cast< wxWindow * >(argp1);
32596 {
32597 PyThreadState* __tstate = wxPyBeginAllowThreads();
32598 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32599 wxPyEndAllowThreads(__tstate);
32600 if (PyErr_Occurred()) SWIG_fail;
32601 }
32602 resultobj = SWIG_From_int(static_cast< int >(result));
32603 return resultobj;
32604 fail:
32605 return NULL;
32606 }
32607
32608
32609 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32610 PyObject *resultobj = 0;
32611 wxWindow *arg1 = (wxWindow *) 0 ;
32612 wxSize *arg2 = 0 ;
32613 void *argp1 = 0 ;
32614 int res1 = 0 ;
32615 wxSize temp2 ;
32616 PyObject * obj0 = 0 ;
32617 PyObject * obj1 = 0 ;
32618 char * kwnames[] = {
32619 (char *) "self",(char *) "size", NULL
32620 };
32621
32622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32624 if (!SWIG_IsOK(res1)) {
32625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32626 }
32627 arg1 = reinterpret_cast< wxWindow * >(argp1);
32628 {
32629 arg2 = &temp2;
32630 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32631 }
32632 {
32633 PyThreadState* __tstate = wxPyBeginAllowThreads();
32634 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32635 wxPyEndAllowThreads(__tstate);
32636 if (PyErr_Occurred()) SWIG_fail;
32637 }
32638 resultobj = SWIG_Py_Void();
32639 return resultobj;
32640 fail:
32641 return NULL;
32642 }
32643
32644
32645 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32646 PyObject *resultobj = 0;
32647 wxWindow *arg1 = (wxWindow *) 0 ;
32648 int arg2 ;
32649 int arg3 ;
32650 void *argp1 = 0 ;
32651 int res1 = 0 ;
32652 int val2 ;
32653 int ecode2 = 0 ;
32654 int val3 ;
32655 int ecode3 = 0 ;
32656 PyObject * obj0 = 0 ;
32657 PyObject * obj1 = 0 ;
32658 PyObject * obj2 = 0 ;
32659 char * kwnames[] = {
32660 (char *) "self",(char *) "w",(char *) "h", NULL
32661 };
32662
32663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32665 if (!SWIG_IsOK(res1)) {
32666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32667 }
32668 arg1 = reinterpret_cast< wxWindow * >(argp1);
32669 ecode2 = SWIG_AsVal_int(obj1, &val2);
32670 if (!SWIG_IsOK(ecode2)) {
32671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32672 }
32673 arg2 = static_cast< int >(val2);
32674 ecode3 = SWIG_AsVal_int(obj2, &val3);
32675 if (!SWIG_IsOK(ecode3)) {
32676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32677 }
32678 arg3 = static_cast< int >(val3);
32679 {
32680 PyThreadState* __tstate = wxPyBeginAllowThreads();
32681 (arg1)->SetVirtualSize(arg2,arg3);
32682 wxPyEndAllowThreads(__tstate);
32683 if (PyErr_Occurred()) SWIG_fail;
32684 }
32685 resultobj = SWIG_Py_Void();
32686 return resultobj;
32687 fail:
32688 return NULL;
32689 }
32690
32691
32692 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32693 PyObject *resultobj = 0;
32694 wxWindow *arg1 = (wxWindow *) 0 ;
32695 wxSize result;
32696 void *argp1 = 0 ;
32697 int res1 = 0 ;
32698 PyObject *swig_obj[1] ;
32699
32700 if (!args) SWIG_fail;
32701 swig_obj[0] = args;
32702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 {
32708 PyThreadState* __tstate = wxPyBeginAllowThreads();
32709 result = ((wxWindow const *)arg1)->GetVirtualSize();
32710 wxPyEndAllowThreads(__tstate);
32711 if (PyErr_Occurred()) SWIG_fail;
32712 }
32713 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32714 return resultobj;
32715 fail:
32716 return NULL;
32717 }
32718
32719
32720 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32721 PyObject *resultobj = 0;
32722 wxWindow *arg1 = (wxWindow *) 0 ;
32723 int *arg2 = (int *) 0 ;
32724 int *arg3 = (int *) 0 ;
32725 void *argp1 = 0 ;
32726 int res1 = 0 ;
32727 int temp2 ;
32728 int res2 = SWIG_TMPOBJ ;
32729 int temp3 ;
32730 int res3 = SWIG_TMPOBJ ;
32731 PyObject *swig_obj[1] ;
32732
32733 arg2 = &temp2;
32734 arg3 = &temp3;
32735 if (!args) SWIG_fail;
32736 swig_obj[0] = args;
32737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32740 }
32741 arg1 = reinterpret_cast< wxWindow * >(argp1);
32742 {
32743 PyThreadState* __tstate = wxPyBeginAllowThreads();
32744 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 resultobj = SWIG_Py_Void();
32749 if (SWIG_IsTmpObj(res2)) {
32750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32751 } else {
32752 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32754 }
32755 if (SWIG_IsTmpObj(res3)) {
32756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32757 } else {
32758 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32760 }
32761 return resultobj;
32762 fail:
32763 return NULL;
32764 }
32765
32766
32767 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32768 PyObject *resultobj = 0;
32769 wxWindow *arg1 = (wxWindow *) 0 ;
32770 wxSize result;
32771 void *argp1 = 0 ;
32772 int res1 = 0 ;
32773 PyObject *swig_obj[1] ;
32774
32775 if (!args) SWIG_fail;
32776 swig_obj[0] = args;
32777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32778 if (!SWIG_IsOK(res1)) {
32779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32780 }
32781 arg1 = reinterpret_cast< wxWindow * >(argp1);
32782 {
32783 PyThreadState* __tstate = wxPyBeginAllowThreads();
32784 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32785 wxPyEndAllowThreads(__tstate);
32786 if (PyErr_Occurred()) SWIG_fail;
32787 }
32788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32796 PyObject *resultobj = 0;
32797 wxWindow *arg1 = (wxWindow *) 0 ;
32798 bool arg2 = (bool) true ;
32799 bool result;
32800 void *argp1 = 0 ;
32801 int res1 = 0 ;
32802 bool val2 ;
32803 int ecode2 = 0 ;
32804 PyObject * obj0 = 0 ;
32805 PyObject * obj1 = 0 ;
32806 char * kwnames[] = {
32807 (char *) "self",(char *) "show", NULL
32808 };
32809
32810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32812 if (!SWIG_IsOK(res1)) {
32813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32814 }
32815 arg1 = reinterpret_cast< wxWindow * >(argp1);
32816 if (obj1) {
32817 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32818 if (!SWIG_IsOK(ecode2)) {
32819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32820 }
32821 arg2 = static_cast< bool >(val2);
32822 }
32823 {
32824 PyThreadState* __tstate = wxPyBeginAllowThreads();
32825 result = (bool)(arg1)->Show(arg2);
32826 wxPyEndAllowThreads(__tstate);
32827 if (PyErr_Occurred()) SWIG_fail;
32828 }
32829 {
32830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32831 }
32832 return resultobj;
32833 fail:
32834 return NULL;
32835 }
32836
32837
32838 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32839 PyObject *resultobj = 0;
32840 wxWindow *arg1 = (wxWindow *) 0 ;
32841 bool result;
32842 void *argp1 = 0 ;
32843 int res1 = 0 ;
32844 PyObject *swig_obj[1] ;
32845
32846 if (!args) SWIG_fail;
32847 swig_obj[0] = args;
32848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32849 if (!SWIG_IsOK(res1)) {
32850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32851 }
32852 arg1 = reinterpret_cast< wxWindow * >(argp1);
32853 {
32854 PyThreadState* __tstate = wxPyBeginAllowThreads();
32855 result = (bool)(arg1)->Hide();
32856 wxPyEndAllowThreads(__tstate);
32857 if (PyErr_Occurred()) SWIG_fail;
32858 }
32859 {
32860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32861 }
32862 return resultobj;
32863 fail:
32864 return NULL;
32865 }
32866
32867
32868 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32869 PyObject *resultobj = 0;
32870 wxWindow *arg1 = (wxWindow *) 0 ;
32871 bool arg2 = (bool) true ;
32872 bool result;
32873 void *argp1 = 0 ;
32874 int res1 = 0 ;
32875 bool val2 ;
32876 int ecode2 = 0 ;
32877 PyObject * obj0 = 0 ;
32878 PyObject * obj1 = 0 ;
32879 char * kwnames[] = {
32880 (char *) "self",(char *) "enable", NULL
32881 };
32882
32883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32885 if (!SWIG_IsOK(res1)) {
32886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32887 }
32888 arg1 = reinterpret_cast< wxWindow * >(argp1);
32889 if (obj1) {
32890 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32891 if (!SWIG_IsOK(ecode2)) {
32892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32893 }
32894 arg2 = static_cast< bool >(val2);
32895 }
32896 {
32897 PyThreadState* __tstate = wxPyBeginAllowThreads();
32898 result = (bool)(arg1)->Enable(arg2);
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 {
32903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32904 }
32905 return resultobj;
32906 fail:
32907 return NULL;
32908 }
32909
32910
32911 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32912 PyObject *resultobj = 0;
32913 wxWindow *arg1 = (wxWindow *) 0 ;
32914 bool result;
32915 void *argp1 = 0 ;
32916 int res1 = 0 ;
32917 PyObject *swig_obj[1] ;
32918
32919 if (!args) SWIG_fail;
32920 swig_obj[0] = args;
32921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32922 if (!SWIG_IsOK(res1)) {
32923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32924 }
32925 arg1 = reinterpret_cast< wxWindow * >(argp1);
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (bool)(arg1)->Disable();
32929 wxPyEndAllowThreads(__tstate);
32930 if (PyErr_Occurred()) SWIG_fail;
32931 }
32932 {
32933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32934 }
32935 return resultobj;
32936 fail:
32937 return NULL;
32938 }
32939
32940
32941 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32942 PyObject *resultobj = 0;
32943 wxWindow *arg1 = (wxWindow *) 0 ;
32944 bool result;
32945 void *argp1 = 0 ;
32946 int res1 = 0 ;
32947 PyObject *swig_obj[1] ;
32948
32949 if (!args) SWIG_fail;
32950 swig_obj[0] = args;
32951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32952 if (!SWIG_IsOK(res1)) {
32953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32954 }
32955 arg1 = reinterpret_cast< wxWindow * >(argp1);
32956 {
32957 PyThreadState* __tstate = wxPyBeginAllowThreads();
32958 result = (bool)((wxWindow const *)arg1)->IsShown();
32959 wxPyEndAllowThreads(__tstate);
32960 if (PyErr_Occurred()) SWIG_fail;
32961 }
32962 {
32963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32964 }
32965 return resultobj;
32966 fail:
32967 return NULL;
32968 }
32969
32970
32971 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32972 PyObject *resultobj = 0;
32973 wxWindow *arg1 = (wxWindow *) 0 ;
32974 bool result;
32975 void *argp1 = 0 ;
32976 int res1 = 0 ;
32977 PyObject *swig_obj[1] ;
32978
32979 if (!args) SWIG_fail;
32980 swig_obj[0] = args;
32981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32982 if (!SWIG_IsOK(res1)) {
32983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32984 }
32985 arg1 = reinterpret_cast< wxWindow * >(argp1);
32986 {
32987 PyThreadState* __tstate = wxPyBeginAllowThreads();
32988 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32989 wxPyEndAllowThreads(__tstate);
32990 if (PyErr_Occurred()) SWIG_fail;
32991 }
32992 {
32993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32994 }
32995 return resultobj;
32996 fail:
32997 return NULL;
32998 }
32999
33000
33001 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33002 PyObject *resultobj = 0;
33003 wxWindow *arg1 = (wxWindow *) 0 ;
33004 bool result;
33005 void *argp1 = 0 ;
33006 int res1 = 0 ;
33007 PyObject *swig_obj[1] ;
33008
33009 if (!args) SWIG_fail;
33010 swig_obj[0] = args;
33011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33014 }
33015 arg1 = reinterpret_cast< wxWindow * >(argp1);
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33019 wxPyEndAllowThreads(__tstate);
33020 if (PyErr_Occurred()) SWIG_fail;
33021 }
33022 {
33023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33024 }
33025 return resultobj;
33026 fail:
33027 return NULL;
33028 }
33029
33030
33031 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33032 PyObject *resultobj = 0;
33033 wxWindow *arg1 = (wxWindow *) 0 ;
33034 long arg2 ;
33035 void *argp1 = 0 ;
33036 int res1 = 0 ;
33037 long val2 ;
33038 int ecode2 = 0 ;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 char * kwnames[] = {
33042 (char *) "self",(char *) "style", NULL
33043 };
33044
33045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33049 }
33050 arg1 = reinterpret_cast< wxWindow * >(argp1);
33051 ecode2 = SWIG_AsVal_long(obj1, &val2);
33052 if (!SWIG_IsOK(ecode2)) {
33053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33054 }
33055 arg2 = static_cast< long >(val2);
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 (arg1)->SetWindowStyleFlag(arg2);
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 resultobj = SWIG_Py_Void();
33063 return resultobj;
33064 fail:
33065 return NULL;
33066 }
33067
33068
33069 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33070 PyObject *resultobj = 0;
33071 wxWindow *arg1 = (wxWindow *) 0 ;
33072 long result;
33073 void *argp1 = 0 ;
33074 int res1 = 0 ;
33075 PyObject *swig_obj[1] ;
33076
33077 if (!args) SWIG_fail;
33078 swig_obj[0] = args;
33079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33080 if (!SWIG_IsOK(res1)) {
33081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33082 }
33083 arg1 = reinterpret_cast< wxWindow * >(argp1);
33084 {
33085 PyThreadState* __tstate = wxPyBeginAllowThreads();
33086 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33087 wxPyEndAllowThreads(__tstate);
33088 if (PyErr_Occurred()) SWIG_fail;
33089 }
33090 resultobj = SWIG_From_long(static_cast< long >(result));
33091 return resultobj;
33092 fail:
33093 return NULL;
33094 }
33095
33096
33097 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33098 PyObject *resultobj = 0;
33099 wxWindow *arg1 = (wxWindow *) 0 ;
33100 int arg2 ;
33101 bool result;
33102 void *argp1 = 0 ;
33103 int res1 = 0 ;
33104 int val2 ;
33105 int ecode2 = 0 ;
33106 PyObject * obj0 = 0 ;
33107 PyObject * obj1 = 0 ;
33108 char * kwnames[] = {
33109 (char *) "self",(char *) "flag", NULL
33110 };
33111
33112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33114 if (!SWIG_IsOK(res1)) {
33115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33116 }
33117 arg1 = reinterpret_cast< wxWindow * >(argp1);
33118 ecode2 = SWIG_AsVal_int(obj1, &val2);
33119 if (!SWIG_IsOK(ecode2)) {
33120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33121 }
33122 arg2 = static_cast< int >(val2);
33123 {
33124 PyThreadState* __tstate = wxPyBeginAllowThreads();
33125 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33126 wxPyEndAllowThreads(__tstate);
33127 if (PyErr_Occurred()) SWIG_fail;
33128 }
33129 {
33130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33131 }
33132 return resultobj;
33133 fail:
33134 return NULL;
33135 }
33136
33137
33138 SWIGINTERN PyObject *_wrap_Window_IsRetained(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_IsRetained" "', 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)->IsRetained();
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_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33169 PyObject *resultobj = 0;
33170 wxWindow *arg1 = (wxWindow *) 0 ;
33171 long arg2 ;
33172 void *argp1 = 0 ;
33173 int res1 = 0 ;
33174 long val2 ;
33175 int ecode2 = 0 ;
33176 PyObject * obj0 = 0 ;
33177 PyObject * obj1 = 0 ;
33178 char * kwnames[] = {
33179 (char *) "self",(char *) "exStyle", NULL
33180 };
33181
33182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33184 if (!SWIG_IsOK(res1)) {
33185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33186 }
33187 arg1 = reinterpret_cast< wxWindow * >(argp1);
33188 ecode2 = SWIG_AsVal_long(obj1, &val2);
33189 if (!SWIG_IsOK(ecode2)) {
33190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33191 }
33192 arg2 = static_cast< long >(val2);
33193 {
33194 PyThreadState* __tstate = wxPyBeginAllowThreads();
33195 (arg1)->SetExtraStyle(arg2);
33196 wxPyEndAllowThreads(__tstate);
33197 if (PyErr_Occurred()) SWIG_fail;
33198 }
33199 resultobj = SWIG_Py_Void();
33200 return resultobj;
33201 fail:
33202 return NULL;
33203 }
33204
33205
33206 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33207 PyObject *resultobj = 0;
33208 wxWindow *arg1 = (wxWindow *) 0 ;
33209 long result;
33210 void *argp1 = 0 ;
33211 int res1 = 0 ;
33212 PyObject *swig_obj[1] ;
33213
33214 if (!args) SWIG_fail;
33215 swig_obj[0] = args;
33216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33217 if (!SWIG_IsOK(res1)) {
33218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33219 }
33220 arg1 = reinterpret_cast< wxWindow * >(argp1);
33221 {
33222 PyThreadState* __tstate = wxPyBeginAllowThreads();
33223 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33224 wxPyEndAllowThreads(__tstate);
33225 if (PyErr_Occurred()) SWIG_fail;
33226 }
33227 resultobj = SWIG_From_long(static_cast< long >(result));
33228 return resultobj;
33229 fail:
33230 return NULL;
33231 }
33232
33233
33234 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33235 PyObject *resultobj = 0;
33236 wxWindow *arg1 = (wxWindow *) 0 ;
33237 bool arg2 = (bool) true ;
33238 void *argp1 = 0 ;
33239 int res1 = 0 ;
33240 bool val2 ;
33241 int ecode2 = 0 ;
33242 PyObject * obj0 = 0 ;
33243 PyObject * obj1 = 0 ;
33244 char * kwnames[] = {
33245 (char *) "self",(char *) "modal", NULL
33246 };
33247
33248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33250 if (!SWIG_IsOK(res1)) {
33251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33252 }
33253 arg1 = reinterpret_cast< wxWindow * >(argp1);
33254 if (obj1) {
33255 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33256 if (!SWIG_IsOK(ecode2)) {
33257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33258 }
33259 arg2 = static_cast< bool >(val2);
33260 }
33261 {
33262 PyThreadState* __tstate = wxPyBeginAllowThreads();
33263 (arg1)->MakeModal(arg2);
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 resultobj = SWIG_Py_Void();
33268 return resultobj;
33269 fail:
33270 return NULL;
33271 }
33272
33273
33274 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33275 PyObject *resultobj = 0;
33276 wxWindow *arg1 = (wxWindow *) 0 ;
33277 bool arg2 ;
33278 void *argp1 = 0 ;
33279 int res1 = 0 ;
33280 bool val2 ;
33281 int ecode2 = 0 ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 char * kwnames[] = {
33285 (char *) "self",(char *) "enableTheme", NULL
33286 };
33287
33288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33292 }
33293 arg1 = reinterpret_cast< wxWindow * >(argp1);
33294 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33295 if (!SWIG_IsOK(ecode2)) {
33296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33297 }
33298 arg2 = static_cast< bool >(val2);
33299 {
33300 PyThreadState* __tstate = wxPyBeginAllowThreads();
33301 (arg1)->SetThemeEnabled(arg2);
33302 wxPyEndAllowThreads(__tstate);
33303 if (PyErr_Occurred()) SWIG_fail;
33304 }
33305 resultobj = SWIG_Py_Void();
33306 return resultobj;
33307 fail:
33308 return NULL;
33309 }
33310
33311
33312 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33313 PyObject *resultobj = 0;
33314 wxWindow *arg1 = (wxWindow *) 0 ;
33315 bool result;
33316 void *argp1 = 0 ;
33317 int res1 = 0 ;
33318 PyObject *swig_obj[1] ;
33319
33320 if (!args) SWIG_fail;
33321 swig_obj[0] = args;
33322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33323 if (!SWIG_IsOK(res1)) {
33324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33325 }
33326 arg1 = reinterpret_cast< wxWindow * >(argp1);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 {
33334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33335 }
33336 return resultobj;
33337 fail:
33338 return NULL;
33339 }
33340
33341
33342 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33343 PyObject *resultobj = 0;
33344 wxWindow *arg1 = (wxWindow *) 0 ;
33345 void *argp1 = 0 ;
33346 int res1 = 0 ;
33347 PyObject *swig_obj[1] ;
33348
33349 if (!args) SWIG_fail;
33350 swig_obj[0] = args;
33351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33352 if (!SWIG_IsOK(res1)) {
33353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33354 }
33355 arg1 = reinterpret_cast< wxWindow * >(argp1);
33356 {
33357 PyThreadState* __tstate = wxPyBeginAllowThreads();
33358 (arg1)->SetFocus();
33359 wxPyEndAllowThreads(__tstate);
33360 if (PyErr_Occurred()) SWIG_fail;
33361 }
33362 resultobj = SWIG_Py_Void();
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33370 PyObject *resultobj = 0;
33371 wxWindow *arg1 = (wxWindow *) 0 ;
33372 void *argp1 = 0 ;
33373 int res1 = 0 ;
33374 PyObject *swig_obj[1] ;
33375
33376 if (!args) SWIG_fail;
33377 swig_obj[0] = args;
33378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33379 if (!SWIG_IsOK(res1)) {
33380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33381 }
33382 arg1 = reinterpret_cast< wxWindow * >(argp1);
33383 {
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 (arg1)->SetFocusFromKbd();
33386 wxPyEndAllowThreads(__tstate);
33387 if (PyErr_Occurred()) SWIG_fail;
33388 }
33389 resultobj = SWIG_Py_Void();
33390 return resultobj;
33391 fail:
33392 return NULL;
33393 }
33394
33395
33396 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33397 PyObject *resultobj = 0;
33398 wxWindow *result = 0 ;
33399
33400 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33401 {
33402 if (!wxPyCheckForApp()) SWIG_fail;
33403 PyThreadState* __tstate = wxPyBeginAllowThreads();
33404 result = (wxWindow *)wxWindow::FindFocus();
33405 wxPyEndAllowThreads(__tstate);
33406 if (PyErr_Occurred()) SWIG_fail;
33407 }
33408 {
33409 resultobj = wxPyMake_wxObject(result, 0);
33410 }
33411 return resultobj;
33412 fail:
33413 return NULL;
33414 }
33415
33416
33417 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33418 PyObject *resultobj = 0;
33419 wxWindow *arg1 = (wxWindow *) 0 ;
33420 bool result;
33421 void *argp1 = 0 ;
33422 int res1 = 0 ;
33423 PyObject *swig_obj[1] ;
33424
33425 if (!args) SWIG_fail;
33426 swig_obj[0] = args;
33427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33428 if (!SWIG_IsOK(res1)) {
33429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33430 }
33431 arg1 = reinterpret_cast< wxWindow * >(argp1);
33432 {
33433 PyThreadState* __tstate = wxPyBeginAllowThreads();
33434 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33435 wxPyEndAllowThreads(__tstate);
33436 if (PyErr_Occurred()) SWIG_fail;
33437 }
33438 {
33439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33440 }
33441 return resultobj;
33442 fail:
33443 return NULL;
33444 }
33445
33446
33447 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33448 PyObject *resultobj = 0;
33449 wxWindow *arg1 = (wxWindow *) 0 ;
33450 bool result;
33451 void *argp1 = 0 ;
33452 int res1 = 0 ;
33453 PyObject *swig_obj[1] ;
33454
33455 if (!args) SWIG_fail;
33456 swig_obj[0] = args;
33457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33458 if (!SWIG_IsOK(res1)) {
33459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33460 }
33461 arg1 = reinterpret_cast< wxWindow * >(argp1);
33462 {
33463 PyThreadState* __tstate = wxPyBeginAllowThreads();
33464 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33465 wxPyEndAllowThreads(__tstate);
33466 if (PyErr_Occurred()) SWIG_fail;
33467 }
33468 {
33469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33470 }
33471 return resultobj;
33472 fail:
33473 return NULL;
33474 }
33475
33476
33477 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33478 PyObject *resultobj = 0;
33479 wxWindow *arg1 = (wxWindow *) 0 ;
33480 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33481 bool result;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 int val2 ;
33485 int ecode2 = 0 ;
33486 PyObject * obj0 = 0 ;
33487 PyObject * obj1 = 0 ;
33488 char * kwnames[] = {
33489 (char *) "self",(char *) "flags", NULL
33490 };
33491
33492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33494 if (!SWIG_IsOK(res1)) {
33495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33496 }
33497 arg1 = reinterpret_cast< wxWindow * >(argp1);
33498 if (obj1) {
33499 ecode2 = SWIG_AsVal_int(obj1, &val2);
33500 if (!SWIG_IsOK(ecode2)) {
33501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33502 }
33503 arg2 = static_cast< int >(val2);
33504 }
33505 {
33506 PyThreadState* __tstate = wxPyBeginAllowThreads();
33507 result = (bool)(arg1)->Navigate(arg2);
33508 wxPyEndAllowThreads(__tstate);
33509 if (PyErr_Occurred()) SWIG_fail;
33510 }
33511 {
33512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33513 }
33514 return resultobj;
33515 fail:
33516 return NULL;
33517 }
33518
33519
33520 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj = 0;
33522 wxWindow *arg1 = (wxWindow *) 0 ;
33523 wxWindow *arg2 = (wxWindow *) 0 ;
33524 void *argp1 = 0 ;
33525 int res1 = 0 ;
33526 void *argp2 = 0 ;
33527 int res2 = 0 ;
33528 PyObject * obj0 = 0 ;
33529 PyObject * obj1 = 0 ;
33530 char * kwnames[] = {
33531 (char *) "self",(char *) "win", NULL
33532 };
33533
33534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33536 if (!SWIG_IsOK(res1)) {
33537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33538 }
33539 arg1 = reinterpret_cast< wxWindow * >(argp1);
33540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33541 if (!SWIG_IsOK(res2)) {
33542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33543 }
33544 arg2 = reinterpret_cast< wxWindow * >(argp2);
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 (arg1)->MoveAfterInTabOrder(arg2);
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 resultobj = SWIG_Py_Void();
33552 return resultobj;
33553 fail:
33554 return NULL;
33555 }
33556
33557
33558 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33559 PyObject *resultobj = 0;
33560 wxWindow *arg1 = (wxWindow *) 0 ;
33561 wxWindow *arg2 = (wxWindow *) 0 ;
33562 void *argp1 = 0 ;
33563 int res1 = 0 ;
33564 void *argp2 = 0 ;
33565 int res2 = 0 ;
33566 PyObject * obj0 = 0 ;
33567 PyObject * obj1 = 0 ;
33568 char * kwnames[] = {
33569 (char *) "self",(char *) "win", NULL
33570 };
33571
33572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33574 if (!SWIG_IsOK(res1)) {
33575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33576 }
33577 arg1 = reinterpret_cast< wxWindow * >(argp1);
33578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33579 if (!SWIG_IsOK(res2)) {
33580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33581 }
33582 arg2 = reinterpret_cast< wxWindow * >(argp2);
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 (arg1)->MoveBeforeInTabOrder(arg2);
33586 wxPyEndAllowThreads(__tstate);
33587 if (PyErr_Occurred()) SWIG_fail;
33588 }
33589 resultobj = SWIG_Py_Void();
33590 return resultobj;
33591 fail:
33592 return NULL;
33593 }
33594
33595
33596 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33597 PyObject *resultobj = 0;
33598 wxWindow *arg1 = (wxWindow *) 0 ;
33599 PyObject *result = 0 ;
33600 void *argp1 = 0 ;
33601 int res1 = 0 ;
33602 PyObject *swig_obj[1] ;
33603
33604 if (!args) SWIG_fail;
33605 swig_obj[0] = args;
33606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33607 if (!SWIG_IsOK(res1)) {
33608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33609 }
33610 arg1 = reinterpret_cast< wxWindow * >(argp1);
33611 {
33612 PyThreadState* __tstate = wxPyBeginAllowThreads();
33613 result = (PyObject *)wxWindow_GetChildren(arg1);
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 resultobj = result;
33618 return resultobj;
33619 fail:
33620 return NULL;
33621 }
33622
33623
33624 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33625 PyObject *resultobj = 0;
33626 wxWindow *arg1 = (wxWindow *) 0 ;
33627 wxWindow *result = 0 ;
33628 void *argp1 = 0 ;
33629 int res1 = 0 ;
33630 PyObject *swig_obj[1] ;
33631
33632 if (!args) SWIG_fail;
33633 swig_obj[0] = args;
33634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33635 if (!SWIG_IsOK(res1)) {
33636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33637 }
33638 arg1 = reinterpret_cast< wxWindow * >(argp1);
33639 {
33640 PyThreadState* __tstate = wxPyBeginAllowThreads();
33641 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33642 wxPyEndAllowThreads(__tstate);
33643 if (PyErr_Occurred()) SWIG_fail;
33644 }
33645 {
33646 resultobj = wxPyMake_wxObject(result, 0);
33647 }
33648 return resultobj;
33649 fail:
33650 return NULL;
33651 }
33652
33653
33654 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33655 PyObject *resultobj = 0;
33656 wxWindow *arg1 = (wxWindow *) 0 ;
33657 wxWindow *result = 0 ;
33658 void *argp1 = 0 ;
33659 int res1 = 0 ;
33660 PyObject *swig_obj[1] ;
33661
33662 if (!args) SWIG_fail;
33663 swig_obj[0] = args;
33664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33665 if (!SWIG_IsOK(res1)) {
33666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33667 }
33668 arg1 = reinterpret_cast< wxWindow * >(argp1);
33669 {
33670 PyThreadState* __tstate = wxPyBeginAllowThreads();
33671 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33672 wxPyEndAllowThreads(__tstate);
33673 if (PyErr_Occurred()) SWIG_fail;
33674 }
33675 {
33676 resultobj = wxPyMake_wxObject(result, 0);
33677 }
33678 return resultobj;
33679 fail:
33680 return NULL;
33681 }
33682
33683
33684 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33685 PyObject *resultobj = 0;
33686 wxWindow *arg1 = (wxWindow *) 0 ;
33687 bool result;
33688 void *argp1 = 0 ;
33689 int res1 = 0 ;
33690 PyObject *swig_obj[1] ;
33691
33692 if (!args) SWIG_fail;
33693 swig_obj[0] = args;
33694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33695 if (!SWIG_IsOK(res1)) {
33696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33697 }
33698 arg1 = reinterpret_cast< wxWindow * >(argp1);
33699 {
33700 PyThreadState* __tstate = wxPyBeginAllowThreads();
33701 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33702 wxPyEndAllowThreads(__tstate);
33703 if (PyErr_Occurred()) SWIG_fail;
33704 }
33705 {
33706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33707 }
33708 return resultobj;
33709 fail:
33710 return NULL;
33711 }
33712
33713
33714 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33715 PyObject *resultobj = 0;
33716 wxWindow *arg1 = (wxWindow *) 0 ;
33717 wxWindow *arg2 = (wxWindow *) 0 ;
33718 bool result;
33719 void *argp1 = 0 ;
33720 int res1 = 0 ;
33721 void *argp2 = 0 ;
33722 int res2 = 0 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 char * kwnames[] = {
33726 (char *) "self",(char *) "newParent", NULL
33727 };
33728
33729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33731 if (!SWIG_IsOK(res1)) {
33732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33733 }
33734 arg1 = reinterpret_cast< wxWindow * >(argp1);
33735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33736 if (!SWIG_IsOK(res2)) {
33737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33738 }
33739 arg2 = reinterpret_cast< wxWindow * >(argp2);
33740 {
33741 PyThreadState* __tstate = wxPyBeginAllowThreads();
33742 result = (bool)(arg1)->Reparent(arg2);
33743 wxPyEndAllowThreads(__tstate);
33744 if (PyErr_Occurred()) SWIG_fail;
33745 }
33746 {
33747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33748 }
33749 return resultobj;
33750 fail:
33751 return NULL;
33752 }
33753
33754
33755 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33756 PyObject *resultobj = 0;
33757 wxWindow *arg1 = (wxWindow *) 0 ;
33758 wxWindow *arg2 = (wxWindow *) 0 ;
33759 void *argp1 = 0 ;
33760 int res1 = 0 ;
33761 void *argp2 = 0 ;
33762 int res2 = 0 ;
33763 PyObject * obj0 = 0 ;
33764 PyObject * obj1 = 0 ;
33765 char * kwnames[] = {
33766 (char *) "self",(char *) "child", NULL
33767 };
33768
33769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33773 }
33774 arg1 = reinterpret_cast< wxWindow * >(argp1);
33775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33776 if (!SWIG_IsOK(res2)) {
33777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33778 }
33779 arg2 = reinterpret_cast< wxWindow * >(argp2);
33780 {
33781 PyThreadState* __tstate = wxPyBeginAllowThreads();
33782 (arg1)->AddChild(arg2);
33783 wxPyEndAllowThreads(__tstate);
33784 if (PyErr_Occurred()) SWIG_fail;
33785 }
33786 resultobj = SWIG_Py_Void();
33787 return resultobj;
33788 fail:
33789 return NULL;
33790 }
33791
33792
33793 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33794 PyObject *resultobj = 0;
33795 wxWindow *arg1 = (wxWindow *) 0 ;
33796 wxWindow *arg2 = (wxWindow *) 0 ;
33797 void *argp1 = 0 ;
33798 int res1 = 0 ;
33799 void *argp2 = 0 ;
33800 int res2 = 0 ;
33801 PyObject * obj0 = 0 ;
33802 PyObject * obj1 = 0 ;
33803 char * kwnames[] = {
33804 (char *) "self",(char *) "child", NULL
33805 };
33806
33807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33809 if (!SWIG_IsOK(res1)) {
33810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33811 }
33812 arg1 = reinterpret_cast< wxWindow * >(argp1);
33813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33814 if (!SWIG_IsOK(res2)) {
33815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33816 }
33817 arg2 = reinterpret_cast< wxWindow * >(argp2);
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 (arg1)->RemoveChild(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_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33832 PyObject *resultobj = 0;
33833 wxWindow *arg1 = (wxWindow *) 0 ;
33834 bool arg2 ;
33835 void *argp1 = 0 ;
33836 int res1 = 0 ;
33837 bool val2 ;
33838 int ecode2 = 0 ;
33839 PyObject * obj0 = 0 ;
33840 PyObject * obj1 = 0 ;
33841 char * kwnames[] = {
33842 (char *) "self",(char *) "on", NULL
33843 };
33844
33845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33847 if (!SWIG_IsOK(res1)) {
33848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33849 }
33850 arg1 = reinterpret_cast< wxWindow * >(argp1);
33851 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33852 if (!SWIG_IsOK(ecode2)) {
33853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33854 }
33855 arg2 = static_cast< bool >(val2);
33856 {
33857 PyThreadState* __tstate = wxPyBeginAllowThreads();
33858 (arg1)->SetDoubleBuffered(arg2);
33859 wxPyEndAllowThreads(__tstate);
33860 if (PyErr_Occurred()) SWIG_fail;
33861 }
33862 resultobj = SWIG_Py_Void();
33863 return resultobj;
33864 fail:
33865 return NULL;
33866 }
33867
33868
33869 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33870 PyObject *resultobj = 0;
33871 wxWindow *arg1 = (wxWindow *) 0 ;
33872 long arg2 ;
33873 wxWindow *result = 0 ;
33874 void *argp1 = 0 ;
33875 int res1 = 0 ;
33876 long val2 ;
33877 int ecode2 = 0 ;
33878 PyObject * obj0 = 0 ;
33879 PyObject * obj1 = 0 ;
33880 char * kwnames[] = {
33881 (char *) "self",(char *) "winid", NULL
33882 };
33883
33884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33886 if (!SWIG_IsOK(res1)) {
33887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33888 }
33889 arg1 = reinterpret_cast< wxWindow * >(argp1);
33890 ecode2 = SWIG_AsVal_long(obj1, &val2);
33891 if (!SWIG_IsOK(ecode2)) {
33892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33893 }
33894 arg2 = static_cast< long >(val2);
33895 {
33896 PyThreadState* __tstate = wxPyBeginAllowThreads();
33897 result = (wxWindow *)(arg1)->FindWindow(arg2);
33898 wxPyEndAllowThreads(__tstate);
33899 if (PyErr_Occurred()) SWIG_fail;
33900 }
33901 {
33902 resultobj = wxPyMake_wxObject(result, 0);
33903 }
33904 return resultobj;
33905 fail:
33906 return NULL;
33907 }
33908
33909
33910 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33911 PyObject *resultobj = 0;
33912 wxWindow *arg1 = (wxWindow *) 0 ;
33913 wxString *arg2 = 0 ;
33914 wxWindow *result = 0 ;
33915 void *argp1 = 0 ;
33916 int res1 = 0 ;
33917 bool temp2 = false ;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 char * kwnames[] = {
33921 (char *) "self",(char *) "name", NULL
33922 };
33923
33924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33926 if (!SWIG_IsOK(res1)) {
33927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33928 }
33929 arg1 = reinterpret_cast< wxWindow * >(argp1);
33930 {
33931 arg2 = wxString_in_helper(obj1);
33932 if (arg2 == NULL) SWIG_fail;
33933 temp2 = true;
33934 }
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 {
33942 resultobj = wxPyMake_wxObject(result, 0);
33943 }
33944 {
33945 if (temp2)
33946 delete arg2;
33947 }
33948 return resultobj;
33949 fail:
33950 {
33951 if (temp2)
33952 delete arg2;
33953 }
33954 return NULL;
33955 }
33956
33957
33958 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33959 PyObject *resultobj = 0;
33960 wxWindow *arg1 = (wxWindow *) 0 ;
33961 wxEvtHandler *result = 0 ;
33962 void *argp1 = 0 ;
33963 int res1 = 0 ;
33964 PyObject *swig_obj[1] ;
33965
33966 if (!args) SWIG_fail;
33967 swig_obj[0] = args;
33968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33969 if (!SWIG_IsOK(res1)) {
33970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33971 }
33972 arg1 = reinterpret_cast< wxWindow * >(argp1);
33973 {
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 {
33980 resultobj = wxPyMake_wxObject(result, 0);
33981 }
33982 return resultobj;
33983 fail:
33984 return NULL;
33985 }
33986
33987
33988 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33989 PyObject *resultobj = 0;
33990 wxWindow *arg1 = (wxWindow *) 0 ;
33991 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33992 void *argp1 = 0 ;
33993 int res1 = 0 ;
33994 void *argp2 = 0 ;
33995 int res2 = 0 ;
33996 PyObject * obj0 = 0 ;
33997 PyObject * obj1 = 0 ;
33998 char * kwnames[] = {
33999 (char *) "self",(char *) "handler", NULL
34000 };
34001
34002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34004 if (!SWIG_IsOK(res1)) {
34005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34006 }
34007 arg1 = reinterpret_cast< wxWindow * >(argp1);
34008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34009 if (!SWIG_IsOK(res2)) {
34010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34011 }
34012 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34013 {
34014 PyThreadState* __tstate = wxPyBeginAllowThreads();
34015 (arg1)->SetEventHandler(arg2);
34016 wxPyEndAllowThreads(__tstate);
34017 if (PyErr_Occurred()) SWIG_fail;
34018 }
34019 resultobj = SWIG_Py_Void();
34020 return resultobj;
34021 fail:
34022 return NULL;
34023 }
34024
34025
34026 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34027 PyObject *resultobj = 0;
34028 wxWindow *arg1 = (wxWindow *) 0 ;
34029 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34030 void *argp1 = 0 ;
34031 int res1 = 0 ;
34032 void *argp2 = 0 ;
34033 int res2 = 0 ;
34034 PyObject * obj0 = 0 ;
34035 PyObject * obj1 = 0 ;
34036 char * kwnames[] = {
34037 (char *) "self",(char *) "handler", NULL
34038 };
34039
34040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34042 if (!SWIG_IsOK(res1)) {
34043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34044 }
34045 arg1 = reinterpret_cast< wxWindow * >(argp1);
34046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34047 if (!SWIG_IsOK(res2)) {
34048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34049 }
34050 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 (arg1)->PushEventHandler(arg2);
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 resultobj = SWIG_Py_Void();
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34065 PyObject *resultobj = 0;
34066 wxWindow *arg1 = (wxWindow *) 0 ;
34067 bool arg2 = (bool) false ;
34068 wxEvtHandler *result = 0 ;
34069 void *argp1 = 0 ;
34070 int res1 = 0 ;
34071 bool val2 ;
34072 int ecode2 = 0 ;
34073 PyObject * obj0 = 0 ;
34074 PyObject * obj1 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "deleteHandler", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 if (obj1) {
34086 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34087 if (!SWIG_IsOK(ecode2)) {
34088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34089 }
34090 arg2 = static_cast< bool >(val2);
34091 }
34092 {
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34095 wxPyEndAllowThreads(__tstate);
34096 if (PyErr_Occurred()) SWIG_fail;
34097 }
34098 {
34099 resultobj = wxPyMake_wxObject(result, 0);
34100 }
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34111 bool result;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 void *argp2 = 0 ;
34115 int res2 = 0 ;
34116 PyObject * obj0 = 0 ;
34117 PyObject * obj1 = 0 ;
34118 char * kwnames[] = {
34119 (char *) "self",(char *) "handler", NULL
34120 };
34121
34122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34124 if (!SWIG_IsOK(res1)) {
34125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34126 }
34127 arg1 = reinterpret_cast< wxWindow * >(argp1);
34128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34129 if (!SWIG_IsOK(res2)) {
34130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34131 }
34132 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34133 {
34134 PyThreadState* __tstate = wxPyBeginAllowThreads();
34135 result = (bool)(arg1)->RemoveEventHandler(arg2);
34136 wxPyEndAllowThreads(__tstate);
34137 if (PyErr_Occurred()) SWIG_fail;
34138 }
34139 {
34140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34141 }
34142 return resultobj;
34143 fail:
34144 return NULL;
34145 }
34146
34147
34148 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34149 PyObject *resultobj = 0;
34150 wxWindow *arg1 = (wxWindow *) 0 ;
34151 wxValidator *arg2 = 0 ;
34152 void *argp1 = 0 ;
34153 int res1 = 0 ;
34154 void *argp2 = 0 ;
34155 int res2 = 0 ;
34156 PyObject * obj0 = 0 ;
34157 PyObject * obj1 = 0 ;
34158 char * kwnames[] = {
34159 (char *) "self",(char *) "validator", NULL
34160 };
34161
34162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34164 if (!SWIG_IsOK(res1)) {
34165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34166 }
34167 arg1 = reinterpret_cast< wxWindow * >(argp1);
34168 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34169 if (!SWIG_IsOK(res2)) {
34170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34171 }
34172 if (!argp2) {
34173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34174 }
34175 arg2 = reinterpret_cast< wxValidator * >(argp2);
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 (arg1)->SetValidator((wxValidator const &)*arg2);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_Py_Void();
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34190 PyObject *resultobj = 0;
34191 wxWindow *arg1 = (wxWindow *) 0 ;
34192 wxValidator *result = 0 ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 PyObject *swig_obj[1] ;
34196
34197 if (!args) SWIG_fail;
34198 swig_obj[0] = args;
34199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34200 if (!SWIG_IsOK(res1)) {
34201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34202 }
34203 arg1 = reinterpret_cast< wxWindow * >(argp1);
34204 {
34205 PyThreadState* __tstate = wxPyBeginAllowThreads();
34206 result = (wxValidator *)(arg1)->GetValidator();
34207 wxPyEndAllowThreads(__tstate);
34208 if (PyErr_Occurred()) SWIG_fail;
34209 }
34210 {
34211 resultobj = wxPyMake_wxObject(result, (bool)0);
34212 }
34213 return resultobj;
34214 fail:
34215 return NULL;
34216 }
34217
34218
34219 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34220 PyObject *resultobj = 0;
34221 wxWindow *arg1 = (wxWindow *) 0 ;
34222 bool result;
34223 void *argp1 = 0 ;
34224 int res1 = 0 ;
34225 PyObject *swig_obj[1] ;
34226
34227 if (!args) SWIG_fail;
34228 swig_obj[0] = args;
34229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34230 if (!SWIG_IsOK(res1)) {
34231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34232 }
34233 arg1 = reinterpret_cast< wxWindow * >(argp1);
34234 {
34235 PyThreadState* __tstate = wxPyBeginAllowThreads();
34236 result = (bool)(arg1)->Validate();
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 {
34241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34242 }
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34250 PyObject *resultobj = 0;
34251 wxWindow *arg1 = (wxWindow *) 0 ;
34252 bool result;
34253 void *argp1 = 0 ;
34254 int res1 = 0 ;
34255 PyObject *swig_obj[1] ;
34256
34257 if (!args) SWIG_fail;
34258 swig_obj[0] = args;
34259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34260 if (!SWIG_IsOK(res1)) {
34261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34262 }
34263 arg1 = reinterpret_cast< wxWindow * >(argp1);
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 result = (bool)(arg1)->TransferDataToWindow();
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 {
34271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34272 }
34273 return resultobj;
34274 fail:
34275 return NULL;
34276 }
34277
34278
34279 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34280 PyObject *resultobj = 0;
34281 wxWindow *arg1 = (wxWindow *) 0 ;
34282 bool result;
34283 void *argp1 = 0 ;
34284 int res1 = 0 ;
34285 PyObject *swig_obj[1] ;
34286
34287 if (!args) SWIG_fail;
34288 swig_obj[0] = args;
34289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34290 if (!SWIG_IsOK(res1)) {
34291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34292 }
34293 arg1 = reinterpret_cast< wxWindow * >(argp1);
34294 {
34295 PyThreadState* __tstate = wxPyBeginAllowThreads();
34296 result = (bool)(arg1)->TransferDataFromWindow();
34297 wxPyEndAllowThreads(__tstate);
34298 if (PyErr_Occurred()) SWIG_fail;
34299 }
34300 {
34301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34302 }
34303 return resultobj;
34304 fail:
34305 return NULL;
34306 }
34307
34308
34309 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34310 PyObject *resultobj = 0;
34311 wxWindow *arg1 = (wxWindow *) 0 ;
34312 void *argp1 = 0 ;
34313 int res1 = 0 ;
34314 PyObject *swig_obj[1] ;
34315
34316 if (!args) SWIG_fail;
34317 swig_obj[0] = args;
34318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34319 if (!SWIG_IsOK(res1)) {
34320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34321 }
34322 arg1 = reinterpret_cast< wxWindow * >(argp1);
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 (arg1)->InitDialog();
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 resultobj = SWIG_Py_Void();
34330 return resultobj;
34331 fail:
34332 return NULL;
34333 }
34334
34335
34336 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34337 PyObject *resultobj = 0;
34338 wxWindow *arg1 = (wxWindow *) 0 ;
34339 wxAcceleratorTable *arg2 = 0 ;
34340 void *argp1 = 0 ;
34341 int res1 = 0 ;
34342 void *argp2 = 0 ;
34343 int res2 = 0 ;
34344 PyObject * obj0 = 0 ;
34345 PyObject * obj1 = 0 ;
34346 char * kwnames[] = {
34347 (char *) "self",(char *) "accel", NULL
34348 };
34349
34350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34352 if (!SWIG_IsOK(res1)) {
34353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34354 }
34355 arg1 = reinterpret_cast< wxWindow * >(argp1);
34356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34357 if (!SWIG_IsOK(res2)) {
34358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34359 }
34360 if (!argp2) {
34361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34362 }
34363 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34364 {
34365 PyThreadState* __tstate = wxPyBeginAllowThreads();
34366 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34367 wxPyEndAllowThreads(__tstate);
34368 if (PyErr_Occurred()) SWIG_fail;
34369 }
34370 resultobj = SWIG_Py_Void();
34371 return resultobj;
34372 fail:
34373 return NULL;
34374 }
34375
34376
34377 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34378 PyObject *resultobj = 0;
34379 wxWindow *arg1 = (wxWindow *) 0 ;
34380 wxAcceleratorTable *result = 0 ;
34381 void *argp1 = 0 ;
34382 int res1 = 0 ;
34383 PyObject *swig_obj[1] ;
34384
34385 if (!args) SWIG_fail;
34386 swig_obj[0] = args;
34387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34388 if (!SWIG_IsOK(res1)) {
34389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34390 }
34391 arg1 = reinterpret_cast< wxWindow * >(argp1);
34392 {
34393 PyThreadState* __tstate = wxPyBeginAllowThreads();
34394 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34395 wxPyEndAllowThreads(__tstate);
34396 if (PyErr_Occurred()) SWIG_fail;
34397 }
34398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34399 return resultobj;
34400 fail:
34401 return NULL;
34402 }
34403
34404
34405 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34406 PyObject *resultobj = 0;
34407 wxWindow *arg1 = (wxWindow *) 0 ;
34408 int arg2 ;
34409 int arg3 ;
34410 int arg4 ;
34411 bool result;
34412 void *argp1 = 0 ;
34413 int res1 = 0 ;
34414 int val2 ;
34415 int ecode2 = 0 ;
34416 int val3 ;
34417 int ecode3 = 0 ;
34418 int val4 ;
34419 int ecode4 = 0 ;
34420 PyObject * obj0 = 0 ;
34421 PyObject * obj1 = 0 ;
34422 PyObject * obj2 = 0 ;
34423 PyObject * obj3 = 0 ;
34424 char * kwnames[] = {
34425 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34426 };
34427
34428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34430 if (!SWIG_IsOK(res1)) {
34431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34432 }
34433 arg1 = reinterpret_cast< wxWindow * >(argp1);
34434 ecode2 = SWIG_AsVal_int(obj1, &val2);
34435 if (!SWIG_IsOK(ecode2)) {
34436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34437 }
34438 arg2 = static_cast< int >(val2);
34439 ecode3 = SWIG_AsVal_int(obj2, &val3);
34440 if (!SWIG_IsOK(ecode3)) {
34441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34442 }
34443 arg3 = static_cast< int >(val3);
34444 ecode4 = SWIG_AsVal_int(obj3, &val4);
34445 if (!SWIG_IsOK(ecode4)) {
34446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34447 }
34448 arg4 = static_cast< int >(val4);
34449 {
34450 PyThreadState* __tstate = wxPyBeginAllowThreads();
34451 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34452 wxPyEndAllowThreads(__tstate);
34453 if (PyErr_Occurred()) SWIG_fail;
34454 }
34455 {
34456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34457 }
34458 return resultobj;
34459 fail:
34460 return NULL;
34461 }
34462
34463
34464 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34465 PyObject *resultobj = 0;
34466 wxWindow *arg1 = (wxWindow *) 0 ;
34467 int arg2 ;
34468 bool result;
34469 void *argp1 = 0 ;
34470 int res1 = 0 ;
34471 int val2 ;
34472 int ecode2 = 0 ;
34473 PyObject * obj0 = 0 ;
34474 PyObject * obj1 = 0 ;
34475 char * kwnames[] = {
34476 (char *) "self",(char *) "hotkeyId", NULL
34477 };
34478
34479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34481 if (!SWIG_IsOK(res1)) {
34482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34483 }
34484 arg1 = reinterpret_cast< wxWindow * >(argp1);
34485 ecode2 = SWIG_AsVal_int(obj1, &val2);
34486 if (!SWIG_IsOK(ecode2)) {
34487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34488 }
34489 arg2 = static_cast< int >(val2);
34490 {
34491 PyThreadState* __tstate = wxPyBeginAllowThreads();
34492 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34493 wxPyEndAllowThreads(__tstate);
34494 if (PyErr_Occurred()) SWIG_fail;
34495 }
34496 {
34497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34498 }
34499 return resultobj;
34500 fail:
34501 return NULL;
34502 }
34503
34504
34505 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34506 PyObject *resultobj = 0;
34507 wxWindow *arg1 = (wxWindow *) 0 ;
34508 wxPoint *arg2 = 0 ;
34509 wxPoint result;
34510 void *argp1 = 0 ;
34511 int res1 = 0 ;
34512 wxPoint temp2 ;
34513 PyObject * obj0 = 0 ;
34514 PyObject * obj1 = 0 ;
34515 char * kwnames[] = {
34516 (char *) "self",(char *) "pt", NULL
34517 };
34518
34519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34521 if (!SWIG_IsOK(res1)) {
34522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34523 }
34524 arg1 = reinterpret_cast< wxWindow * >(argp1);
34525 {
34526 arg2 = &temp2;
34527 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34528 }
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj = 0;
34544 wxWindow *arg1 = (wxWindow *) 0 ;
34545 wxSize *arg2 = 0 ;
34546 wxSize result;
34547 void *argp1 = 0 ;
34548 int res1 = 0 ;
34549 wxSize temp2 ;
34550 PyObject * obj0 = 0 ;
34551 PyObject * obj1 = 0 ;
34552 char * kwnames[] = {
34553 (char *) "self",(char *) "sz", NULL
34554 };
34555
34556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34558 if (!SWIG_IsOK(res1)) {
34559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34560 }
34561 arg1 = reinterpret_cast< wxWindow * >(argp1);
34562 {
34563 arg2 = &temp2;
34564 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34565 }
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34569 wxPyEndAllowThreads(__tstate);
34570 if (PyErr_Occurred()) SWIG_fail;
34571 }
34572 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34580 PyObject *resultobj = 0;
34581 wxWindow *arg1 = (wxWindow *) 0 ;
34582 wxPoint *arg2 = 0 ;
34583 wxPoint result;
34584 void *argp1 = 0 ;
34585 int res1 = 0 ;
34586 wxPoint temp2 ;
34587 PyObject * obj0 = 0 ;
34588 PyObject * obj1 = 0 ;
34589 char * kwnames[] = {
34590 (char *) "self",(char *) "pt", NULL
34591 };
34592
34593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34595 if (!SWIG_IsOK(res1)) {
34596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34597 }
34598 arg1 = reinterpret_cast< wxWindow * >(argp1);
34599 {
34600 arg2 = &temp2;
34601 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34602 }
34603 {
34604 PyThreadState* __tstate = wxPyBeginAllowThreads();
34605 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34610 return resultobj;
34611 fail:
34612 return NULL;
34613 }
34614
34615
34616 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34617 PyObject *resultobj = 0;
34618 wxWindow *arg1 = (wxWindow *) 0 ;
34619 wxSize *arg2 = 0 ;
34620 wxSize result;
34621 void *argp1 = 0 ;
34622 int res1 = 0 ;
34623 wxSize temp2 ;
34624 PyObject * obj0 = 0 ;
34625 PyObject * obj1 = 0 ;
34626 char * kwnames[] = {
34627 (char *) "self",(char *) "sz", NULL
34628 };
34629
34630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34632 if (!SWIG_IsOK(res1)) {
34633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34634 }
34635 arg1 = reinterpret_cast< wxWindow * >(argp1);
34636 {
34637 arg2 = &temp2;
34638 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34639 }
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj = 0;
34655 wxWindow *arg1 = (wxWindow *) 0 ;
34656 wxPoint *arg2 = 0 ;
34657 wxPoint result;
34658 void *argp1 = 0 ;
34659 int res1 = 0 ;
34660 wxPoint temp2 ;
34661 PyObject * obj0 = 0 ;
34662 PyObject * obj1 = 0 ;
34663 char * kwnames[] = {
34664 (char *) "self",(char *) "pt", NULL
34665 };
34666
34667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34669 if (!SWIG_IsOK(res1)) {
34670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34671 }
34672 arg1 = reinterpret_cast< wxWindow * >(argp1);
34673 {
34674 arg2 = &temp2;
34675 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34676 }
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj = 0;
34692 wxWindow *arg1 = (wxWindow *) 0 ;
34693 wxSize *arg2 = 0 ;
34694 wxSize result;
34695 void *argp1 = 0 ;
34696 int res1 = 0 ;
34697 wxSize temp2 ;
34698 PyObject * obj0 = 0 ;
34699 PyObject * obj1 = 0 ;
34700 char * kwnames[] = {
34701 (char *) "self",(char *) "sz", NULL
34702 };
34703
34704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34706 if (!SWIG_IsOK(res1)) {
34707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34708 }
34709 arg1 = reinterpret_cast< wxWindow * >(argp1);
34710 {
34711 arg2 = &temp2;
34712 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34713 }
34714 {
34715 PyThreadState* __tstate = wxPyBeginAllowThreads();
34716 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34717 wxPyEndAllowThreads(__tstate);
34718 if (PyErr_Occurred()) SWIG_fail;
34719 }
34720 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34721 return resultobj;
34722 fail:
34723 return NULL;
34724 }
34725
34726
34727 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34728 PyObject *resultobj = 0;
34729 wxWindow *arg1 = (wxWindow *) 0 ;
34730 int arg2 ;
34731 int arg3 ;
34732 void *argp1 = 0 ;
34733 int res1 = 0 ;
34734 int val2 ;
34735 int ecode2 = 0 ;
34736 int val3 ;
34737 int ecode3 = 0 ;
34738 PyObject * obj0 = 0 ;
34739 PyObject * obj1 = 0 ;
34740 PyObject * obj2 = 0 ;
34741 char * kwnames[] = {
34742 (char *) "self",(char *) "x",(char *) "y", NULL
34743 };
34744
34745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34747 if (!SWIG_IsOK(res1)) {
34748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34749 }
34750 arg1 = reinterpret_cast< wxWindow * >(argp1);
34751 ecode2 = SWIG_AsVal_int(obj1, &val2);
34752 if (!SWIG_IsOK(ecode2)) {
34753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34754 }
34755 arg2 = static_cast< int >(val2);
34756 ecode3 = SWIG_AsVal_int(obj2, &val3);
34757 if (!SWIG_IsOK(ecode3)) {
34758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34759 }
34760 arg3 = static_cast< int >(val3);
34761 {
34762 PyThreadState* __tstate = wxPyBeginAllowThreads();
34763 (arg1)->WarpPointer(arg2,arg3);
34764 wxPyEndAllowThreads(__tstate);
34765 if (PyErr_Occurred()) SWIG_fail;
34766 }
34767 resultobj = SWIG_Py_Void();
34768 return resultobj;
34769 fail:
34770 return NULL;
34771 }
34772
34773
34774 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34775 PyObject *resultobj = 0;
34776 wxWindow *arg1 = (wxWindow *) 0 ;
34777 void *argp1 = 0 ;
34778 int res1 = 0 ;
34779 PyObject *swig_obj[1] ;
34780
34781 if (!args) SWIG_fail;
34782 swig_obj[0] = args;
34783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34784 if (!SWIG_IsOK(res1)) {
34785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34786 }
34787 arg1 = reinterpret_cast< wxWindow * >(argp1);
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 (arg1)->CaptureMouse();
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 resultobj = SWIG_Py_Void();
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34802 PyObject *resultobj = 0;
34803 wxWindow *arg1 = (wxWindow *) 0 ;
34804 void *argp1 = 0 ;
34805 int res1 = 0 ;
34806 PyObject *swig_obj[1] ;
34807
34808 if (!args) SWIG_fail;
34809 swig_obj[0] = args;
34810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34811 if (!SWIG_IsOK(res1)) {
34812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34813 }
34814 arg1 = reinterpret_cast< wxWindow * >(argp1);
34815 {
34816 PyThreadState* __tstate = wxPyBeginAllowThreads();
34817 (arg1)->ReleaseMouse();
34818 wxPyEndAllowThreads(__tstate);
34819 if (PyErr_Occurred()) SWIG_fail;
34820 }
34821 resultobj = SWIG_Py_Void();
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34829 PyObject *resultobj = 0;
34830 wxWindow *result = 0 ;
34831
34832 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34833 {
34834 if (!wxPyCheckForApp()) SWIG_fail;
34835 PyThreadState* __tstate = wxPyBeginAllowThreads();
34836 result = (wxWindow *)wxWindow::GetCapture();
34837 wxPyEndAllowThreads(__tstate);
34838 if (PyErr_Occurred()) SWIG_fail;
34839 }
34840 {
34841 resultobj = wxPyMake_wxObject(result, 0);
34842 }
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34850 PyObject *resultobj = 0;
34851 wxWindow *arg1 = (wxWindow *) 0 ;
34852 bool result;
34853 void *argp1 = 0 ;
34854 int res1 = 0 ;
34855 PyObject *swig_obj[1] ;
34856
34857 if (!args) SWIG_fail;
34858 swig_obj[0] = args;
34859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34860 if (!SWIG_IsOK(res1)) {
34861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34862 }
34863 arg1 = reinterpret_cast< wxWindow * >(argp1);
34864 {
34865 PyThreadState* __tstate = wxPyBeginAllowThreads();
34866 result = (bool)((wxWindow const *)arg1)->HasCapture();
34867 wxPyEndAllowThreads(__tstate);
34868 if (PyErr_Occurred()) SWIG_fail;
34869 }
34870 {
34871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34872 }
34873 return resultobj;
34874 fail:
34875 return NULL;
34876 }
34877
34878
34879 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34880 PyObject *resultobj = 0;
34881 wxWindow *arg1 = (wxWindow *) 0 ;
34882 bool arg2 = (bool) true ;
34883 wxRect *arg3 = (wxRect *) NULL ;
34884 void *argp1 = 0 ;
34885 int res1 = 0 ;
34886 bool val2 ;
34887 int ecode2 = 0 ;
34888 void *argp3 = 0 ;
34889 int res3 = 0 ;
34890 PyObject * obj0 = 0 ;
34891 PyObject * obj1 = 0 ;
34892 PyObject * obj2 = 0 ;
34893 char * kwnames[] = {
34894 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34895 };
34896
34897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34899 if (!SWIG_IsOK(res1)) {
34900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34901 }
34902 arg1 = reinterpret_cast< wxWindow * >(argp1);
34903 if (obj1) {
34904 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34905 if (!SWIG_IsOK(ecode2)) {
34906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34907 }
34908 arg2 = static_cast< bool >(val2);
34909 }
34910 if (obj2) {
34911 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34912 if (!SWIG_IsOK(res3)) {
34913 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34914 }
34915 arg3 = reinterpret_cast< wxRect * >(argp3);
34916 }
34917 {
34918 PyThreadState* __tstate = wxPyBeginAllowThreads();
34919 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34920 wxPyEndAllowThreads(__tstate);
34921 if (PyErr_Occurred()) SWIG_fail;
34922 }
34923 resultobj = SWIG_Py_Void();
34924 return resultobj;
34925 fail:
34926 return NULL;
34927 }
34928
34929
34930 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34931 PyObject *resultobj = 0;
34932 wxWindow *arg1 = (wxWindow *) 0 ;
34933 wxRect *arg2 = 0 ;
34934 bool arg3 = (bool) true ;
34935 void *argp1 = 0 ;
34936 int res1 = 0 ;
34937 wxRect temp2 ;
34938 bool val3 ;
34939 int ecode3 = 0 ;
34940 PyObject * obj0 = 0 ;
34941 PyObject * obj1 = 0 ;
34942 PyObject * obj2 = 0 ;
34943 char * kwnames[] = {
34944 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34945 };
34946
34947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34949 if (!SWIG_IsOK(res1)) {
34950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34951 }
34952 arg1 = reinterpret_cast< wxWindow * >(argp1);
34953 {
34954 arg2 = &temp2;
34955 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34956 }
34957 if (obj2) {
34958 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34959 if (!SWIG_IsOK(ecode3)) {
34960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34961 }
34962 arg3 = static_cast< bool >(val3);
34963 }
34964 {
34965 PyThreadState* __tstate = wxPyBeginAllowThreads();
34966 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34967 wxPyEndAllowThreads(__tstate);
34968 if (PyErr_Occurred()) SWIG_fail;
34969 }
34970 resultobj = SWIG_Py_Void();
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34978 PyObject *resultobj = 0;
34979 wxWindow *arg1 = (wxWindow *) 0 ;
34980 void *argp1 = 0 ;
34981 int res1 = 0 ;
34982 PyObject *swig_obj[1] ;
34983
34984 if (!args) SWIG_fail;
34985 swig_obj[0] = args;
34986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34987 if (!SWIG_IsOK(res1)) {
34988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34989 }
34990 arg1 = reinterpret_cast< wxWindow * >(argp1);
34991 {
34992 PyThreadState* __tstate = wxPyBeginAllowThreads();
34993 (arg1)->Update();
34994 wxPyEndAllowThreads(__tstate);
34995 if (PyErr_Occurred()) SWIG_fail;
34996 }
34997 resultobj = SWIG_Py_Void();
34998 return resultobj;
34999 fail:
35000 return NULL;
35001 }
35002
35003
35004 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35005 PyObject *resultobj = 0;
35006 wxWindow *arg1 = (wxWindow *) 0 ;
35007 void *argp1 = 0 ;
35008 int res1 = 0 ;
35009 PyObject *swig_obj[1] ;
35010
35011 if (!args) SWIG_fail;
35012 swig_obj[0] = args;
35013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35014 if (!SWIG_IsOK(res1)) {
35015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35016 }
35017 arg1 = reinterpret_cast< wxWindow * >(argp1);
35018 {
35019 PyThreadState* __tstate = wxPyBeginAllowThreads();
35020 (arg1)->ClearBackground();
35021 wxPyEndAllowThreads(__tstate);
35022 if (PyErr_Occurred()) SWIG_fail;
35023 }
35024 resultobj = SWIG_Py_Void();
35025 return resultobj;
35026 fail:
35027 return NULL;
35028 }
35029
35030
35031 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35032 PyObject *resultobj = 0;
35033 wxWindow *arg1 = (wxWindow *) 0 ;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 PyObject *swig_obj[1] ;
35037
35038 if (!args) SWIG_fail;
35039 swig_obj[0] = args;
35040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35041 if (!SWIG_IsOK(res1)) {
35042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35043 }
35044 arg1 = reinterpret_cast< wxWindow * >(argp1);
35045 {
35046 PyThreadState* __tstate = wxPyBeginAllowThreads();
35047 (arg1)->Freeze();
35048 wxPyEndAllowThreads(__tstate);
35049 if (PyErr_Occurred()) SWIG_fail;
35050 }
35051 resultobj = SWIG_Py_Void();
35052 return resultobj;
35053 fail:
35054 return NULL;
35055 }
35056
35057
35058 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35059 PyObject *resultobj = 0;
35060 wxWindow *arg1 = (wxWindow *) 0 ;
35061 bool result;
35062 void *argp1 = 0 ;
35063 int res1 = 0 ;
35064 PyObject *swig_obj[1] ;
35065
35066 if (!args) SWIG_fail;
35067 swig_obj[0] = args;
35068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35069 if (!SWIG_IsOK(res1)) {
35070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35071 }
35072 arg1 = reinterpret_cast< wxWindow * >(argp1);
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35076 wxPyEndAllowThreads(__tstate);
35077 if (PyErr_Occurred()) SWIG_fail;
35078 }
35079 {
35080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35081 }
35082 return resultobj;
35083 fail:
35084 return NULL;
35085 }
35086
35087
35088 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35089 PyObject *resultobj = 0;
35090 wxWindow *arg1 = (wxWindow *) 0 ;
35091 void *argp1 = 0 ;
35092 int res1 = 0 ;
35093 PyObject *swig_obj[1] ;
35094
35095 if (!args) SWIG_fail;
35096 swig_obj[0] = args;
35097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35098 if (!SWIG_IsOK(res1)) {
35099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35100 }
35101 arg1 = reinterpret_cast< wxWindow * >(argp1);
35102 {
35103 PyThreadState* __tstate = wxPyBeginAllowThreads();
35104 (arg1)->Thaw();
35105 wxPyEndAllowThreads(__tstate);
35106 if (PyErr_Occurred()) SWIG_fail;
35107 }
35108 resultobj = SWIG_Py_Void();
35109 return resultobj;
35110 fail:
35111 return NULL;
35112 }
35113
35114
35115 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35116 PyObject *resultobj = 0;
35117 wxWindow *arg1 = (wxWindow *) 0 ;
35118 wxDC *arg2 = 0 ;
35119 void *argp1 = 0 ;
35120 int res1 = 0 ;
35121 void *argp2 = 0 ;
35122 int res2 = 0 ;
35123 PyObject * obj0 = 0 ;
35124 PyObject * obj1 = 0 ;
35125 char * kwnames[] = {
35126 (char *) "self",(char *) "dc", NULL
35127 };
35128
35129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35131 if (!SWIG_IsOK(res1)) {
35132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35133 }
35134 arg1 = reinterpret_cast< wxWindow * >(argp1);
35135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35136 if (!SWIG_IsOK(res2)) {
35137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35138 }
35139 if (!argp2) {
35140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35141 }
35142 arg2 = reinterpret_cast< wxDC * >(argp2);
35143 {
35144 PyThreadState* __tstate = wxPyBeginAllowThreads();
35145 (arg1)->PrepareDC(*arg2);
35146 wxPyEndAllowThreads(__tstate);
35147 if (PyErr_Occurred()) SWIG_fail;
35148 }
35149 resultobj = SWIG_Py_Void();
35150 return resultobj;
35151 fail:
35152 return NULL;
35153 }
35154
35155
35156 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35157 PyObject *resultobj = 0;
35158 wxWindow *arg1 = (wxWindow *) 0 ;
35159 wxRegion *result = 0 ;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 PyObject *swig_obj[1] ;
35163
35164 if (!args) SWIG_fail;
35165 swig_obj[0] = args;
35166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35167 if (!SWIG_IsOK(res1)) {
35168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35169 }
35170 arg1 = reinterpret_cast< wxWindow * >(argp1);
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 {
35174 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35175 result = (wxRegion *) &_result_ref;
35176 }
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35188 PyObject *resultobj = 0;
35189 wxWindow *arg1 = (wxWindow *) 0 ;
35190 wxRect result;
35191 void *argp1 = 0 ;
35192 int res1 = 0 ;
35193 PyObject *swig_obj[1] ;
35194
35195 if (!args) SWIG_fail;
35196 swig_obj[0] = args;
35197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35198 if (!SWIG_IsOK(res1)) {
35199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35200 }
35201 arg1 = reinterpret_cast< wxWindow * >(argp1);
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35216 PyObject *resultobj = 0;
35217 wxWindow *arg1 = (wxWindow *) 0 ;
35218 int arg2 ;
35219 int arg3 ;
35220 int arg4 = (int) 1 ;
35221 int arg5 = (int) 1 ;
35222 bool result;
35223 void *argp1 = 0 ;
35224 int res1 = 0 ;
35225 int val2 ;
35226 int ecode2 = 0 ;
35227 int val3 ;
35228 int ecode3 = 0 ;
35229 int val4 ;
35230 int ecode4 = 0 ;
35231 int val5 ;
35232 int ecode5 = 0 ;
35233 PyObject * obj0 = 0 ;
35234 PyObject * obj1 = 0 ;
35235 PyObject * obj2 = 0 ;
35236 PyObject * obj3 = 0 ;
35237 PyObject * obj4 = 0 ;
35238 char * kwnames[] = {
35239 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35240 };
35241
35242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35244 if (!SWIG_IsOK(res1)) {
35245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35246 }
35247 arg1 = reinterpret_cast< wxWindow * >(argp1);
35248 ecode2 = SWIG_AsVal_int(obj1, &val2);
35249 if (!SWIG_IsOK(ecode2)) {
35250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35251 }
35252 arg2 = static_cast< int >(val2);
35253 ecode3 = SWIG_AsVal_int(obj2, &val3);
35254 if (!SWIG_IsOK(ecode3)) {
35255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35256 }
35257 arg3 = static_cast< int >(val3);
35258 if (obj3) {
35259 ecode4 = SWIG_AsVal_int(obj3, &val4);
35260 if (!SWIG_IsOK(ecode4)) {
35261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35262 }
35263 arg4 = static_cast< int >(val4);
35264 }
35265 if (obj4) {
35266 ecode5 = SWIG_AsVal_int(obj4, &val5);
35267 if (!SWIG_IsOK(ecode5)) {
35268 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35269 }
35270 arg5 = static_cast< int >(val5);
35271 }
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 {
35279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35280 }
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj = 0;
35289 wxWindow *arg1 = (wxWindow *) 0 ;
35290 wxPoint *arg2 = 0 ;
35291 bool result;
35292 void *argp1 = 0 ;
35293 int res1 = 0 ;
35294 wxPoint temp2 ;
35295 PyObject * obj0 = 0 ;
35296 PyObject * obj1 = 0 ;
35297 char * kwnames[] = {
35298 (char *) "self",(char *) "pt", NULL
35299 };
35300
35301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35305 }
35306 arg1 = reinterpret_cast< wxWindow * >(argp1);
35307 {
35308 arg2 = &temp2;
35309 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35310 }
35311 {
35312 PyThreadState* __tstate = wxPyBeginAllowThreads();
35313 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35314 wxPyEndAllowThreads(__tstate);
35315 if (PyErr_Occurred()) SWIG_fail;
35316 }
35317 {
35318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35319 }
35320 return resultobj;
35321 fail:
35322 return NULL;
35323 }
35324
35325
35326 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35327 PyObject *resultobj = 0;
35328 wxWindow *arg1 = (wxWindow *) 0 ;
35329 wxRect *arg2 = 0 ;
35330 bool result;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 wxRect temp2 ;
35334 PyObject * obj0 = 0 ;
35335 PyObject * obj1 = 0 ;
35336 char * kwnames[] = {
35337 (char *) "self",(char *) "rect", NULL
35338 };
35339
35340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35342 if (!SWIG_IsOK(res1)) {
35343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35344 }
35345 arg1 = reinterpret_cast< wxWindow * >(argp1);
35346 {
35347 arg2 = &temp2;
35348 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35349 }
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35353 wxPyEndAllowThreads(__tstate);
35354 if (PyErr_Occurred()) SWIG_fail;
35355 }
35356 {
35357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35358 }
35359 return resultobj;
35360 fail:
35361 return NULL;
35362 }
35363
35364
35365 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35366 PyObject *resultobj = 0;
35367 wxWindow *arg1 = (wxWindow *) 0 ;
35368 SwigValueWrapper<wxVisualAttributes > result;
35369 void *argp1 = 0 ;
35370 int res1 = 0 ;
35371 PyObject *swig_obj[1] ;
35372
35373 if (!args) SWIG_fail;
35374 swig_obj[0] = args;
35375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35376 if (!SWIG_IsOK(res1)) {
35377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35378 }
35379 arg1 = reinterpret_cast< wxWindow * >(argp1);
35380 {
35381 PyThreadState* __tstate = wxPyBeginAllowThreads();
35382 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35383 wxPyEndAllowThreads(__tstate);
35384 if (PyErr_Occurred()) SWIG_fail;
35385 }
35386 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35387 return resultobj;
35388 fail:
35389 return NULL;
35390 }
35391
35392
35393 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35394 PyObject *resultobj = 0;
35395 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35396 SwigValueWrapper<wxVisualAttributes > result;
35397 int val1 ;
35398 int ecode1 = 0 ;
35399 PyObject * obj0 = 0 ;
35400 char * kwnames[] = {
35401 (char *) "variant", NULL
35402 };
35403
35404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35405 if (obj0) {
35406 ecode1 = SWIG_AsVal_int(obj0, &val1);
35407 if (!SWIG_IsOK(ecode1)) {
35408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35409 }
35410 arg1 = static_cast< wxWindowVariant >(val1);
35411 }
35412 {
35413 if (!wxPyCheckForApp()) SWIG_fail;
35414 PyThreadState* __tstate = wxPyBeginAllowThreads();
35415 result = wxWindow::GetClassDefaultAttributes(arg1);
35416 wxPyEndAllowThreads(__tstate);
35417 if (PyErr_Occurred()) SWIG_fail;
35418 }
35419 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35420 return resultobj;
35421 fail:
35422 return NULL;
35423 }
35424
35425
35426 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35427 PyObject *resultobj = 0;
35428 wxWindow *arg1 = (wxWindow *) 0 ;
35429 wxColour *arg2 = 0 ;
35430 bool result;
35431 void *argp1 = 0 ;
35432 int res1 = 0 ;
35433 wxColour temp2 ;
35434 PyObject * obj0 = 0 ;
35435 PyObject * obj1 = 0 ;
35436 char * kwnames[] = {
35437 (char *) "self",(char *) "colour", NULL
35438 };
35439
35440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35442 if (!SWIG_IsOK(res1)) {
35443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35444 }
35445 arg1 = reinterpret_cast< wxWindow * >(argp1);
35446 {
35447 arg2 = &temp2;
35448 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35449 }
35450 {
35451 PyThreadState* __tstate = wxPyBeginAllowThreads();
35452 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35453 wxPyEndAllowThreads(__tstate);
35454 if (PyErr_Occurred()) SWIG_fail;
35455 }
35456 {
35457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35458 }
35459 return resultobj;
35460 fail:
35461 return NULL;
35462 }
35463
35464
35465 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35466 PyObject *resultobj = 0;
35467 wxWindow *arg1 = (wxWindow *) 0 ;
35468 wxColour *arg2 = 0 ;
35469 void *argp1 = 0 ;
35470 int res1 = 0 ;
35471 wxColour temp2 ;
35472 PyObject * obj0 = 0 ;
35473 PyObject * obj1 = 0 ;
35474 char * kwnames[] = {
35475 (char *) "self",(char *) "colour", NULL
35476 };
35477
35478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35480 if (!SWIG_IsOK(res1)) {
35481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35482 }
35483 arg1 = reinterpret_cast< wxWindow * >(argp1);
35484 {
35485 arg2 = &temp2;
35486 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35487 }
35488 {
35489 PyThreadState* __tstate = wxPyBeginAllowThreads();
35490 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35491 wxPyEndAllowThreads(__tstate);
35492 if (PyErr_Occurred()) SWIG_fail;
35493 }
35494 resultobj = SWIG_Py_Void();
35495 return resultobj;
35496 fail:
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 wxColour *arg2 = 0 ;
35505 bool result;
35506 void *argp1 = 0 ;
35507 int res1 = 0 ;
35508 wxColour temp2 ;
35509 PyObject * obj0 = 0 ;
35510 PyObject * obj1 = 0 ;
35511 char * kwnames[] = {
35512 (char *) "self",(char *) "colour", NULL
35513 };
35514
35515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35517 if (!SWIG_IsOK(res1)) {
35518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35519 }
35520 arg1 = reinterpret_cast< wxWindow * >(argp1);
35521 {
35522 arg2 = &temp2;
35523 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35524 }
35525 {
35526 PyThreadState* __tstate = wxPyBeginAllowThreads();
35527 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35528 wxPyEndAllowThreads(__tstate);
35529 if (PyErr_Occurred()) SWIG_fail;
35530 }
35531 {
35532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35533 }
35534 return resultobj;
35535 fail:
35536 return NULL;
35537 }
35538
35539
35540 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35541 PyObject *resultobj = 0;
35542 wxWindow *arg1 = (wxWindow *) 0 ;
35543 wxColour *arg2 = 0 ;
35544 void *argp1 = 0 ;
35545 int res1 = 0 ;
35546 wxColour temp2 ;
35547 PyObject * obj0 = 0 ;
35548 PyObject * obj1 = 0 ;
35549 char * kwnames[] = {
35550 (char *) "self",(char *) "colour", NULL
35551 };
35552
35553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35555 if (!SWIG_IsOK(res1)) {
35556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35557 }
35558 arg1 = reinterpret_cast< wxWindow * >(argp1);
35559 {
35560 arg2 = &temp2;
35561 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35562 }
35563 {
35564 PyThreadState* __tstate = wxPyBeginAllowThreads();
35565 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35566 wxPyEndAllowThreads(__tstate);
35567 if (PyErr_Occurred()) SWIG_fail;
35568 }
35569 resultobj = SWIG_Py_Void();
35570 return resultobj;
35571 fail:
35572 return NULL;
35573 }
35574
35575
35576 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35577 PyObject *resultobj = 0;
35578 wxWindow *arg1 = (wxWindow *) 0 ;
35579 wxColour result;
35580 void *argp1 = 0 ;
35581 int res1 = 0 ;
35582 PyObject *swig_obj[1] ;
35583
35584 if (!args) SWIG_fail;
35585 swig_obj[0] = args;
35586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35587 if (!SWIG_IsOK(res1)) {
35588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35589 }
35590 arg1 = reinterpret_cast< wxWindow * >(argp1);
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35605 PyObject *resultobj = 0;
35606 wxWindow *arg1 = (wxWindow *) 0 ;
35607 wxColour result;
35608 void *argp1 = 0 ;
35609 int res1 = 0 ;
35610 PyObject *swig_obj[1] ;
35611
35612 if (!args) SWIG_fail;
35613 swig_obj[0] = args;
35614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35615 if (!SWIG_IsOK(res1)) {
35616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35617 }
35618 arg1 = reinterpret_cast< wxWindow * >(argp1);
35619 {
35620 PyThreadState* __tstate = wxPyBeginAllowThreads();
35621 result = ((wxWindow const *)arg1)->GetForegroundColour();
35622 wxPyEndAllowThreads(__tstate);
35623 if (PyErr_Occurred()) SWIG_fail;
35624 }
35625 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35626 return resultobj;
35627 fail:
35628 return NULL;
35629 }
35630
35631
35632 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35633 PyObject *resultobj = 0;
35634 wxWindow *arg1 = (wxWindow *) 0 ;
35635 bool result;
35636 void *argp1 = 0 ;
35637 int res1 = 0 ;
35638 PyObject *swig_obj[1] ;
35639
35640 if (!args) SWIG_fail;
35641 swig_obj[0] = args;
35642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35643 if (!SWIG_IsOK(res1)) {
35644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35645 }
35646 arg1 = reinterpret_cast< wxWindow * >(argp1);
35647 {
35648 PyThreadState* __tstate = wxPyBeginAllowThreads();
35649 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35650 wxPyEndAllowThreads(__tstate);
35651 if (PyErr_Occurred()) SWIG_fail;
35652 }
35653 {
35654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35655 }
35656 return resultobj;
35657 fail:
35658 return NULL;
35659 }
35660
35661
35662 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35663 PyObject *resultobj = 0;
35664 wxWindow *arg1 = (wxWindow *) 0 ;
35665 bool result;
35666 void *argp1 = 0 ;
35667 int res1 = 0 ;
35668 PyObject *swig_obj[1] ;
35669
35670 if (!args) SWIG_fail;
35671 swig_obj[0] = args;
35672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35673 if (!SWIG_IsOK(res1)) {
35674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35675 }
35676 arg1 = reinterpret_cast< wxWindow * >(argp1);
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35680 wxPyEndAllowThreads(__tstate);
35681 if (PyErr_Occurred()) SWIG_fail;
35682 }
35683 {
35684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35685 }
35686 return resultobj;
35687 fail:
35688 return NULL;
35689 }
35690
35691
35692 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35693 PyObject *resultobj = 0;
35694 wxWindow *arg1 = (wxWindow *) 0 ;
35695 wxBackgroundStyle arg2 ;
35696 bool result;
35697 void *argp1 = 0 ;
35698 int res1 = 0 ;
35699 int val2 ;
35700 int ecode2 = 0 ;
35701 PyObject * obj0 = 0 ;
35702 PyObject * obj1 = 0 ;
35703 char * kwnames[] = {
35704 (char *) "self",(char *) "style", NULL
35705 };
35706
35707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35709 if (!SWIG_IsOK(res1)) {
35710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35711 }
35712 arg1 = reinterpret_cast< wxWindow * >(argp1);
35713 ecode2 = SWIG_AsVal_int(obj1, &val2);
35714 if (!SWIG_IsOK(ecode2)) {
35715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35716 }
35717 arg2 = static_cast< wxBackgroundStyle >(val2);
35718 {
35719 PyThreadState* __tstate = wxPyBeginAllowThreads();
35720 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35721 wxPyEndAllowThreads(__tstate);
35722 if (PyErr_Occurred()) SWIG_fail;
35723 }
35724 {
35725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35726 }
35727 return resultobj;
35728 fail:
35729 return NULL;
35730 }
35731
35732
35733 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35734 PyObject *resultobj = 0;
35735 wxWindow *arg1 = (wxWindow *) 0 ;
35736 wxBackgroundStyle result;
35737 void *argp1 = 0 ;
35738 int res1 = 0 ;
35739 PyObject *swig_obj[1] ;
35740
35741 if (!args) SWIG_fail;
35742 swig_obj[0] = args;
35743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35744 if (!SWIG_IsOK(res1)) {
35745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35746 }
35747 arg1 = reinterpret_cast< wxWindow * >(argp1);
35748 {
35749 PyThreadState* __tstate = wxPyBeginAllowThreads();
35750 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35751 wxPyEndAllowThreads(__tstate);
35752 if (PyErr_Occurred()) SWIG_fail;
35753 }
35754 resultobj = SWIG_From_int(static_cast< int >(result));
35755 return resultobj;
35756 fail:
35757 return NULL;
35758 }
35759
35760
35761 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35762 PyObject *resultobj = 0;
35763 wxWindow *arg1 = (wxWindow *) 0 ;
35764 bool result;
35765 void *argp1 = 0 ;
35766 int res1 = 0 ;
35767 PyObject *swig_obj[1] ;
35768
35769 if (!args) SWIG_fail;
35770 swig_obj[0] = args;
35771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35772 if (!SWIG_IsOK(res1)) {
35773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35774 }
35775 arg1 = reinterpret_cast< wxWindow * >(argp1);
35776 {
35777 PyThreadState* __tstate = wxPyBeginAllowThreads();
35778 result = (bool)(arg1)->HasTransparentBackground();
35779 wxPyEndAllowThreads(__tstate);
35780 if (PyErr_Occurred()) SWIG_fail;
35781 }
35782 {
35783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35784 }
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35792 PyObject *resultobj = 0;
35793 wxWindow *arg1 = (wxWindow *) 0 ;
35794 wxCursor *arg2 = 0 ;
35795 bool result;
35796 void *argp1 = 0 ;
35797 int res1 = 0 ;
35798 void *argp2 = 0 ;
35799 int res2 = 0 ;
35800 PyObject * obj0 = 0 ;
35801 PyObject * obj1 = 0 ;
35802 char * kwnames[] = {
35803 (char *) "self",(char *) "cursor", NULL
35804 };
35805
35806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35808 if (!SWIG_IsOK(res1)) {
35809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35810 }
35811 arg1 = reinterpret_cast< wxWindow * >(argp1);
35812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35813 if (!SWIG_IsOK(res2)) {
35814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35815 }
35816 if (!argp2) {
35817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35818 }
35819 arg2 = reinterpret_cast< wxCursor * >(argp2);
35820 {
35821 PyThreadState* __tstate = wxPyBeginAllowThreads();
35822 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35823 wxPyEndAllowThreads(__tstate);
35824 if (PyErr_Occurred()) SWIG_fail;
35825 }
35826 {
35827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35828 }
35829 return resultobj;
35830 fail:
35831 return NULL;
35832 }
35833
35834
35835 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35836 PyObject *resultobj = 0;
35837 wxWindow *arg1 = (wxWindow *) 0 ;
35838 wxCursor result;
35839 void *argp1 = 0 ;
35840 int res1 = 0 ;
35841 PyObject *swig_obj[1] ;
35842
35843 if (!args) SWIG_fail;
35844 swig_obj[0] = args;
35845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35846 if (!SWIG_IsOK(res1)) {
35847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35848 }
35849 arg1 = reinterpret_cast< wxWindow * >(argp1);
35850 {
35851 PyThreadState* __tstate = wxPyBeginAllowThreads();
35852 result = (arg1)->GetCursor();
35853 wxPyEndAllowThreads(__tstate);
35854 if (PyErr_Occurred()) SWIG_fail;
35855 }
35856 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35857 return resultobj;
35858 fail:
35859 return NULL;
35860 }
35861
35862
35863 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35864 PyObject *resultobj = 0;
35865 wxWindow *arg1 = (wxWindow *) 0 ;
35866 wxFont *arg2 = 0 ;
35867 bool result;
35868 void *argp1 = 0 ;
35869 int res1 = 0 ;
35870 void *argp2 = 0 ;
35871 int res2 = 0 ;
35872 PyObject * obj0 = 0 ;
35873 PyObject * obj1 = 0 ;
35874 char * kwnames[] = {
35875 (char *) "self",(char *) "font", NULL
35876 };
35877
35878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35880 if (!SWIG_IsOK(res1)) {
35881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35882 }
35883 arg1 = reinterpret_cast< wxWindow * >(argp1);
35884 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35885 if (!SWIG_IsOK(res2)) {
35886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35887 }
35888 if (!argp2) {
35889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35890 }
35891 arg2 = reinterpret_cast< wxFont * >(argp2);
35892 {
35893 PyThreadState* __tstate = wxPyBeginAllowThreads();
35894 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35895 wxPyEndAllowThreads(__tstate);
35896 if (PyErr_Occurred()) SWIG_fail;
35897 }
35898 {
35899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35900 }
35901 return resultobj;
35902 fail:
35903 return NULL;
35904 }
35905
35906
35907 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35908 PyObject *resultobj = 0;
35909 wxWindow *arg1 = (wxWindow *) 0 ;
35910 wxFont *arg2 = 0 ;
35911 void *argp1 = 0 ;
35912 int res1 = 0 ;
35913 void *argp2 = 0 ;
35914 int res2 = 0 ;
35915 PyObject * obj0 = 0 ;
35916 PyObject * obj1 = 0 ;
35917 char * kwnames[] = {
35918 (char *) "self",(char *) "font", NULL
35919 };
35920
35921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35923 if (!SWIG_IsOK(res1)) {
35924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35925 }
35926 arg1 = reinterpret_cast< wxWindow * >(argp1);
35927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35928 if (!SWIG_IsOK(res2)) {
35929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35930 }
35931 if (!argp2) {
35932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35933 }
35934 arg2 = reinterpret_cast< wxFont * >(argp2);
35935 {
35936 PyThreadState* __tstate = wxPyBeginAllowThreads();
35937 (arg1)->SetOwnFont((wxFont const &)*arg2);
35938 wxPyEndAllowThreads(__tstate);
35939 if (PyErr_Occurred()) SWIG_fail;
35940 }
35941 resultobj = SWIG_Py_Void();
35942 return resultobj;
35943 fail:
35944 return NULL;
35945 }
35946
35947
35948 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35949 PyObject *resultobj = 0;
35950 wxWindow *arg1 = (wxWindow *) 0 ;
35951 wxFont result;
35952 void *argp1 = 0 ;
35953 int res1 = 0 ;
35954 PyObject *swig_obj[1] ;
35955
35956 if (!args) SWIG_fail;
35957 swig_obj[0] = args;
35958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35961 }
35962 arg1 = reinterpret_cast< wxWindow * >(argp1);
35963 {
35964 PyThreadState* __tstate = wxPyBeginAllowThreads();
35965 result = (arg1)->GetFont();
35966 wxPyEndAllowThreads(__tstate);
35967 if (PyErr_Occurred()) SWIG_fail;
35968 }
35969 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35970 return resultobj;
35971 fail:
35972 return NULL;
35973 }
35974
35975
35976 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35977 PyObject *resultobj = 0;
35978 wxWindow *arg1 = (wxWindow *) 0 ;
35979 wxCaret *arg2 = (wxCaret *) 0 ;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 int res2 = 0 ;
35983 PyObject * obj0 = 0 ;
35984 PyObject * obj1 = 0 ;
35985 char * kwnames[] = {
35986 (char *) "self",(char *) "caret", NULL
35987 };
35988
35989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35991 if (!SWIG_IsOK(res1)) {
35992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35993 }
35994 arg1 = reinterpret_cast< wxWindow * >(argp1);
35995 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35996 if (!SWIG_IsOK(res2)) {
35997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35998 }
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 (arg1)->SetCaret(arg2);
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 resultobj = SWIG_Py_Void();
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36013 PyObject *resultobj = 0;
36014 wxWindow *arg1 = (wxWindow *) 0 ;
36015 wxCaret *result = 0 ;
36016 void *argp1 = 0 ;
36017 int res1 = 0 ;
36018 PyObject *swig_obj[1] ;
36019
36020 if (!args) SWIG_fail;
36021 swig_obj[0] = args;
36022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36023 if (!SWIG_IsOK(res1)) {
36024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36025 }
36026 arg1 = reinterpret_cast< wxWindow * >(argp1);
36027 {
36028 PyThreadState* __tstate = wxPyBeginAllowThreads();
36029 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36030 wxPyEndAllowThreads(__tstate);
36031 if (PyErr_Occurred()) SWIG_fail;
36032 }
36033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36034 return resultobj;
36035 fail:
36036 return NULL;
36037 }
36038
36039
36040 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36041 PyObject *resultobj = 0;
36042 wxWindow *arg1 = (wxWindow *) 0 ;
36043 int result;
36044 void *argp1 = 0 ;
36045 int res1 = 0 ;
36046 PyObject *swig_obj[1] ;
36047
36048 if (!args) SWIG_fail;
36049 swig_obj[0] = args;
36050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36051 if (!SWIG_IsOK(res1)) {
36052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36053 }
36054 arg1 = reinterpret_cast< wxWindow * >(argp1);
36055 {
36056 PyThreadState* __tstate = wxPyBeginAllowThreads();
36057 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36058 wxPyEndAllowThreads(__tstate);
36059 if (PyErr_Occurred()) SWIG_fail;
36060 }
36061 resultobj = SWIG_From_int(static_cast< int >(result));
36062 return resultobj;
36063 fail:
36064 return NULL;
36065 }
36066
36067
36068 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36069 PyObject *resultobj = 0;
36070 wxWindow *arg1 = (wxWindow *) 0 ;
36071 int result;
36072 void *argp1 = 0 ;
36073 int res1 = 0 ;
36074 PyObject *swig_obj[1] ;
36075
36076 if (!args) SWIG_fail;
36077 swig_obj[0] = args;
36078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36079 if (!SWIG_IsOK(res1)) {
36080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36081 }
36082 arg1 = reinterpret_cast< wxWindow * >(argp1);
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36086 wxPyEndAllowThreads(__tstate);
36087 if (PyErr_Occurred()) SWIG_fail;
36088 }
36089 resultobj = SWIG_From_int(static_cast< int >(result));
36090 return resultobj;
36091 fail:
36092 return NULL;
36093 }
36094
36095
36096 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36097 PyObject *resultobj = 0;
36098 wxWindow *arg1 = (wxWindow *) 0 ;
36099 wxString *arg2 = 0 ;
36100 int *arg3 = (int *) 0 ;
36101 int *arg4 = (int *) 0 ;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 bool temp2 = false ;
36105 int temp3 ;
36106 int res3 = SWIG_TMPOBJ ;
36107 int temp4 ;
36108 int res4 = SWIG_TMPOBJ ;
36109 PyObject * obj0 = 0 ;
36110 PyObject * obj1 = 0 ;
36111 char * kwnames[] = {
36112 (char *) "self",(char *) "string", NULL
36113 };
36114
36115 arg3 = &temp3;
36116 arg4 = &temp4;
36117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36119 if (!SWIG_IsOK(res1)) {
36120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36121 }
36122 arg1 = reinterpret_cast< wxWindow * >(argp1);
36123 {
36124 arg2 = wxString_in_helper(obj1);
36125 if (arg2 == NULL) SWIG_fail;
36126 temp2 = true;
36127 }
36128 {
36129 PyThreadState* __tstate = wxPyBeginAllowThreads();
36130 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36131 wxPyEndAllowThreads(__tstate);
36132 if (PyErr_Occurred()) SWIG_fail;
36133 }
36134 resultobj = SWIG_Py_Void();
36135 if (SWIG_IsTmpObj(res3)) {
36136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36137 } else {
36138 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36140 }
36141 if (SWIG_IsTmpObj(res4)) {
36142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36143 } else {
36144 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36146 }
36147 {
36148 if (temp2)
36149 delete arg2;
36150 }
36151 return resultobj;
36152 fail:
36153 {
36154 if (temp2)
36155 delete arg2;
36156 }
36157 return NULL;
36158 }
36159
36160
36161 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36162 PyObject *resultobj = 0;
36163 wxWindow *arg1 = (wxWindow *) 0 ;
36164 wxString *arg2 = 0 ;
36165 int *arg3 = (int *) 0 ;
36166 int *arg4 = (int *) 0 ;
36167 int *arg5 = (int *) 0 ;
36168 int *arg6 = (int *) 0 ;
36169 wxFont *arg7 = (wxFont *) NULL ;
36170 void *argp1 = 0 ;
36171 int res1 = 0 ;
36172 bool temp2 = false ;
36173 int temp3 ;
36174 int res3 = SWIG_TMPOBJ ;
36175 int temp4 ;
36176 int res4 = SWIG_TMPOBJ ;
36177 int temp5 ;
36178 int res5 = SWIG_TMPOBJ ;
36179 int temp6 ;
36180 int res6 = SWIG_TMPOBJ ;
36181 void *argp7 = 0 ;
36182 int res7 = 0 ;
36183 PyObject * obj0 = 0 ;
36184 PyObject * obj1 = 0 ;
36185 PyObject * obj2 = 0 ;
36186 char * kwnames[] = {
36187 (char *) "self",(char *) "string",(char *) "font", NULL
36188 };
36189
36190 arg3 = &temp3;
36191 arg4 = &temp4;
36192 arg5 = &temp5;
36193 arg6 = &temp6;
36194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36196 if (!SWIG_IsOK(res1)) {
36197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36198 }
36199 arg1 = reinterpret_cast< wxWindow * >(argp1);
36200 {
36201 arg2 = wxString_in_helper(obj1);
36202 if (arg2 == NULL) SWIG_fail;
36203 temp2 = true;
36204 }
36205 if (obj2) {
36206 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36207 if (!SWIG_IsOK(res7)) {
36208 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36209 }
36210 arg7 = reinterpret_cast< wxFont * >(argp7);
36211 }
36212 {
36213 PyThreadState* __tstate = wxPyBeginAllowThreads();
36214 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36215 wxPyEndAllowThreads(__tstate);
36216 if (PyErr_Occurred()) SWIG_fail;
36217 }
36218 resultobj = SWIG_Py_Void();
36219 if (SWIG_IsTmpObj(res3)) {
36220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36221 } else {
36222 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36224 }
36225 if (SWIG_IsTmpObj(res4)) {
36226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36227 } else {
36228 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36230 }
36231 if (SWIG_IsTmpObj(res5)) {
36232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36233 } else {
36234 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36236 }
36237 if (SWIG_IsTmpObj(res6)) {
36238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36239 } else {
36240 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36242 }
36243 {
36244 if (temp2)
36245 delete arg2;
36246 }
36247 return resultobj;
36248 fail:
36249 {
36250 if (temp2)
36251 delete arg2;
36252 }
36253 return NULL;
36254 }
36255
36256
36257 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36258 PyObject *resultobj = 0;
36259 wxWindow *arg1 = (wxWindow *) 0 ;
36260 int *arg2 = (int *) 0 ;
36261 int *arg3 = (int *) 0 ;
36262 void *argp1 = 0 ;
36263 int res1 = 0 ;
36264 int temp2 ;
36265 int res2 = 0 ;
36266 int temp3 ;
36267 int res3 = 0 ;
36268 PyObject * obj0 = 0 ;
36269 PyObject * obj1 = 0 ;
36270 PyObject * obj2 = 0 ;
36271 char * kwnames[] = {
36272 (char *) "self",(char *) "x",(char *) "y", NULL
36273 };
36274
36275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36277 if (!SWIG_IsOK(res1)) {
36278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36279 }
36280 arg1 = reinterpret_cast< wxWindow * >(argp1);
36281 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36282 int val;
36283 int ecode = SWIG_AsVal_int(obj1, &val);
36284 if (!SWIG_IsOK(ecode)) {
36285 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36286 }
36287 temp2 = static_cast< int >(val);
36288 arg2 = &temp2;
36289 res2 = SWIG_AddTmpMask(ecode);
36290 }
36291 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36292 int val;
36293 int ecode = SWIG_AsVal_int(obj2, &val);
36294 if (!SWIG_IsOK(ecode)) {
36295 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36296 }
36297 temp3 = static_cast< int >(val);
36298 arg3 = &temp3;
36299 res3 = SWIG_AddTmpMask(ecode);
36300 }
36301 {
36302 PyThreadState* __tstate = wxPyBeginAllowThreads();
36303 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36304 wxPyEndAllowThreads(__tstate);
36305 if (PyErr_Occurred()) SWIG_fail;
36306 }
36307 resultobj = SWIG_Py_Void();
36308 if (SWIG_IsTmpObj(res2)) {
36309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36310 } else {
36311 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36313 }
36314 if (SWIG_IsTmpObj(res3)) {
36315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36316 } else {
36317 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36319 }
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36327 PyObject *resultobj = 0;
36328 wxWindow *arg1 = (wxWindow *) 0 ;
36329 int *arg2 = (int *) 0 ;
36330 int *arg3 = (int *) 0 ;
36331 void *argp1 = 0 ;
36332 int res1 = 0 ;
36333 int temp2 ;
36334 int res2 = 0 ;
36335 int temp3 ;
36336 int res3 = 0 ;
36337 PyObject * obj0 = 0 ;
36338 PyObject * obj1 = 0 ;
36339 PyObject * obj2 = 0 ;
36340 char * kwnames[] = {
36341 (char *) "self",(char *) "x",(char *) "y", NULL
36342 };
36343
36344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36346 if (!SWIG_IsOK(res1)) {
36347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36348 }
36349 arg1 = reinterpret_cast< wxWindow * >(argp1);
36350 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36351 int val;
36352 int ecode = SWIG_AsVal_int(obj1, &val);
36353 if (!SWIG_IsOK(ecode)) {
36354 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36355 }
36356 temp2 = static_cast< int >(val);
36357 arg2 = &temp2;
36358 res2 = SWIG_AddTmpMask(ecode);
36359 }
36360 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36361 int val;
36362 int ecode = SWIG_AsVal_int(obj2, &val);
36363 if (!SWIG_IsOK(ecode)) {
36364 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36365 }
36366 temp3 = static_cast< int >(val);
36367 arg3 = &temp3;
36368 res3 = SWIG_AddTmpMask(ecode);
36369 }
36370 {
36371 PyThreadState* __tstate = wxPyBeginAllowThreads();
36372 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36373 wxPyEndAllowThreads(__tstate);
36374 if (PyErr_Occurred()) SWIG_fail;
36375 }
36376 resultobj = SWIG_Py_Void();
36377 if (SWIG_IsTmpObj(res2)) {
36378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36379 } else {
36380 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36382 }
36383 if (SWIG_IsTmpObj(res3)) {
36384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36385 } else {
36386 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36388 }
36389 return resultobj;
36390 fail:
36391 return NULL;
36392 }
36393
36394
36395 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36396 PyObject *resultobj = 0;
36397 wxWindow *arg1 = (wxWindow *) 0 ;
36398 wxPoint *arg2 = 0 ;
36399 wxPoint result;
36400 void *argp1 = 0 ;
36401 int res1 = 0 ;
36402 wxPoint temp2 ;
36403 PyObject * obj0 = 0 ;
36404 PyObject * obj1 = 0 ;
36405 char * kwnames[] = {
36406 (char *) "self",(char *) "pt", NULL
36407 };
36408
36409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36411 if (!SWIG_IsOK(res1)) {
36412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36413 }
36414 arg1 = reinterpret_cast< wxWindow * >(argp1);
36415 {
36416 arg2 = &temp2;
36417 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36418 }
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36433 PyObject *resultobj = 0;
36434 wxWindow *arg1 = (wxWindow *) 0 ;
36435 wxPoint *arg2 = 0 ;
36436 wxPoint result;
36437 void *argp1 = 0 ;
36438 int res1 = 0 ;
36439 wxPoint temp2 ;
36440 PyObject * obj0 = 0 ;
36441 PyObject * obj1 = 0 ;
36442 char * kwnames[] = {
36443 (char *) "self",(char *) "pt", NULL
36444 };
36445
36446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36448 if (!SWIG_IsOK(res1)) {
36449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36450 }
36451 arg1 = reinterpret_cast< wxWindow * >(argp1);
36452 {
36453 arg2 = &temp2;
36454 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36455 }
36456 {
36457 PyThreadState* __tstate = wxPyBeginAllowThreads();
36458 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36459 wxPyEndAllowThreads(__tstate);
36460 if (PyErr_Occurred()) SWIG_fail;
36461 }
36462 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36463 return resultobj;
36464 fail:
36465 return NULL;
36466 }
36467
36468
36469 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36470 PyObject *resultobj = 0;
36471 wxWindow *arg1 = (wxWindow *) 0 ;
36472 int arg2 ;
36473 int arg3 ;
36474 wxHitTest result;
36475 void *argp1 = 0 ;
36476 int res1 = 0 ;
36477 int val2 ;
36478 int ecode2 = 0 ;
36479 int val3 ;
36480 int ecode3 = 0 ;
36481 PyObject * obj0 = 0 ;
36482 PyObject * obj1 = 0 ;
36483 PyObject * obj2 = 0 ;
36484 char * kwnames[] = {
36485 (char *) "self",(char *) "x",(char *) "y", NULL
36486 };
36487
36488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36490 if (!SWIG_IsOK(res1)) {
36491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36492 }
36493 arg1 = reinterpret_cast< wxWindow * >(argp1);
36494 ecode2 = SWIG_AsVal_int(obj1, &val2);
36495 if (!SWIG_IsOK(ecode2)) {
36496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36497 }
36498 arg2 = static_cast< int >(val2);
36499 ecode3 = SWIG_AsVal_int(obj2, &val3);
36500 if (!SWIG_IsOK(ecode3)) {
36501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36502 }
36503 arg3 = static_cast< int >(val3);
36504 {
36505 PyThreadState* __tstate = wxPyBeginAllowThreads();
36506 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 resultobj = SWIG_From_int(static_cast< int >(result));
36511 return resultobj;
36512 fail:
36513 return NULL;
36514 }
36515
36516
36517 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36518 PyObject *resultobj = 0;
36519 wxWindow *arg1 = (wxWindow *) 0 ;
36520 wxPoint *arg2 = 0 ;
36521 wxHitTest result;
36522 void *argp1 = 0 ;
36523 int res1 = 0 ;
36524 wxPoint temp2 ;
36525 PyObject * obj0 = 0 ;
36526 PyObject * obj1 = 0 ;
36527 char * kwnames[] = {
36528 (char *) "self",(char *) "pt", NULL
36529 };
36530
36531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36533 if (!SWIG_IsOK(res1)) {
36534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36535 }
36536 arg1 = reinterpret_cast< wxWindow * >(argp1);
36537 {
36538 arg2 = &temp2;
36539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36540 }
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 resultobj = SWIG_From_int(static_cast< int >(result));
36548 return resultobj;
36549 fail:
36550 return NULL;
36551 }
36552
36553
36554 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36555 PyObject *resultobj = 0;
36556 wxWindow *arg1 = (wxWindow *) 0 ;
36557 long arg2 ;
36558 wxBorder result;
36559 void *argp1 = 0 ;
36560 int res1 = 0 ;
36561 long val2 ;
36562 int ecode2 = 0 ;
36563
36564 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36566 if (!SWIG_IsOK(res1)) {
36567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36568 }
36569 arg1 = reinterpret_cast< wxWindow * >(argp1);
36570 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36571 if (!SWIG_IsOK(ecode2)) {
36572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36573 }
36574 arg2 = static_cast< long >(val2);
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36578 wxPyEndAllowThreads(__tstate);
36579 if (PyErr_Occurred()) SWIG_fail;
36580 }
36581 resultobj = SWIG_From_int(static_cast< int >(result));
36582 return resultobj;
36583 fail:
36584 return NULL;
36585 }
36586
36587
36588 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36589 PyObject *resultobj = 0;
36590 wxWindow *arg1 = (wxWindow *) 0 ;
36591 wxBorder result;
36592 void *argp1 = 0 ;
36593 int res1 = 0 ;
36594
36595 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36597 if (!SWIG_IsOK(res1)) {
36598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36599 }
36600 arg1 = reinterpret_cast< wxWindow * >(argp1);
36601 {
36602 PyThreadState* __tstate = wxPyBeginAllowThreads();
36603 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36604 wxPyEndAllowThreads(__tstate);
36605 if (PyErr_Occurred()) SWIG_fail;
36606 }
36607 resultobj = SWIG_From_int(static_cast< int >(result));
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36615 int argc;
36616 PyObject *argv[3];
36617
36618 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36619 --argc;
36620 if (argc == 1) {
36621 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36622 }
36623 if (argc == 2) {
36624 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36625 }
36626
36627 fail:
36628 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36629 return NULL;
36630 }
36631
36632
36633 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36634 PyObject *resultobj = 0;
36635 wxWindow *arg1 = (wxWindow *) 0 ;
36636 long arg2 = (long) wxUPDATE_UI_NONE ;
36637 void *argp1 = 0 ;
36638 int res1 = 0 ;
36639 long val2 ;
36640 int ecode2 = 0 ;
36641 PyObject * obj0 = 0 ;
36642 PyObject * obj1 = 0 ;
36643 char * kwnames[] = {
36644 (char *) "self",(char *) "flags", NULL
36645 };
36646
36647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36649 if (!SWIG_IsOK(res1)) {
36650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36651 }
36652 arg1 = reinterpret_cast< wxWindow * >(argp1);
36653 if (obj1) {
36654 ecode2 = SWIG_AsVal_long(obj1, &val2);
36655 if (!SWIG_IsOK(ecode2)) {
36656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36657 }
36658 arg2 = static_cast< long >(val2);
36659 }
36660 {
36661 PyThreadState* __tstate = wxPyBeginAllowThreads();
36662 (arg1)->UpdateWindowUI(arg2);
36663 wxPyEndAllowThreads(__tstate);
36664 if (PyErr_Occurred()) SWIG_fail;
36665 }
36666 resultobj = SWIG_Py_Void();
36667 return resultobj;
36668 fail:
36669 return NULL;
36670 }
36671
36672
36673 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36674 PyObject *resultobj = 0;
36675 wxWindow *arg1 = (wxWindow *) 0 ;
36676 wxMenu *arg2 = (wxMenu *) 0 ;
36677 int arg3 = (int) -1 ;
36678 int arg4 = (int) -1 ;
36679 bool result;
36680 void *argp1 = 0 ;
36681 int res1 = 0 ;
36682 void *argp2 = 0 ;
36683 int res2 = 0 ;
36684 int val3 ;
36685 int ecode3 = 0 ;
36686 int val4 ;
36687 int ecode4 = 0 ;
36688 PyObject * obj0 = 0 ;
36689 PyObject * obj1 = 0 ;
36690 PyObject * obj2 = 0 ;
36691 PyObject * obj3 = 0 ;
36692 char * kwnames[] = {
36693 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36694 };
36695
36696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36698 if (!SWIG_IsOK(res1)) {
36699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36700 }
36701 arg1 = reinterpret_cast< wxWindow * >(argp1);
36702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36703 if (!SWIG_IsOK(res2)) {
36704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36705 }
36706 arg2 = reinterpret_cast< wxMenu * >(argp2);
36707 if (obj2) {
36708 ecode3 = SWIG_AsVal_int(obj2, &val3);
36709 if (!SWIG_IsOK(ecode3)) {
36710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36711 }
36712 arg3 = static_cast< int >(val3);
36713 }
36714 if (obj3) {
36715 ecode4 = SWIG_AsVal_int(obj3, &val4);
36716 if (!SWIG_IsOK(ecode4)) {
36717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36718 }
36719 arg4 = static_cast< int >(val4);
36720 }
36721 {
36722 PyThreadState* __tstate = wxPyBeginAllowThreads();
36723 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36724 wxPyEndAllowThreads(__tstate);
36725 if (PyErr_Occurred()) SWIG_fail;
36726 }
36727 {
36728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36729 }
36730 return resultobj;
36731 fail:
36732 return NULL;
36733 }
36734
36735
36736 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36737 PyObject *resultobj = 0;
36738 wxWindow *arg1 = (wxWindow *) 0 ;
36739 wxMenu *arg2 = (wxMenu *) 0 ;
36740 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36741 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36742 bool result;
36743 void *argp1 = 0 ;
36744 int res1 = 0 ;
36745 void *argp2 = 0 ;
36746 int res2 = 0 ;
36747 wxPoint temp3 ;
36748 PyObject * obj0 = 0 ;
36749 PyObject * obj1 = 0 ;
36750 PyObject * obj2 = 0 ;
36751 char * kwnames[] = {
36752 (char *) "self",(char *) "menu",(char *) "pos", NULL
36753 };
36754
36755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36757 if (!SWIG_IsOK(res1)) {
36758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36759 }
36760 arg1 = reinterpret_cast< wxWindow * >(argp1);
36761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36762 if (!SWIG_IsOK(res2)) {
36763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36764 }
36765 arg2 = reinterpret_cast< wxMenu * >(argp2);
36766 if (obj2) {
36767 {
36768 arg3 = &temp3;
36769 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36770 }
36771 }
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36775 wxPyEndAllowThreads(__tstate);
36776 if (PyErr_Occurred()) SWIG_fail;
36777 }
36778 {
36779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36780 }
36781 return resultobj;
36782 fail:
36783 return NULL;
36784 }
36785
36786
36787 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36788 PyObject *resultobj = 0;
36789 wxWindow *arg1 = (wxWindow *) 0 ;
36790 bool result;
36791 void *argp1 = 0 ;
36792 int res1 = 0 ;
36793 PyObject *swig_obj[1] ;
36794
36795 if (!args) SWIG_fail;
36796 swig_obj[0] = args;
36797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36798 if (!SWIG_IsOK(res1)) {
36799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36800 }
36801 arg1 = reinterpret_cast< wxWindow * >(argp1);
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 {
36809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36810 }
36811 return resultobj;
36812 fail:
36813 return NULL;
36814 }
36815
36816
36817 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36818 PyObject *resultobj = 0;
36819 wxWindow *arg1 = (wxWindow *) 0 ;
36820 long result;
36821 void *argp1 = 0 ;
36822 int res1 = 0 ;
36823 PyObject *swig_obj[1] ;
36824
36825 if (!args) SWIG_fail;
36826 swig_obj[0] = args;
36827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36830 }
36831 arg1 = reinterpret_cast< wxWindow * >(argp1);
36832 {
36833 PyThreadState* __tstate = wxPyBeginAllowThreads();
36834 result = (long)wxWindow_GetHandle(arg1);
36835 wxPyEndAllowThreads(__tstate);
36836 if (PyErr_Occurred()) SWIG_fail;
36837 }
36838 resultobj = SWIG_From_long(static_cast< long >(result));
36839 return resultobj;
36840 fail:
36841 return NULL;
36842 }
36843
36844
36845 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36846 PyObject *resultobj = 0;
36847 wxWindow *arg1 = (wxWindow *) 0 ;
36848 long arg2 ;
36849 void *argp1 = 0 ;
36850 int res1 = 0 ;
36851 long val2 ;
36852 int ecode2 = 0 ;
36853 PyObject * obj0 = 0 ;
36854 PyObject * obj1 = 0 ;
36855 char * kwnames[] = {
36856 (char *) "self",(char *) "handle", NULL
36857 };
36858
36859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36861 if (!SWIG_IsOK(res1)) {
36862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36863 }
36864 arg1 = reinterpret_cast< wxWindow * >(argp1);
36865 ecode2 = SWIG_AsVal_long(obj1, &val2);
36866 if (!SWIG_IsOK(ecode2)) {
36867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36868 }
36869 arg2 = static_cast< long >(val2);
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 wxWindow_AssociateHandle(arg1,arg2);
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 resultobj = SWIG_Py_Void();
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36884 PyObject *resultobj = 0;
36885 wxWindow *arg1 = (wxWindow *) 0 ;
36886 void *argp1 = 0 ;
36887 int res1 = 0 ;
36888 PyObject *swig_obj[1] ;
36889
36890 if (!args) SWIG_fail;
36891 swig_obj[0] = args;
36892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36893 if (!SWIG_IsOK(res1)) {
36894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36895 }
36896 arg1 = reinterpret_cast< wxWindow * >(argp1);
36897 {
36898 PyThreadState* __tstate = wxPyBeginAllowThreads();
36899 (arg1)->DissociateHandle();
36900 wxPyEndAllowThreads(__tstate);
36901 if (PyErr_Occurred()) SWIG_fail;
36902 }
36903 resultobj = SWIG_Py_Void();
36904 return resultobj;
36905 fail:
36906 return NULL;
36907 }
36908
36909
36910 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36911 PyObject *resultobj = 0;
36912 wxWindow *arg1 = (wxWindow *) 0 ;
36913 int arg2 ;
36914 bool result;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 int val2 ;
36918 int ecode2 = 0 ;
36919 PyObject * obj0 = 0 ;
36920 PyObject * obj1 = 0 ;
36921 char * kwnames[] = {
36922 (char *) "self",(char *) "orient", NULL
36923 };
36924
36925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36927 if (!SWIG_IsOK(res1)) {
36928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36929 }
36930 arg1 = reinterpret_cast< wxWindow * >(argp1);
36931 ecode2 = SWIG_AsVal_int(obj1, &val2);
36932 if (!SWIG_IsOK(ecode2)) {
36933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36934 }
36935 arg2 = static_cast< int >(val2);
36936 {
36937 PyThreadState* __tstate = wxPyBeginAllowThreads();
36938 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 {
36943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36944 }
36945 return resultobj;
36946 fail:
36947 return NULL;
36948 }
36949
36950
36951 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36952 PyObject *resultobj = 0;
36953 wxWindow *arg1 = (wxWindow *) 0 ;
36954 int arg2 ;
36955 int arg3 ;
36956 int arg4 ;
36957 int arg5 ;
36958 bool arg6 = (bool) true ;
36959 void *argp1 = 0 ;
36960 int res1 = 0 ;
36961 int val2 ;
36962 int ecode2 = 0 ;
36963 int val3 ;
36964 int ecode3 = 0 ;
36965 int val4 ;
36966 int ecode4 = 0 ;
36967 int val5 ;
36968 int ecode5 = 0 ;
36969 bool val6 ;
36970 int ecode6 = 0 ;
36971 PyObject * obj0 = 0 ;
36972 PyObject * obj1 = 0 ;
36973 PyObject * obj2 = 0 ;
36974 PyObject * obj3 = 0 ;
36975 PyObject * obj4 = 0 ;
36976 PyObject * obj5 = 0 ;
36977 char * kwnames[] = {
36978 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36979 };
36980
36981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36983 if (!SWIG_IsOK(res1)) {
36984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36985 }
36986 arg1 = reinterpret_cast< wxWindow * >(argp1);
36987 ecode2 = SWIG_AsVal_int(obj1, &val2);
36988 if (!SWIG_IsOK(ecode2)) {
36989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36990 }
36991 arg2 = static_cast< int >(val2);
36992 ecode3 = SWIG_AsVal_int(obj2, &val3);
36993 if (!SWIG_IsOK(ecode3)) {
36994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36995 }
36996 arg3 = static_cast< int >(val3);
36997 ecode4 = SWIG_AsVal_int(obj3, &val4);
36998 if (!SWIG_IsOK(ecode4)) {
36999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37000 }
37001 arg4 = static_cast< int >(val4);
37002 ecode5 = SWIG_AsVal_int(obj4, &val5);
37003 if (!SWIG_IsOK(ecode5)) {
37004 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37005 }
37006 arg5 = static_cast< int >(val5);
37007 if (obj5) {
37008 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37009 if (!SWIG_IsOK(ecode6)) {
37010 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37011 }
37012 arg6 = static_cast< bool >(val6);
37013 }
37014 {
37015 PyThreadState* __tstate = wxPyBeginAllowThreads();
37016 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37017 wxPyEndAllowThreads(__tstate);
37018 if (PyErr_Occurred()) SWIG_fail;
37019 }
37020 resultobj = SWIG_Py_Void();
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37028 PyObject *resultobj = 0;
37029 wxWindow *arg1 = (wxWindow *) 0 ;
37030 int arg2 ;
37031 int arg3 ;
37032 bool arg4 = (bool) true ;
37033 void *argp1 = 0 ;
37034 int res1 = 0 ;
37035 int val2 ;
37036 int ecode2 = 0 ;
37037 int val3 ;
37038 int ecode3 = 0 ;
37039 bool val4 ;
37040 int ecode4 = 0 ;
37041 PyObject * obj0 = 0 ;
37042 PyObject * obj1 = 0 ;
37043 PyObject * obj2 = 0 ;
37044 PyObject * obj3 = 0 ;
37045 char * kwnames[] = {
37046 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37047 };
37048
37049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37051 if (!SWIG_IsOK(res1)) {
37052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37053 }
37054 arg1 = reinterpret_cast< wxWindow * >(argp1);
37055 ecode2 = SWIG_AsVal_int(obj1, &val2);
37056 if (!SWIG_IsOK(ecode2)) {
37057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37058 }
37059 arg2 = static_cast< int >(val2);
37060 ecode3 = SWIG_AsVal_int(obj2, &val3);
37061 if (!SWIG_IsOK(ecode3)) {
37062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37063 }
37064 arg3 = static_cast< int >(val3);
37065 if (obj3) {
37066 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37067 if (!SWIG_IsOK(ecode4)) {
37068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37069 }
37070 arg4 = static_cast< bool >(val4);
37071 }
37072 {
37073 PyThreadState* __tstate = wxPyBeginAllowThreads();
37074 (arg1)->SetScrollPos(arg2,arg3,arg4);
37075 wxPyEndAllowThreads(__tstate);
37076 if (PyErr_Occurred()) SWIG_fail;
37077 }
37078 resultobj = SWIG_Py_Void();
37079 return resultobj;
37080 fail:
37081 return NULL;
37082 }
37083
37084
37085 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37086 PyObject *resultobj = 0;
37087 wxWindow *arg1 = (wxWindow *) 0 ;
37088 int arg2 ;
37089 int result;
37090 void *argp1 = 0 ;
37091 int res1 = 0 ;
37092 int val2 ;
37093 int ecode2 = 0 ;
37094 PyObject * obj0 = 0 ;
37095 PyObject * obj1 = 0 ;
37096 char * kwnames[] = {
37097 (char *) "self",(char *) "orientation", NULL
37098 };
37099
37100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37102 if (!SWIG_IsOK(res1)) {
37103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37104 }
37105 arg1 = reinterpret_cast< wxWindow * >(argp1);
37106 ecode2 = SWIG_AsVal_int(obj1, &val2);
37107 if (!SWIG_IsOK(ecode2)) {
37108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37109 }
37110 arg2 = static_cast< int >(val2);
37111 {
37112 PyThreadState* __tstate = wxPyBeginAllowThreads();
37113 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 resultobj = SWIG_From_int(static_cast< int >(result));
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj = 0;
37126 wxWindow *arg1 = (wxWindow *) 0 ;
37127 int arg2 ;
37128 int result;
37129 void *argp1 = 0 ;
37130 int res1 = 0 ;
37131 int val2 ;
37132 int ecode2 = 0 ;
37133 PyObject * obj0 = 0 ;
37134 PyObject * obj1 = 0 ;
37135 char * kwnames[] = {
37136 (char *) "self",(char *) "orientation", NULL
37137 };
37138
37139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37141 if (!SWIG_IsOK(res1)) {
37142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37143 }
37144 arg1 = reinterpret_cast< wxWindow * >(argp1);
37145 ecode2 = SWIG_AsVal_int(obj1, &val2);
37146 if (!SWIG_IsOK(ecode2)) {
37147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37148 }
37149 arg2 = static_cast< int >(val2);
37150 {
37151 PyThreadState* __tstate = wxPyBeginAllowThreads();
37152 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 resultobj = SWIG_From_int(static_cast< int >(result));
37157 return resultobj;
37158 fail:
37159 return NULL;
37160 }
37161
37162
37163 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37164 PyObject *resultobj = 0;
37165 wxWindow *arg1 = (wxWindow *) 0 ;
37166 int arg2 ;
37167 int result;
37168 void *argp1 = 0 ;
37169 int res1 = 0 ;
37170 int val2 ;
37171 int ecode2 = 0 ;
37172 PyObject * obj0 = 0 ;
37173 PyObject * obj1 = 0 ;
37174 char * kwnames[] = {
37175 (char *) "self",(char *) "orientation", NULL
37176 };
37177
37178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37180 if (!SWIG_IsOK(res1)) {
37181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37182 }
37183 arg1 = reinterpret_cast< wxWindow * >(argp1);
37184 ecode2 = SWIG_AsVal_int(obj1, &val2);
37185 if (!SWIG_IsOK(ecode2)) {
37186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37187 }
37188 arg2 = static_cast< int >(val2);
37189 {
37190 PyThreadState* __tstate = wxPyBeginAllowThreads();
37191 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37192 wxPyEndAllowThreads(__tstate);
37193 if (PyErr_Occurred()) SWIG_fail;
37194 }
37195 resultobj = SWIG_From_int(static_cast< int >(result));
37196 return resultobj;
37197 fail:
37198 return NULL;
37199 }
37200
37201
37202 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37203 PyObject *resultobj = 0;
37204 wxWindow *arg1 = (wxWindow *) 0 ;
37205 int arg2 ;
37206 int arg3 ;
37207 wxRect *arg4 = (wxRect *) NULL ;
37208 void *argp1 = 0 ;
37209 int res1 = 0 ;
37210 int val2 ;
37211 int ecode2 = 0 ;
37212 int val3 ;
37213 int ecode3 = 0 ;
37214 void *argp4 = 0 ;
37215 int res4 = 0 ;
37216 PyObject * obj0 = 0 ;
37217 PyObject * obj1 = 0 ;
37218 PyObject * obj2 = 0 ;
37219 PyObject * obj3 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37226 if (!SWIG_IsOK(res1)) {
37227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37228 }
37229 arg1 = reinterpret_cast< wxWindow * >(argp1);
37230 ecode2 = SWIG_AsVal_int(obj1, &val2);
37231 if (!SWIG_IsOK(ecode2)) {
37232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37233 }
37234 arg2 = static_cast< int >(val2);
37235 ecode3 = SWIG_AsVal_int(obj2, &val3);
37236 if (!SWIG_IsOK(ecode3)) {
37237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37238 }
37239 arg3 = static_cast< int >(val3);
37240 if (obj3) {
37241 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37242 if (!SWIG_IsOK(res4)) {
37243 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37244 }
37245 arg4 = reinterpret_cast< wxRect * >(argp4);
37246 }
37247 {
37248 PyThreadState* __tstate = wxPyBeginAllowThreads();
37249 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37250 wxPyEndAllowThreads(__tstate);
37251 if (PyErr_Occurred()) SWIG_fail;
37252 }
37253 resultobj = SWIG_Py_Void();
37254 return resultobj;
37255 fail:
37256 return NULL;
37257 }
37258
37259
37260 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37261 PyObject *resultobj = 0;
37262 wxWindow *arg1 = (wxWindow *) 0 ;
37263 int arg2 ;
37264 bool result;
37265 void *argp1 = 0 ;
37266 int res1 = 0 ;
37267 int val2 ;
37268 int ecode2 = 0 ;
37269 PyObject * obj0 = 0 ;
37270 PyObject * obj1 = 0 ;
37271 char * kwnames[] = {
37272 (char *) "self",(char *) "lines", NULL
37273 };
37274
37275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37277 if (!SWIG_IsOK(res1)) {
37278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37279 }
37280 arg1 = reinterpret_cast< wxWindow * >(argp1);
37281 ecode2 = SWIG_AsVal_int(obj1, &val2);
37282 if (!SWIG_IsOK(ecode2)) {
37283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37284 }
37285 arg2 = static_cast< int >(val2);
37286 {
37287 PyThreadState* __tstate = wxPyBeginAllowThreads();
37288 result = (bool)(arg1)->ScrollLines(arg2);
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 {
37293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37294 }
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 int arg2 ;
37305 bool result;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 int val2 ;
37309 int ecode2 = 0 ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char * kwnames[] = {
37313 (char *) "self",(char *) "pages", NULL
37314 };
37315
37316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37318 if (!SWIG_IsOK(res1)) {
37319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37320 }
37321 arg1 = reinterpret_cast< wxWindow * >(argp1);
37322 ecode2 = SWIG_AsVal_int(obj1, &val2);
37323 if (!SWIG_IsOK(ecode2)) {
37324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37325 }
37326 arg2 = static_cast< int >(val2);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 result = (bool)(arg1)->ScrollPages(arg2);
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 {
37334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37335 }
37336 return resultobj;
37337 fail:
37338 return NULL;
37339 }
37340
37341
37342 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37343 PyObject *resultobj = 0;
37344 wxWindow *arg1 = (wxWindow *) 0 ;
37345 bool result;
37346 void *argp1 = 0 ;
37347 int res1 = 0 ;
37348 PyObject *swig_obj[1] ;
37349
37350 if (!args) SWIG_fail;
37351 swig_obj[0] = args;
37352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37353 if (!SWIG_IsOK(res1)) {
37354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37355 }
37356 arg1 = reinterpret_cast< wxWindow * >(argp1);
37357 {
37358 PyThreadState* __tstate = wxPyBeginAllowThreads();
37359 result = (bool)(arg1)->LineUp();
37360 wxPyEndAllowThreads(__tstate);
37361 if (PyErr_Occurred()) SWIG_fail;
37362 }
37363 {
37364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37365 }
37366 return resultobj;
37367 fail:
37368 return NULL;
37369 }
37370
37371
37372 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37373 PyObject *resultobj = 0;
37374 wxWindow *arg1 = (wxWindow *) 0 ;
37375 bool result;
37376 void *argp1 = 0 ;
37377 int res1 = 0 ;
37378 PyObject *swig_obj[1] ;
37379
37380 if (!args) SWIG_fail;
37381 swig_obj[0] = args;
37382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37383 if (!SWIG_IsOK(res1)) {
37384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37385 }
37386 arg1 = reinterpret_cast< wxWindow * >(argp1);
37387 {
37388 PyThreadState* __tstate = wxPyBeginAllowThreads();
37389 result = (bool)(arg1)->LineDown();
37390 wxPyEndAllowThreads(__tstate);
37391 if (PyErr_Occurred()) SWIG_fail;
37392 }
37393 {
37394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37395 }
37396 return resultobj;
37397 fail:
37398 return NULL;
37399 }
37400
37401
37402 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37403 PyObject *resultobj = 0;
37404 wxWindow *arg1 = (wxWindow *) 0 ;
37405 bool result;
37406 void *argp1 = 0 ;
37407 int res1 = 0 ;
37408 PyObject *swig_obj[1] ;
37409
37410 if (!args) SWIG_fail;
37411 swig_obj[0] = args;
37412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37413 if (!SWIG_IsOK(res1)) {
37414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37415 }
37416 arg1 = reinterpret_cast< wxWindow * >(argp1);
37417 {
37418 PyThreadState* __tstate = wxPyBeginAllowThreads();
37419 result = (bool)(arg1)->PageUp();
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 {
37424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37425 }
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37433 PyObject *resultobj = 0;
37434 wxWindow *arg1 = (wxWindow *) 0 ;
37435 bool result;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 PyObject *swig_obj[1] ;
37439
37440 if (!args) SWIG_fail;
37441 swig_obj[0] = args;
37442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37443 if (!SWIG_IsOK(res1)) {
37444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37445 }
37446 arg1 = reinterpret_cast< wxWindow * >(argp1);
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 result = (bool)(arg1)->PageDown();
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 {
37454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37455 }
37456 return resultobj;
37457 fail:
37458 return NULL;
37459 }
37460
37461
37462 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37463 PyObject *resultobj = 0;
37464 wxWindow *arg1 = (wxWindow *) 0 ;
37465 wxString *arg2 = 0 ;
37466 void *argp1 = 0 ;
37467 int res1 = 0 ;
37468 bool temp2 = false ;
37469 PyObject * obj0 = 0 ;
37470 PyObject * obj1 = 0 ;
37471 char * kwnames[] = {
37472 (char *) "self",(char *) "text", NULL
37473 };
37474
37475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37477 if (!SWIG_IsOK(res1)) {
37478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37479 }
37480 arg1 = reinterpret_cast< wxWindow * >(argp1);
37481 {
37482 arg2 = wxString_in_helper(obj1);
37483 if (arg2 == NULL) SWIG_fail;
37484 temp2 = true;
37485 }
37486 {
37487 PyThreadState* __tstate = wxPyBeginAllowThreads();
37488 (arg1)->SetHelpText((wxString const &)*arg2);
37489 wxPyEndAllowThreads(__tstate);
37490 if (PyErr_Occurred()) SWIG_fail;
37491 }
37492 resultobj = SWIG_Py_Void();
37493 {
37494 if (temp2)
37495 delete arg2;
37496 }
37497 return resultobj;
37498 fail:
37499 {
37500 if (temp2)
37501 delete arg2;
37502 }
37503 return NULL;
37504 }
37505
37506
37507 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37508 PyObject *resultobj = 0;
37509 wxWindow *arg1 = (wxWindow *) 0 ;
37510 wxString *arg2 = 0 ;
37511 void *argp1 = 0 ;
37512 int res1 = 0 ;
37513 bool temp2 = false ;
37514 PyObject * obj0 = 0 ;
37515 PyObject * obj1 = 0 ;
37516 char * kwnames[] = {
37517 (char *) "self",(char *) "text", NULL
37518 };
37519
37520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37522 if (!SWIG_IsOK(res1)) {
37523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37524 }
37525 arg1 = reinterpret_cast< wxWindow * >(argp1);
37526 {
37527 arg2 = wxString_in_helper(obj1);
37528 if (arg2 == NULL) SWIG_fail;
37529 temp2 = true;
37530 }
37531 {
37532 PyThreadState* __tstate = wxPyBeginAllowThreads();
37533 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37534 wxPyEndAllowThreads(__tstate);
37535 if (PyErr_Occurred()) SWIG_fail;
37536 }
37537 resultobj = SWIG_Py_Void();
37538 {
37539 if (temp2)
37540 delete arg2;
37541 }
37542 return resultobj;
37543 fail:
37544 {
37545 if (temp2)
37546 delete arg2;
37547 }
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 wxPoint *arg2 = 0 ;
37556 wxHelpEvent::Origin arg3 ;
37557 wxString result;
37558 void *argp1 = 0 ;
37559 int res1 = 0 ;
37560 wxPoint temp2 ;
37561 void *argp3 ;
37562 int res3 = 0 ;
37563 PyObject * obj0 = 0 ;
37564 PyObject * obj1 = 0 ;
37565 PyObject * obj2 = 0 ;
37566 char * kwnames[] = {
37567 (char *) "self",(char *) "pt",(char *) "origin", NULL
37568 };
37569
37570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37572 if (!SWIG_IsOK(res1)) {
37573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37574 }
37575 arg1 = reinterpret_cast< wxWindow * >(argp1);
37576 {
37577 arg2 = &temp2;
37578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37579 }
37580 {
37581 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37582 if (!SWIG_IsOK(res3)) {
37583 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37584 }
37585 if (!argp3) {
37586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37587 } else {
37588 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37589 arg3 = *temp;
37590 if (SWIG_IsNewObj(res3)) delete temp;
37591 }
37592 }
37593 {
37594 PyThreadState* __tstate = wxPyBeginAllowThreads();
37595 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37596 wxPyEndAllowThreads(__tstate);
37597 if (PyErr_Occurred()) SWIG_fail;
37598 }
37599 {
37600 #if wxUSE_UNICODE
37601 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37602 #else
37603 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37604 #endif
37605 }
37606 return resultobj;
37607 fail:
37608 return NULL;
37609 }
37610
37611
37612 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37613 PyObject *resultobj = 0;
37614 wxWindow *arg1 = (wxWindow *) 0 ;
37615 wxString result;
37616 void *argp1 = 0 ;
37617 int res1 = 0 ;
37618 PyObject *swig_obj[1] ;
37619
37620 if (!args) SWIG_fail;
37621 swig_obj[0] = args;
37622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37623 if (!SWIG_IsOK(res1)) {
37624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37625 }
37626 arg1 = reinterpret_cast< wxWindow * >(argp1);
37627 {
37628 PyThreadState* __tstate = wxPyBeginAllowThreads();
37629 result = ((wxWindow const *)arg1)->GetHelpText();
37630 wxPyEndAllowThreads(__tstate);
37631 if (PyErr_Occurred()) SWIG_fail;
37632 }
37633 {
37634 #if wxUSE_UNICODE
37635 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37636 #else
37637 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37638 #endif
37639 }
37640 return resultobj;
37641 fail:
37642 return NULL;
37643 }
37644
37645
37646 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37647 PyObject *resultobj = 0;
37648 wxWindow *arg1 = (wxWindow *) 0 ;
37649 wxString *arg2 = 0 ;
37650 void *argp1 = 0 ;
37651 int res1 = 0 ;
37652 bool temp2 = false ;
37653 PyObject * obj0 = 0 ;
37654 PyObject * obj1 = 0 ;
37655 char * kwnames[] = {
37656 (char *) "self",(char *) "tip", NULL
37657 };
37658
37659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37661 if (!SWIG_IsOK(res1)) {
37662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37663 }
37664 arg1 = reinterpret_cast< wxWindow * >(argp1);
37665 {
37666 arg2 = wxString_in_helper(obj1);
37667 if (arg2 == NULL) SWIG_fail;
37668 temp2 = true;
37669 }
37670 {
37671 PyThreadState* __tstate = wxPyBeginAllowThreads();
37672 (arg1)->SetToolTip((wxString const &)*arg2);
37673 wxPyEndAllowThreads(__tstate);
37674 if (PyErr_Occurred()) SWIG_fail;
37675 }
37676 resultobj = SWIG_Py_Void();
37677 {
37678 if (temp2)
37679 delete arg2;
37680 }
37681 return resultobj;
37682 fail:
37683 {
37684 if (temp2)
37685 delete arg2;
37686 }
37687 return NULL;
37688 }
37689
37690
37691 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37692 PyObject *resultobj = 0;
37693 wxWindow *arg1 = (wxWindow *) 0 ;
37694 wxToolTip *arg2 = (wxToolTip *) 0 ;
37695 void *argp1 = 0 ;
37696 int res1 = 0 ;
37697 int res2 = 0 ;
37698 PyObject * obj0 = 0 ;
37699 PyObject * obj1 = 0 ;
37700 char * kwnames[] = {
37701 (char *) "self",(char *) "tip", NULL
37702 };
37703
37704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37706 if (!SWIG_IsOK(res1)) {
37707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37708 }
37709 arg1 = reinterpret_cast< wxWindow * >(argp1);
37710 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37711 if (!SWIG_IsOK(res2)) {
37712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37713 }
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 (arg1)->SetToolTip(arg2);
37717 wxPyEndAllowThreads(__tstate);
37718 if (PyErr_Occurred()) SWIG_fail;
37719 }
37720 resultobj = SWIG_Py_Void();
37721 return resultobj;
37722 fail:
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37728 PyObject *resultobj = 0;
37729 wxWindow *arg1 = (wxWindow *) 0 ;
37730 wxToolTip *result = 0 ;
37731 void *argp1 = 0 ;
37732 int res1 = 0 ;
37733 PyObject *swig_obj[1] ;
37734
37735 if (!args) SWIG_fail;
37736 swig_obj[0] = args;
37737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37738 if (!SWIG_IsOK(res1)) {
37739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37740 }
37741 arg1 = reinterpret_cast< wxWindow * >(argp1);
37742 {
37743 PyThreadState* __tstate = wxPyBeginAllowThreads();
37744 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37745 wxPyEndAllowThreads(__tstate);
37746 if (PyErr_Occurred()) SWIG_fail;
37747 }
37748 {
37749 resultobj = wxPyMake_wxObject(result, (bool)0);
37750 }
37751 return resultobj;
37752 fail:
37753 return NULL;
37754 }
37755
37756
37757 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37758 PyObject *resultobj = 0;
37759 wxWindow *arg1 = (wxWindow *) 0 ;
37760 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37761 void *argp1 = 0 ;
37762 int res1 = 0 ;
37763 int res2 = 0 ;
37764 PyObject * obj0 = 0 ;
37765 PyObject * obj1 = 0 ;
37766 char * kwnames[] = {
37767 (char *) "self",(char *) "dropTarget", NULL
37768 };
37769
37770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37772 if (!SWIG_IsOK(res1)) {
37773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37774 }
37775 arg1 = reinterpret_cast< wxWindow * >(argp1);
37776 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37777 if (!SWIG_IsOK(res2)) {
37778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37779 }
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 (arg1)->SetDropTarget(arg2);
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 resultobj = SWIG_Py_Void();
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37794 PyObject *resultobj = 0;
37795 wxWindow *arg1 = (wxWindow *) 0 ;
37796 wxPyDropTarget *result = 0 ;
37797 void *argp1 = 0 ;
37798 int res1 = 0 ;
37799 PyObject *swig_obj[1] ;
37800
37801 if (!args) SWIG_fail;
37802 swig_obj[0] = args;
37803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37804 if (!SWIG_IsOK(res1)) {
37805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37806 }
37807 arg1 = reinterpret_cast< wxWindow * >(argp1);
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37811 wxPyEndAllowThreads(__tstate);
37812 if (PyErr_Occurred()) SWIG_fail;
37813 }
37814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37822 PyObject *resultobj = 0;
37823 wxWindow *arg1 = (wxWindow *) 0 ;
37824 bool arg2 ;
37825 void *argp1 = 0 ;
37826 int res1 = 0 ;
37827 bool val2 ;
37828 int ecode2 = 0 ;
37829 PyObject * obj0 = 0 ;
37830 PyObject * obj1 = 0 ;
37831 char * kwnames[] = {
37832 (char *) "self",(char *) "accept", NULL
37833 };
37834
37835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37837 if (!SWIG_IsOK(res1)) {
37838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37839 }
37840 arg1 = reinterpret_cast< wxWindow * >(argp1);
37841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37842 if (!SWIG_IsOK(ecode2)) {
37843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37844 }
37845 arg2 = static_cast< bool >(val2);
37846 {
37847 PyThreadState* __tstate = wxPyBeginAllowThreads();
37848 wxWindow_DragAcceptFiles(arg1,arg2);
37849 wxPyEndAllowThreads(__tstate);
37850 if (PyErr_Occurred()) SWIG_fail;
37851 }
37852 resultobj = SWIG_Py_Void();
37853 return resultobj;
37854 fail:
37855 return NULL;
37856 }
37857
37858
37859 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37860 PyObject *resultobj = 0;
37861 wxWindow *arg1 = (wxWindow *) 0 ;
37862 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37863 void *argp1 = 0 ;
37864 int res1 = 0 ;
37865 int res2 = 0 ;
37866 PyObject * obj0 = 0 ;
37867 PyObject * obj1 = 0 ;
37868 char * kwnames[] = {
37869 (char *) "self",(char *) "constraints", NULL
37870 };
37871
37872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37874 if (!SWIG_IsOK(res1)) {
37875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37876 }
37877 arg1 = reinterpret_cast< wxWindow * >(argp1);
37878 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37879 if (!SWIG_IsOK(res2)) {
37880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37881 }
37882 {
37883 PyThreadState* __tstate = wxPyBeginAllowThreads();
37884 (arg1)->SetConstraints(arg2);
37885 wxPyEndAllowThreads(__tstate);
37886 if (PyErr_Occurred()) SWIG_fail;
37887 }
37888 resultobj = SWIG_Py_Void();
37889 return resultobj;
37890 fail:
37891 return NULL;
37892 }
37893
37894
37895 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37896 PyObject *resultobj = 0;
37897 wxWindow *arg1 = (wxWindow *) 0 ;
37898 wxLayoutConstraints *result = 0 ;
37899 void *argp1 = 0 ;
37900 int res1 = 0 ;
37901 PyObject *swig_obj[1] ;
37902
37903 if (!args) SWIG_fail;
37904 swig_obj[0] = args;
37905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37906 if (!SWIG_IsOK(res1)) {
37907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37908 }
37909 arg1 = reinterpret_cast< wxWindow * >(argp1);
37910 {
37911 PyThreadState* __tstate = wxPyBeginAllowThreads();
37912 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37913 wxPyEndAllowThreads(__tstate);
37914 if (PyErr_Occurred()) SWIG_fail;
37915 }
37916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37924 PyObject *resultobj = 0;
37925 wxWindow *arg1 = (wxWindow *) 0 ;
37926 bool arg2 ;
37927 void *argp1 = 0 ;
37928 int res1 = 0 ;
37929 bool val2 ;
37930 int ecode2 = 0 ;
37931 PyObject * obj0 = 0 ;
37932 PyObject * obj1 = 0 ;
37933 char * kwnames[] = {
37934 (char *) "self",(char *) "autoLayout", NULL
37935 };
37936
37937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37939 if (!SWIG_IsOK(res1)) {
37940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37941 }
37942 arg1 = reinterpret_cast< wxWindow * >(argp1);
37943 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37944 if (!SWIG_IsOK(ecode2)) {
37945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37946 }
37947 arg2 = static_cast< bool >(val2);
37948 {
37949 PyThreadState* __tstate = wxPyBeginAllowThreads();
37950 (arg1)->SetAutoLayout(arg2);
37951 wxPyEndAllowThreads(__tstate);
37952 if (PyErr_Occurred()) SWIG_fail;
37953 }
37954 resultobj = SWIG_Py_Void();
37955 return resultobj;
37956 fail:
37957 return NULL;
37958 }
37959
37960
37961 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37962 PyObject *resultobj = 0;
37963 wxWindow *arg1 = (wxWindow *) 0 ;
37964 bool result;
37965 void *argp1 = 0 ;
37966 int res1 = 0 ;
37967 PyObject *swig_obj[1] ;
37968
37969 if (!args) SWIG_fail;
37970 swig_obj[0] = args;
37971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37972 if (!SWIG_IsOK(res1)) {
37973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37974 }
37975 arg1 = reinterpret_cast< wxWindow * >(argp1);
37976 {
37977 PyThreadState* __tstate = wxPyBeginAllowThreads();
37978 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37979 wxPyEndAllowThreads(__tstate);
37980 if (PyErr_Occurred()) SWIG_fail;
37981 }
37982 {
37983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37984 }
37985 return resultobj;
37986 fail:
37987 return NULL;
37988 }
37989
37990
37991 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37992 PyObject *resultobj = 0;
37993 wxWindow *arg1 = (wxWindow *) 0 ;
37994 bool result;
37995 void *argp1 = 0 ;
37996 int res1 = 0 ;
37997 PyObject *swig_obj[1] ;
37998
37999 if (!args) SWIG_fail;
38000 swig_obj[0] = args;
38001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38002 if (!SWIG_IsOK(res1)) {
38003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38004 }
38005 arg1 = reinterpret_cast< wxWindow * >(argp1);
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 result = (bool)(arg1)->Layout();
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 {
38013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38014 }
38015 return resultobj;
38016 fail:
38017 return NULL;
38018 }
38019
38020
38021 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38022 PyObject *resultobj = 0;
38023 wxWindow *arg1 = (wxWindow *) 0 ;
38024 wxSizer *arg2 = (wxSizer *) 0 ;
38025 bool arg3 = (bool) true ;
38026 void *argp1 = 0 ;
38027 int res1 = 0 ;
38028 int res2 = 0 ;
38029 bool val3 ;
38030 int ecode3 = 0 ;
38031 PyObject * obj0 = 0 ;
38032 PyObject * obj1 = 0 ;
38033 PyObject * obj2 = 0 ;
38034 char * kwnames[] = {
38035 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38036 };
38037
38038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38040 if (!SWIG_IsOK(res1)) {
38041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38042 }
38043 arg1 = reinterpret_cast< wxWindow * >(argp1);
38044 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38045 if (!SWIG_IsOK(res2)) {
38046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38047 }
38048 if (obj2) {
38049 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38050 if (!SWIG_IsOK(ecode3)) {
38051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38052 }
38053 arg3 = static_cast< bool >(val3);
38054 }
38055 {
38056 PyThreadState* __tstate = wxPyBeginAllowThreads();
38057 (arg1)->SetSizer(arg2,arg3);
38058 wxPyEndAllowThreads(__tstate);
38059 if (PyErr_Occurred()) SWIG_fail;
38060 }
38061 resultobj = SWIG_Py_Void();
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38069 PyObject *resultobj = 0;
38070 wxWindow *arg1 = (wxWindow *) 0 ;
38071 wxSizer *arg2 = (wxSizer *) 0 ;
38072 bool arg3 = (bool) true ;
38073 void *argp1 = 0 ;
38074 int res1 = 0 ;
38075 int res2 = 0 ;
38076 bool val3 ;
38077 int ecode3 = 0 ;
38078 PyObject * obj0 = 0 ;
38079 PyObject * obj1 = 0 ;
38080 PyObject * obj2 = 0 ;
38081 char * kwnames[] = {
38082 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38083 };
38084
38085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38087 if (!SWIG_IsOK(res1)) {
38088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38089 }
38090 arg1 = reinterpret_cast< wxWindow * >(argp1);
38091 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38092 if (!SWIG_IsOK(res2)) {
38093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38094 }
38095 if (obj2) {
38096 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38097 if (!SWIG_IsOK(ecode3)) {
38098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38099 }
38100 arg3 = static_cast< bool >(val3);
38101 }
38102 {
38103 PyThreadState* __tstate = wxPyBeginAllowThreads();
38104 (arg1)->SetSizerAndFit(arg2,arg3);
38105 wxPyEndAllowThreads(__tstate);
38106 if (PyErr_Occurred()) SWIG_fail;
38107 }
38108 resultobj = SWIG_Py_Void();
38109 return resultobj;
38110 fail:
38111 return NULL;
38112 }
38113
38114
38115 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38116 PyObject *resultobj = 0;
38117 wxWindow *arg1 = (wxWindow *) 0 ;
38118 wxSizer *result = 0 ;
38119 void *argp1 = 0 ;
38120 int res1 = 0 ;
38121 PyObject *swig_obj[1] ;
38122
38123 if (!args) SWIG_fail;
38124 swig_obj[0] = args;
38125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38126 if (!SWIG_IsOK(res1)) {
38127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38128 }
38129 arg1 = reinterpret_cast< wxWindow * >(argp1);
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38133 wxPyEndAllowThreads(__tstate);
38134 if (PyErr_Occurred()) SWIG_fail;
38135 }
38136 {
38137 resultobj = wxPyMake_wxObject(result, (bool)0);
38138 }
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj = 0;
38147 wxWindow *arg1 = (wxWindow *) 0 ;
38148 wxSizer *arg2 = (wxSizer *) 0 ;
38149 void *argp1 = 0 ;
38150 int res1 = 0 ;
38151 void *argp2 = 0 ;
38152 int res2 = 0 ;
38153 PyObject * obj0 = 0 ;
38154 PyObject * obj1 = 0 ;
38155 char * kwnames[] = {
38156 (char *) "self",(char *) "sizer", NULL
38157 };
38158
38159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38163 }
38164 arg1 = reinterpret_cast< wxWindow * >(argp1);
38165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38166 if (!SWIG_IsOK(res2)) {
38167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38168 }
38169 arg2 = reinterpret_cast< wxSizer * >(argp2);
38170 {
38171 PyThreadState* __tstate = wxPyBeginAllowThreads();
38172 (arg1)->SetContainingSizer(arg2);
38173 wxPyEndAllowThreads(__tstate);
38174 if (PyErr_Occurred()) SWIG_fail;
38175 }
38176 resultobj = SWIG_Py_Void();
38177 return resultobj;
38178 fail:
38179 return NULL;
38180 }
38181
38182
38183 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38184 PyObject *resultobj = 0;
38185 wxWindow *arg1 = (wxWindow *) 0 ;
38186 wxSizer *result = 0 ;
38187 void *argp1 = 0 ;
38188 int res1 = 0 ;
38189 PyObject *swig_obj[1] ;
38190
38191 if (!args) SWIG_fail;
38192 swig_obj[0] = args;
38193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38194 if (!SWIG_IsOK(res1)) {
38195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38196 }
38197 arg1 = reinterpret_cast< wxWindow * >(argp1);
38198 {
38199 PyThreadState* __tstate = wxPyBeginAllowThreads();
38200 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38201 wxPyEndAllowThreads(__tstate);
38202 if (PyErr_Occurred()) SWIG_fail;
38203 }
38204 {
38205 resultobj = wxPyMake_wxObject(result, (bool)0);
38206 }
38207 return resultobj;
38208 fail:
38209 return NULL;
38210 }
38211
38212
38213 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38214 PyObject *resultobj = 0;
38215 wxWindow *arg1 = (wxWindow *) 0 ;
38216 void *argp1 = 0 ;
38217 int res1 = 0 ;
38218 PyObject *swig_obj[1] ;
38219
38220 if (!args) SWIG_fail;
38221 swig_obj[0] = args;
38222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38223 if (!SWIG_IsOK(res1)) {
38224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38225 }
38226 arg1 = reinterpret_cast< wxWindow * >(argp1);
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 (arg1)->InheritAttributes();
38230 wxPyEndAllowThreads(__tstate);
38231 if (PyErr_Occurred()) SWIG_fail;
38232 }
38233 resultobj = SWIG_Py_Void();
38234 return resultobj;
38235 fail:
38236 return NULL;
38237 }
38238
38239
38240 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38241 PyObject *resultobj = 0;
38242 wxWindow *arg1 = (wxWindow *) 0 ;
38243 bool result;
38244 void *argp1 = 0 ;
38245 int res1 = 0 ;
38246 PyObject *swig_obj[1] ;
38247
38248 if (!args) SWIG_fail;
38249 swig_obj[0] = args;
38250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38251 if (!SWIG_IsOK(res1)) {
38252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38253 }
38254 arg1 = reinterpret_cast< wxWindow * >(argp1);
38255 {
38256 PyThreadState* __tstate = wxPyBeginAllowThreads();
38257 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38258 wxPyEndAllowThreads(__tstate);
38259 if (PyErr_Occurred()) SWIG_fail;
38260 }
38261 {
38262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38263 }
38264 return resultobj;
38265 fail:
38266 return NULL;
38267 }
38268
38269
38270 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38271 PyObject *resultobj = 0;
38272 wxWindow *arg1 = (wxWindow *) 0 ;
38273 bool result;
38274 void *argp1 = 0 ;
38275 int res1 = 0 ;
38276 PyObject *swig_obj[1] ;
38277
38278 if (!args) SWIG_fail;
38279 swig_obj[0] = args;
38280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38281 if (!SWIG_IsOK(res1)) {
38282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38283 }
38284 arg1 = reinterpret_cast< wxWindow * >(argp1);
38285 {
38286 PyThreadState* __tstate = wxPyBeginAllowThreads();
38287 result = (bool)(arg1)->CanSetTransparent();
38288 wxPyEndAllowThreads(__tstate);
38289 if (PyErr_Occurred()) SWIG_fail;
38290 }
38291 {
38292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38293 }
38294 return resultobj;
38295 fail:
38296 return NULL;
38297 }
38298
38299
38300 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38301 PyObject *resultobj = 0;
38302 wxWindow *arg1 = (wxWindow *) 0 ;
38303 byte arg2 ;
38304 bool result;
38305 void *argp1 = 0 ;
38306 int res1 = 0 ;
38307 unsigned char val2 ;
38308 int ecode2 = 0 ;
38309 PyObject * obj0 = 0 ;
38310 PyObject * obj1 = 0 ;
38311 char * kwnames[] = {
38312 (char *) "self",(char *) "alpha", NULL
38313 };
38314
38315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38317 if (!SWIG_IsOK(res1)) {
38318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38319 }
38320 arg1 = reinterpret_cast< wxWindow * >(argp1);
38321 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38322 if (!SWIG_IsOK(ecode2)) {
38323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38324 }
38325 arg2 = static_cast< byte >(val2);
38326 {
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 result = (bool)(arg1)->SetTransparent(arg2);
38329 wxPyEndAllowThreads(__tstate);
38330 if (PyErr_Occurred()) SWIG_fail;
38331 }
38332 {
38333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38334 }
38335 return resultobj;
38336 fail:
38337 return NULL;
38338 }
38339
38340
38341 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38342 PyObject *obj;
38343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38344 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38345 return SWIG_Py_Void();
38346 }
38347
38348 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38349 return SWIG_Python_InitShadowInstance(args);
38350 }
38351
38352 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38353 PyObject *resultobj = 0;
38354 long arg1 ;
38355 wxWindow *arg2 = (wxWindow *) NULL ;
38356 wxWindow *result = 0 ;
38357 long val1 ;
38358 int ecode1 = 0 ;
38359 void *argp2 = 0 ;
38360 int res2 = 0 ;
38361 PyObject * obj0 = 0 ;
38362 PyObject * obj1 = 0 ;
38363 char * kwnames[] = {
38364 (char *) "id",(char *) "parent", NULL
38365 };
38366
38367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38368 ecode1 = SWIG_AsVal_long(obj0, &val1);
38369 if (!SWIG_IsOK(ecode1)) {
38370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38371 }
38372 arg1 = static_cast< long >(val1);
38373 if (obj1) {
38374 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38375 if (!SWIG_IsOK(res2)) {
38376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38377 }
38378 arg2 = reinterpret_cast< wxWindow * >(argp2);
38379 }
38380 {
38381 if (!wxPyCheckForApp()) SWIG_fail;
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 {
38388 resultobj = wxPyMake_wxObject(result, 0);
38389 }
38390 return resultobj;
38391 fail:
38392 return NULL;
38393 }
38394
38395
38396 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38397 PyObject *resultobj = 0;
38398 wxString *arg1 = 0 ;
38399 wxWindow *arg2 = (wxWindow *) NULL ;
38400 wxWindow *result = 0 ;
38401 bool temp1 = false ;
38402 void *argp2 = 0 ;
38403 int res2 = 0 ;
38404 PyObject * obj0 = 0 ;
38405 PyObject * obj1 = 0 ;
38406 char * kwnames[] = {
38407 (char *) "name",(char *) "parent", NULL
38408 };
38409
38410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38411 {
38412 arg1 = wxString_in_helper(obj0);
38413 if (arg1 == NULL) SWIG_fail;
38414 temp1 = true;
38415 }
38416 if (obj1) {
38417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38418 if (!SWIG_IsOK(res2)) {
38419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38420 }
38421 arg2 = reinterpret_cast< wxWindow * >(argp2);
38422 }
38423 {
38424 if (!wxPyCheckForApp()) SWIG_fail;
38425 PyThreadState* __tstate = wxPyBeginAllowThreads();
38426 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38427 wxPyEndAllowThreads(__tstate);
38428 if (PyErr_Occurred()) SWIG_fail;
38429 }
38430 {
38431 resultobj = wxPyMake_wxObject(result, 0);
38432 }
38433 {
38434 if (temp1)
38435 delete arg1;
38436 }
38437 return resultobj;
38438 fail:
38439 {
38440 if (temp1)
38441 delete arg1;
38442 }
38443 return NULL;
38444 }
38445
38446
38447 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38448 PyObject *resultobj = 0;
38449 wxString *arg1 = 0 ;
38450 wxWindow *arg2 = (wxWindow *) NULL ;
38451 wxWindow *result = 0 ;
38452 bool temp1 = false ;
38453 void *argp2 = 0 ;
38454 int res2 = 0 ;
38455 PyObject * obj0 = 0 ;
38456 PyObject * obj1 = 0 ;
38457 char * kwnames[] = {
38458 (char *) "label",(char *) "parent", NULL
38459 };
38460
38461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38462 {
38463 arg1 = wxString_in_helper(obj0);
38464 if (arg1 == NULL) SWIG_fail;
38465 temp1 = true;
38466 }
38467 if (obj1) {
38468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38469 if (!SWIG_IsOK(res2)) {
38470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38471 }
38472 arg2 = reinterpret_cast< wxWindow * >(argp2);
38473 }
38474 {
38475 if (!wxPyCheckForApp()) SWIG_fail;
38476 PyThreadState* __tstate = wxPyBeginAllowThreads();
38477 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38478 wxPyEndAllowThreads(__tstate);
38479 if (PyErr_Occurred()) SWIG_fail;
38480 }
38481 {
38482 resultobj = wxPyMake_wxObject(result, 0);
38483 }
38484 {
38485 if (temp1)
38486 delete arg1;
38487 }
38488 return resultobj;
38489 fail:
38490 {
38491 if (temp1)
38492 delete arg1;
38493 }
38494 return NULL;
38495 }
38496
38497
38498 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38499 PyObject *resultobj = 0;
38500 wxWindow *arg1 = (wxWindow *) 0 ;
38501 unsigned long arg2 ;
38502 wxWindow *result = 0 ;
38503 void *argp1 = 0 ;
38504 int res1 = 0 ;
38505 unsigned long val2 ;
38506 int ecode2 = 0 ;
38507 PyObject * obj0 = 0 ;
38508 PyObject * obj1 = 0 ;
38509 char * kwnames[] = {
38510 (char *) "parent",(char *) "_hWnd", NULL
38511 };
38512
38513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38515 if (!SWIG_IsOK(res1)) {
38516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38517 }
38518 arg1 = reinterpret_cast< wxWindow * >(argp1);
38519 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38520 if (!SWIG_IsOK(ecode2)) {
38521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38522 }
38523 arg2 = static_cast< unsigned long >(val2);
38524 {
38525 PyThreadState* __tstate = wxPyBeginAllowThreads();
38526 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38527 wxPyEndAllowThreads(__tstate);
38528 if (PyErr_Occurred()) SWIG_fail;
38529 }
38530 {
38531 resultobj = wxPyMake_wxObject(result, 0);
38532 }
38533 return resultobj;
38534 fail:
38535 return NULL;
38536 }
38537
38538
38539 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38540 PyObject *resultobj = 0;
38541 PyObject *result = 0 ;
38542
38543 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38544 {
38545 PyThreadState* __tstate = wxPyBeginAllowThreads();
38546 result = (PyObject *)GetTopLevelWindows();
38547 wxPyEndAllowThreads(__tstate);
38548 if (PyErr_Occurred()) SWIG_fail;
38549 }
38550 resultobj = result;
38551 return resultobj;
38552 fail:
38553 return NULL;
38554 }
38555
38556
38557 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38558 PyObject *resultobj = 0;
38559 wxValidator *result = 0 ;
38560
38561 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38562 {
38563 PyThreadState* __tstate = wxPyBeginAllowThreads();
38564 result = (wxValidator *)new wxValidator();
38565 wxPyEndAllowThreads(__tstate);
38566 if (PyErr_Occurred()) SWIG_fail;
38567 }
38568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38569 return resultobj;
38570 fail:
38571 return NULL;
38572 }
38573
38574
38575 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38576 PyObject *resultobj = 0;
38577 wxValidator *arg1 = (wxValidator *) 0 ;
38578 wxValidator *result = 0 ;
38579 void *argp1 = 0 ;
38580 int res1 = 0 ;
38581 PyObject *swig_obj[1] ;
38582
38583 if (!args) SWIG_fail;
38584 swig_obj[0] = args;
38585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38586 if (!SWIG_IsOK(res1)) {
38587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38588 }
38589 arg1 = reinterpret_cast< wxValidator * >(argp1);
38590 {
38591 PyThreadState* __tstate = wxPyBeginAllowThreads();
38592 result = (wxValidator *)(arg1)->Clone();
38593 wxPyEndAllowThreads(__tstate);
38594 if (PyErr_Occurred()) SWIG_fail;
38595 }
38596 {
38597 resultobj = wxPyMake_wxObject(result, 0);
38598 }
38599 return resultobj;
38600 fail:
38601 return NULL;
38602 }
38603
38604
38605 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38606 PyObject *resultobj = 0;
38607 wxValidator *arg1 = (wxValidator *) 0 ;
38608 wxWindow *arg2 = (wxWindow *) 0 ;
38609 bool result;
38610 void *argp1 = 0 ;
38611 int res1 = 0 ;
38612 void *argp2 = 0 ;
38613 int res2 = 0 ;
38614 PyObject * obj0 = 0 ;
38615 PyObject * obj1 = 0 ;
38616 char * kwnames[] = {
38617 (char *) "self",(char *) "parent", NULL
38618 };
38619
38620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38622 if (!SWIG_IsOK(res1)) {
38623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38624 }
38625 arg1 = reinterpret_cast< wxValidator * >(argp1);
38626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38627 if (!SWIG_IsOK(res2)) {
38628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38629 }
38630 arg2 = reinterpret_cast< wxWindow * >(argp2);
38631 {
38632 PyThreadState* __tstate = wxPyBeginAllowThreads();
38633 result = (bool)(arg1)->Validate(arg2);
38634 wxPyEndAllowThreads(__tstate);
38635 if (PyErr_Occurred()) SWIG_fail;
38636 }
38637 {
38638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38639 }
38640 return resultobj;
38641 fail:
38642 return NULL;
38643 }
38644
38645
38646 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38647 PyObject *resultobj = 0;
38648 wxValidator *arg1 = (wxValidator *) 0 ;
38649 bool result;
38650 void *argp1 = 0 ;
38651 int res1 = 0 ;
38652 PyObject *swig_obj[1] ;
38653
38654 if (!args) SWIG_fail;
38655 swig_obj[0] = args;
38656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38659 }
38660 arg1 = reinterpret_cast< wxValidator * >(argp1);
38661 {
38662 PyThreadState* __tstate = wxPyBeginAllowThreads();
38663 result = (bool)(arg1)->TransferToWindow();
38664 wxPyEndAllowThreads(__tstate);
38665 if (PyErr_Occurred()) SWIG_fail;
38666 }
38667 {
38668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38669 }
38670 return resultobj;
38671 fail:
38672 return NULL;
38673 }
38674
38675
38676 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38677 PyObject *resultobj = 0;
38678 wxValidator *arg1 = (wxValidator *) 0 ;
38679 bool result;
38680 void *argp1 = 0 ;
38681 int res1 = 0 ;
38682 PyObject *swig_obj[1] ;
38683
38684 if (!args) SWIG_fail;
38685 swig_obj[0] = args;
38686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38687 if (!SWIG_IsOK(res1)) {
38688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38689 }
38690 arg1 = reinterpret_cast< wxValidator * >(argp1);
38691 {
38692 PyThreadState* __tstate = wxPyBeginAllowThreads();
38693 result = (bool)(arg1)->TransferFromWindow();
38694 wxPyEndAllowThreads(__tstate);
38695 if (PyErr_Occurred()) SWIG_fail;
38696 }
38697 {
38698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38699 }
38700 return resultobj;
38701 fail:
38702 return NULL;
38703 }
38704
38705
38706 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38707 PyObject *resultobj = 0;
38708 wxValidator *arg1 = (wxValidator *) 0 ;
38709 wxWindow *result = 0 ;
38710 void *argp1 = 0 ;
38711 int res1 = 0 ;
38712 PyObject *swig_obj[1] ;
38713
38714 if (!args) SWIG_fail;
38715 swig_obj[0] = args;
38716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38717 if (!SWIG_IsOK(res1)) {
38718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38719 }
38720 arg1 = reinterpret_cast< wxValidator * >(argp1);
38721 {
38722 PyThreadState* __tstate = wxPyBeginAllowThreads();
38723 result = (wxWindow *)(arg1)->GetWindow();
38724 wxPyEndAllowThreads(__tstate);
38725 if (PyErr_Occurred()) SWIG_fail;
38726 }
38727 {
38728 resultobj = wxPyMake_wxObject(result, 0);
38729 }
38730 return resultobj;
38731 fail:
38732 return NULL;
38733 }
38734
38735
38736 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38737 PyObject *resultobj = 0;
38738 wxValidator *arg1 = (wxValidator *) 0 ;
38739 wxWindow *arg2 = (wxWindow *) 0 ;
38740 void *argp1 = 0 ;
38741 int res1 = 0 ;
38742 void *argp2 = 0 ;
38743 int res2 = 0 ;
38744 PyObject * obj0 = 0 ;
38745 PyObject * obj1 = 0 ;
38746 char * kwnames[] = {
38747 (char *) "self",(char *) "window", NULL
38748 };
38749
38750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38752 if (!SWIG_IsOK(res1)) {
38753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38754 }
38755 arg1 = reinterpret_cast< wxValidator * >(argp1);
38756 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38757 if (!SWIG_IsOK(res2)) {
38758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38759 }
38760 arg2 = reinterpret_cast< wxWindow * >(argp2);
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 (arg1)->SetWindow(arg2);
38764 wxPyEndAllowThreads(__tstate);
38765 if (PyErr_Occurred()) SWIG_fail;
38766 }
38767 resultobj = SWIG_Py_Void();
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38775 PyObject *resultobj = 0;
38776 bool result;
38777
38778 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 result = (bool)wxValidator::IsSilent();
38782 wxPyEndAllowThreads(__tstate);
38783 if (PyErr_Occurred()) SWIG_fail;
38784 }
38785 {
38786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38787 }
38788 return resultobj;
38789 fail:
38790 return NULL;
38791 }
38792
38793
38794 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38795 PyObject *resultobj = 0;
38796 int arg1 = (int) true ;
38797 int val1 ;
38798 int ecode1 = 0 ;
38799 PyObject * obj0 = 0 ;
38800 char * kwnames[] = {
38801 (char *) "doIt", NULL
38802 };
38803
38804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38805 if (obj0) {
38806 ecode1 = SWIG_AsVal_int(obj0, &val1);
38807 if (!SWIG_IsOK(ecode1)) {
38808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38809 }
38810 arg1 = static_cast< int >(val1);
38811 }
38812 {
38813 PyThreadState* __tstate = wxPyBeginAllowThreads();
38814 wxValidator::SetBellOnError(arg1);
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 resultobj = SWIG_Py_Void();
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38826 PyObject *obj;
38827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38828 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38829 return SWIG_Py_Void();
38830 }
38831
38832 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38833 return SWIG_Python_InitShadowInstance(args);
38834 }
38835
38836 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38837 PyObject *resultobj = 0;
38838 wxPyValidator *result = 0 ;
38839
38840 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38841 {
38842 PyThreadState* __tstate = wxPyBeginAllowThreads();
38843 result = (wxPyValidator *)new wxPyValidator();
38844 wxPyEndAllowThreads(__tstate);
38845 if (PyErr_Occurred()) SWIG_fail;
38846 }
38847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38848 return resultobj;
38849 fail:
38850 return NULL;
38851 }
38852
38853
38854 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38855 PyObject *resultobj = 0;
38856 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38857 PyObject *arg2 = (PyObject *) 0 ;
38858 PyObject *arg3 = (PyObject *) 0 ;
38859 int arg4 = (int) true ;
38860 void *argp1 = 0 ;
38861 int res1 = 0 ;
38862 int val4 ;
38863 int ecode4 = 0 ;
38864 PyObject * obj0 = 0 ;
38865 PyObject * obj1 = 0 ;
38866 PyObject * obj2 = 0 ;
38867 PyObject * obj3 = 0 ;
38868 char * kwnames[] = {
38869 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38870 };
38871
38872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38874 if (!SWIG_IsOK(res1)) {
38875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38876 }
38877 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38878 arg2 = obj1;
38879 arg3 = obj2;
38880 if (obj3) {
38881 ecode4 = SWIG_AsVal_int(obj3, &val4);
38882 if (!SWIG_IsOK(ecode4)) {
38883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38884 }
38885 arg4 = static_cast< int >(val4);
38886 }
38887 {
38888 PyThreadState* __tstate = wxPyBeginAllowThreads();
38889 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38890 wxPyEndAllowThreads(__tstate);
38891 if (PyErr_Occurred()) SWIG_fail;
38892 }
38893 resultobj = SWIG_Py_Void();
38894 return resultobj;
38895 fail:
38896 return NULL;
38897 }
38898
38899
38900 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38901 PyObject *obj;
38902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38903 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38904 return SWIG_Py_Void();
38905 }
38906
38907 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38908 return SWIG_Python_InitShadowInstance(args);
38909 }
38910
38911 SWIGINTERN int DefaultValidator_set(PyObject *) {
38912 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38913 return 1;
38914 }
38915
38916
38917 SWIGINTERN PyObject *DefaultValidator_get(void) {
38918 PyObject *pyobj = 0;
38919
38920 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38921 return pyobj;
38922 }
38923
38924
38925 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38926 PyObject *resultobj = 0;
38927 wxString const &arg1_defvalue = wxPyEmptyString ;
38928 wxString *arg1 = (wxString *) &arg1_defvalue ;
38929 long arg2 = (long) 0 ;
38930 wxMenu *result = 0 ;
38931 bool temp1 = false ;
38932 long val2 ;
38933 int ecode2 = 0 ;
38934 PyObject * obj0 = 0 ;
38935 PyObject * obj1 = 0 ;
38936 char * kwnames[] = {
38937 (char *) "title",(char *) "style", NULL
38938 };
38939
38940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38941 if (obj0) {
38942 {
38943 arg1 = wxString_in_helper(obj0);
38944 if (arg1 == NULL) SWIG_fail;
38945 temp1 = true;
38946 }
38947 }
38948 if (obj1) {
38949 ecode2 = SWIG_AsVal_long(obj1, &val2);
38950 if (!SWIG_IsOK(ecode2)) {
38951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38952 }
38953 arg2 = static_cast< long >(val2);
38954 }
38955 {
38956 if (!wxPyCheckForApp()) SWIG_fail;
38957 PyThreadState* __tstate = wxPyBeginAllowThreads();
38958 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38959 wxPyEndAllowThreads(__tstate);
38960 if (PyErr_Occurred()) SWIG_fail;
38961 }
38962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38963 {
38964 if (temp1)
38965 delete arg1;
38966 }
38967 return resultobj;
38968 fail:
38969 {
38970 if (temp1)
38971 delete arg1;
38972 }
38973 return NULL;
38974 }
38975
38976
38977 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38978 PyObject *resultobj = 0;
38979 wxMenu *arg1 = (wxMenu *) 0 ;
38980 int arg2 ;
38981 wxString const &arg3_defvalue = wxPyEmptyString ;
38982 wxString *arg3 = (wxString *) &arg3_defvalue ;
38983 wxString const &arg4_defvalue = wxPyEmptyString ;
38984 wxString *arg4 = (wxString *) &arg4_defvalue ;
38985 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38986 wxMenuItem *result = 0 ;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 int val2 ;
38990 int ecode2 = 0 ;
38991 bool temp3 = false ;
38992 bool temp4 = false ;
38993 int val5 ;
38994 int ecode5 = 0 ;
38995 PyObject * obj0 = 0 ;
38996 PyObject * obj1 = 0 ;
38997 PyObject * obj2 = 0 ;
38998 PyObject * obj3 = 0 ;
38999 PyObject * obj4 = 0 ;
39000 char * kwnames[] = {
39001 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39002 };
39003
39004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39006 if (!SWIG_IsOK(res1)) {
39007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39008 }
39009 arg1 = reinterpret_cast< wxMenu * >(argp1);
39010 ecode2 = SWIG_AsVal_int(obj1, &val2);
39011 if (!SWIG_IsOK(ecode2)) {
39012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39013 }
39014 arg2 = static_cast< int >(val2);
39015 if (obj2) {
39016 {
39017 arg3 = wxString_in_helper(obj2);
39018 if (arg3 == NULL) SWIG_fail;
39019 temp3 = true;
39020 }
39021 }
39022 if (obj3) {
39023 {
39024 arg4 = wxString_in_helper(obj3);
39025 if (arg4 == NULL) SWIG_fail;
39026 temp4 = true;
39027 }
39028 }
39029 if (obj4) {
39030 ecode5 = SWIG_AsVal_int(obj4, &val5);
39031 if (!SWIG_IsOK(ecode5)) {
39032 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39033 }
39034 arg5 = static_cast< wxItemKind >(val5);
39035 }
39036 {
39037 PyThreadState* __tstate = wxPyBeginAllowThreads();
39038 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39039 wxPyEndAllowThreads(__tstate);
39040 if (PyErr_Occurred()) SWIG_fail;
39041 }
39042 {
39043 resultobj = wxPyMake_wxObject(result, (bool)0);
39044 }
39045 {
39046 if (temp3)
39047 delete arg3;
39048 }
39049 {
39050 if (temp4)
39051 delete arg4;
39052 }
39053 return resultobj;
39054 fail:
39055 {
39056 if (temp3)
39057 delete arg3;
39058 }
39059 {
39060 if (temp4)
39061 delete arg4;
39062 }
39063 return NULL;
39064 }
39065
39066
39067 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39068 PyObject *resultobj = 0;
39069 wxMenu *arg1 = (wxMenu *) 0 ;
39070 wxMenuItem *result = 0 ;
39071 void *argp1 = 0 ;
39072 int res1 = 0 ;
39073 PyObject *swig_obj[1] ;
39074
39075 if (!args) SWIG_fail;
39076 swig_obj[0] = args;
39077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39080 }
39081 arg1 = reinterpret_cast< wxMenu * >(argp1);
39082 {
39083 PyThreadState* __tstate = wxPyBeginAllowThreads();
39084 result = (wxMenuItem *)(arg1)->AppendSeparator();
39085 wxPyEndAllowThreads(__tstate);
39086 if (PyErr_Occurred()) SWIG_fail;
39087 }
39088 {
39089 resultobj = wxPyMake_wxObject(result, (bool)0);
39090 }
39091 return resultobj;
39092 fail:
39093 return NULL;
39094 }
39095
39096
39097 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39098 PyObject *resultobj = 0;
39099 wxMenu *arg1 = (wxMenu *) 0 ;
39100 int arg2 ;
39101 wxString *arg3 = 0 ;
39102 wxString const &arg4_defvalue = wxPyEmptyString ;
39103 wxString *arg4 = (wxString *) &arg4_defvalue ;
39104 wxMenuItem *result = 0 ;
39105 void *argp1 = 0 ;
39106 int res1 = 0 ;
39107 int val2 ;
39108 int ecode2 = 0 ;
39109 bool temp3 = false ;
39110 bool temp4 = false ;
39111 PyObject * obj0 = 0 ;
39112 PyObject * obj1 = 0 ;
39113 PyObject * obj2 = 0 ;
39114 PyObject * obj3 = 0 ;
39115 char * kwnames[] = {
39116 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39117 };
39118
39119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39121 if (!SWIG_IsOK(res1)) {
39122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39123 }
39124 arg1 = reinterpret_cast< wxMenu * >(argp1);
39125 ecode2 = SWIG_AsVal_int(obj1, &val2);
39126 if (!SWIG_IsOK(ecode2)) {
39127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39128 }
39129 arg2 = static_cast< int >(val2);
39130 {
39131 arg3 = wxString_in_helper(obj2);
39132 if (arg3 == NULL) SWIG_fail;
39133 temp3 = true;
39134 }
39135 if (obj3) {
39136 {
39137 arg4 = wxString_in_helper(obj3);
39138 if (arg4 == NULL) SWIG_fail;
39139 temp4 = true;
39140 }
39141 }
39142 {
39143 PyThreadState* __tstate = wxPyBeginAllowThreads();
39144 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39145 wxPyEndAllowThreads(__tstate);
39146 if (PyErr_Occurred()) SWIG_fail;
39147 }
39148 {
39149 resultobj = wxPyMake_wxObject(result, (bool)0);
39150 }
39151 {
39152 if (temp3)
39153 delete arg3;
39154 }
39155 {
39156 if (temp4)
39157 delete arg4;
39158 }
39159 return resultobj;
39160 fail:
39161 {
39162 if (temp3)
39163 delete arg3;
39164 }
39165 {
39166 if (temp4)
39167 delete arg4;
39168 }
39169 return NULL;
39170 }
39171
39172
39173 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj = 0;
39175 wxMenu *arg1 = (wxMenu *) 0 ;
39176 int arg2 ;
39177 wxString *arg3 = 0 ;
39178 wxString const &arg4_defvalue = wxPyEmptyString ;
39179 wxString *arg4 = (wxString *) &arg4_defvalue ;
39180 wxMenuItem *result = 0 ;
39181 void *argp1 = 0 ;
39182 int res1 = 0 ;
39183 int val2 ;
39184 int ecode2 = 0 ;
39185 bool temp3 = false ;
39186 bool temp4 = false ;
39187 PyObject * obj0 = 0 ;
39188 PyObject * obj1 = 0 ;
39189 PyObject * obj2 = 0 ;
39190 PyObject * obj3 = 0 ;
39191 char * kwnames[] = {
39192 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39193 };
39194
39195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39197 if (!SWIG_IsOK(res1)) {
39198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39199 }
39200 arg1 = reinterpret_cast< wxMenu * >(argp1);
39201 ecode2 = SWIG_AsVal_int(obj1, &val2);
39202 if (!SWIG_IsOK(ecode2)) {
39203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39204 }
39205 arg2 = static_cast< int >(val2);
39206 {
39207 arg3 = wxString_in_helper(obj2);
39208 if (arg3 == NULL) SWIG_fail;
39209 temp3 = true;
39210 }
39211 if (obj3) {
39212 {
39213 arg4 = wxString_in_helper(obj3);
39214 if (arg4 == NULL) SWIG_fail;
39215 temp4 = true;
39216 }
39217 }
39218 {
39219 PyThreadState* __tstate = wxPyBeginAllowThreads();
39220 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39221 wxPyEndAllowThreads(__tstate);
39222 if (PyErr_Occurred()) SWIG_fail;
39223 }
39224 {
39225 resultobj = wxPyMake_wxObject(result, (bool)0);
39226 }
39227 {
39228 if (temp3)
39229 delete arg3;
39230 }
39231 {
39232 if (temp4)
39233 delete arg4;
39234 }
39235 return resultobj;
39236 fail:
39237 {
39238 if (temp3)
39239 delete arg3;
39240 }
39241 {
39242 if (temp4)
39243 delete arg4;
39244 }
39245 return NULL;
39246 }
39247
39248
39249 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39250 PyObject *resultobj = 0;
39251 wxMenu *arg1 = (wxMenu *) 0 ;
39252 int arg2 ;
39253 wxString *arg3 = 0 ;
39254 wxMenu *arg4 = (wxMenu *) 0 ;
39255 wxString const &arg5_defvalue = wxPyEmptyString ;
39256 wxString *arg5 = (wxString *) &arg5_defvalue ;
39257 wxMenuItem *result = 0 ;
39258 void *argp1 = 0 ;
39259 int res1 = 0 ;
39260 int val2 ;
39261 int ecode2 = 0 ;
39262 bool temp3 = false ;
39263 void *argp4 = 0 ;
39264 int res4 = 0 ;
39265 bool temp5 = false ;
39266 PyObject * obj0 = 0 ;
39267 PyObject * obj1 = 0 ;
39268 PyObject * obj2 = 0 ;
39269 PyObject * obj3 = 0 ;
39270 PyObject * obj4 = 0 ;
39271 char * kwnames[] = {
39272 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39273 };
39274
39275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39277 if (!SWIG_IsOK(res1)) {
39278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39279 }
39280 arg1 = reinterpret_cast< wxMenu * >(argp1);
39281 ecode2 = SWIG_AsVal_int(obj1, &val2);
39282 if (!SWIG_IsOK(ecode2)) {
39283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39284 }
39285 arg2 = static_cast< int >(val2);
39286 {
39287 arg3 = wxString_in_helper(obj2);
39288 if (arg3 == NULL) SWIG_fail;
39289 temp3 = true;
39290 }
39291 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39292 if (!SWIG_IsOK(res4)) {
39293 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39294 }
39295 arg4 = reinterpret_cast< wxMenu * >(argp4);
39296 if (obj4) {
39297 {
39298 arg5 = wxString_in_helper(obj4);
39299 if (arg5 == NULL) SWIG_fail;
39300 temp5 = true;
39301 }
39302 }
39303 {
39304 PyThreadState* __tstate = wxPyBeginAllowThreads();
39305 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39306 wxPyEndAllowThreads(__tstate);
39307 if (PyErr_Occurred()) SWIG_fail;
39308 }
39309 {
39310 resultobj = wxPyMake_wxObject(result, (bool)0);
39311 }
39312 {
39313 if (temp3)
39314 delete arg3;
39315 }
39316 {
39317 if (temp5)
39318 delete arg5;
39319 }
39320 return resultobj;
39321 fail:
39322 {
39323 if (temp3)
39324 delete arg3;
39325 }
39326 {
39327 if (temp5)
39328 delete arg5;
39329 }
39330 return NULL;
39331 }
39332
39333
39334 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39335 PyObject *resultobj = 0;
39336 wxMenu *arg1 = (wxMenu *) 0 ;
39337 wxMenu *arg2 = (wxMenu *) 0 ;
39338 wxString *arg3 = 0 ;
39339 wxString const &arg4_defvalue = wxPyEmptyString ;
39340 wxString *arg4 = (wxString *) &arg4_defvalue ;
39341 wxMenuItem *result = 0 ;
39342 void *argp1 = 0 ;
39343 int res1 = 0 ;
39344 void *argp2 = 0 ;
39345 int res2 = 0 ;
39346 bool temp3 = false ;
39347 bool temp4 = false ;
39348 PyObject * obj0 = 0 ;
39349 PyObject * obj1 = 0 ;
39350 PyObject * obj2 = 0 ;
39351 PyObject * obj3 = 0 ;
39352 char * kwnames[] = {
39353 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39354 };
39355
39356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39358 if (!SWIG_IsOK(res1)) {
39359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39360 }
39361 arg1 = reinterpret_cast< wxMenu * >(argp1);
39362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39363 if (!SWIG_IsOK(res2)) {
39364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39365 }
39366 arg2 = reinterpret_cast< wxMenu * >(argp2);
39367 {
39368 arg3 = wxString_in_helper(obj2);
39369 if (arg3 == NULL) SWIG_fail;
39370 temp3 = true;
39371 }
39372 if (obj3) {
39373 {
39374 arg4 = wxString_in_helper(obj3);
39375 if (arg4 == NULL) SWIG_fail;
39376 temp4 = true;
39377 }
39378 }
39379 {
39380 PyThreadState* __tstate = wxPyBeginAllowThreads();
39381 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39382 wxPyEndAllowThreads(__tstate);
39383 if (PyErr_Occurred()) SWIG_fail;
39384 }
39385 {
39386 resultobj = wxPyMake_wxObject(result, (bool)0);
39387 }
39388 {
39389 if (temp3)
39390 delete arg3;
39391 }
39392 {
39393 if (temp4)
39394 delete arg4;
39395 }
39396 return resultobj;
39397 fail:
39398 {
39399 if (temp3)
39400 delete arg3;
39401 }
39402 {
39403 if (temp4)
39404 delete arg4;
39405 }
39406 return NULL;
39407 }
39408
39409
39410 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39411 PyObject *resultobj = 0;
39412 wxMenu *arg1 = (wxMenu *) 0 ;
39413 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39414 wxMenuItem *result = 0 ;
39415 void *argp1 = 0 ;
39416 int res1 = 0 ;
39417 int res2 = 0 ;
39418 PyObject * obj0 = 0 ;
39419 PyObject * obj1 = 0 ;
39420 char * kwnames[] = {
39421 (char *) "self",(char *) "item", NULL
39422 };
39423
39424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39426 if (!SWIG_IsOK(res1)) {
39427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39428 }
39429 arg1 = reinterpret_cast< wxMenu * >(argp1);
39430 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39431 if (!SWIG_IsOK(res2)) {
39432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39433 }
39434 {
39435 PyThreadState* __tstate = wxPyBeginAllowThreads();
39436 result = (wxMenuItem *)(arg1)->Append(arg2);
39437 wxPyEndAllowThreads(__tstate);
39438 if (PyErr_Occurred()) SWIG_fail;
39439 }
39440 {
39441 resultobj = wxPyMake_wxObject(result, (bool)0);
39442 }
39443 return resultobj;
39444 fail:
39445 return NULL;
39446 }
39447
39448
39449 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39450 PyObject *resultobj = 0;
39451 wxMenu *arg1 = (wxMenu *) 0 ;
39452 size_t arg2 ;
39453 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39454 wxMenuItem *result = 0 ;
39455 void *argp1 = 0 ;
39456 int res1 = 0 ;
39457 size_t val2 ;
39458 int ecode2 = 0 ;
39459 int res3 = 0 ;
39460 PyObject * obj0 = 0 ;
39461 PyObject * obj1 = 0 ;
39462 PyObject * obj2 = 0 ;
39463 char * kwnames[] = {
39464 (char *) "self",(char *) "pos",(char *) "item", NULL
39465 };
39466
39467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39469 if (!SWIG_IsOK(res1)) {
39470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39471 }
39472 arg1 = reinterpret_cast< wxMenu * >(argp1);
39473 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39474 if (!SWIG_IsOK(ecode2)) {
39475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39476 }
39477 arg2 = static_cast< size_t >(val2);
39478 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39479 if (!SWIG_IsOK(res3)) {
39480 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39481 }
39482 {
39483 PyThreadState* __tstate = wxPyBeginAllowThreads();
39484 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39485 wxPyEndAllowThreads(__tstate);
39486 if (PyErr_Occurred()) SWIG_fail;
39487 }
39488 {
39489 resultobj = wxPyMake_wxObject(result, (bool)0);
39490 }
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39498 PyObject *resultobj = 0;
39499 wxMenu *arg1 = (wxMenu *) 0 ;
39500 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39501 wxMenuItem *result = 0 ;
39502 void *argp1 = 0 ;
39503 int res1 = 0 ;
39504 int res2 = 0 ;
39505 PyObject * obj0 = 0 ;
39506 PyObject * obj1 = 0 ;
39507 char * kwnames[] = {
39508 (char *) "self",(char *) "item", NULL
39509 };
39510
39511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39513 if (!SWIG_IsOK(res1)) {
39514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39515 }
39516 arg1 = reinterpret_cast< wxMenu * >(argp1);
39517 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39518 if (!SWIG_IsOK(res2)) {
39519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39520 }
39521 {
39522 PyThreadState* __tstate = wxPyBeginAllowThreads();
39523 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 {
39528 resultobj = wxPyMake_wxObject(result, (bool)0);
39529 }
39530 return resultobj;
39531 fail:
39532 return NULL;
39533 }
39534
39535
39536 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39537 PyObject *resultobj = 0;
39538 wxMenu *arg1 = (wxMenu *) 0 ;
39539 void *argp1 = 0 ;
39540 int res1 = 0 ;
39541 PyObject *swig_obj[1] ;
39542
39543 if (!args) SWIG_fail;
39544 swig_obj[0] = args;
39545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39546 if (!SWIG_IsOK(res1)) {
39547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39548 }
39549 arg1 = reinterpret_cast< wxMenu * >(argp1);
39550 {
39551 PyThreadState* __tstate = wxPyBeginAllowThreads();
39552 (arg1)->Break();
39553 wxPyEndAllowThreads(__tstate);
39554 if (PyErr_Occurred()) SWIG_fail;
39555 }
39556 resultobj = SWIG_Py_Void();
39557 return resultobj;
39558 fail:
39559 return NULL;
39560 }
39561
39562
39563 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39564 PyObject *resultobj = 0;
39565 wxMenu *arg1 = (wxMenu *) 0 ;
39566 size_t arg2 ;
39567 int arg3 ;
39568 wxString const &arg4_defvalue = wxPyEmptyString ;
39569 wxString *arg4 = (wxString *) &arg4_defvalue ;
39570 wxString const &arg5_defvalue = wxPyEmptyString ;
39571 wxString *arg5 = (wxString *) &arg5_defvalue ;
39572 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39573 wxMenuItem *result = 0 ;
39574 void *argp1 = 0 ;
39575 int res1 = 0 ;
39576 size_t val2 ;
39577 int ecode2 = 0 ;
39578 int val3 ;
39579 int ecode3 = 0 ;
39580 bool temp4 = false ;
39581 bool temp5 = false ;
39582 int val6 ;
39583 int ecode6 = 0 ;
39584 PyObject * obj0 = 0 ;
39585 PyObject * obj1 = 0 ;
39586 PyObject * obj2 = 0 ;
39587 PyObject * obj3 = 0 ;
39588 PyObject * obj4 = 0 ;
39589 PyObject * obj5 = 0 ;
39590 char * kwnames[] = {
39591 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39592 };
39593
39594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39596 if (!SWIG_IsOK(res1)) {
39597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39598 }
39599 arg1 = reinterpret_cast< wxMenu * >(argp1);
39600 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39601 if (!SWIG_IsOK(ecode2)) {
39602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39603 }
39604 arg2 = static_cast< size_t >(val2);
39605 ecode3 = SWIG_AsVal_int(obj2, &val3);
39606 if (!SWIG_IsOK(ecode3)) {
39607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39608 }
39609 arg3 = static_cast< int >(val3);
39610 if (obj3) {
39611 {
39612 arg4 = wxString_in_helper(obj3);
39613 if (arg4 == NULL) SWIG_fail;
39614 temp4 = true;
39615 }
39616 }
39617 if (obj4) {
39618 {
39619 arg5 = wxString_in_helper(obj4);
39620 if (arg5 == NULL) SWIG_fail;
39621 temp5 = true;
39622 }
39623 }
39624 if (obj5) {
39625 ecode6 = SWIG_AsVal_int(obj5, &val6);
39626 if (!SWIG_IsOK(ecode6)) {
39627 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39628 }
39629 arg6 = static_cast< wxItemKind >(val6);
39630 }
39631 {
39632 PyThreadState* __tstate = wxPyBeginAllowThreads();
39633 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 {
39638 resultobj = wxPyMake_wxObject(result, (bool)0);
39639 }
39640 {
39641 if (temp4)
39642 delete arg4;
39643 }
39644 {
39645 if (temp5)
39646 delete arg5;
39647 }
39648 return resultobj;
39649 fail:
39650 {
39651 if (temp4)
39652 delete arg4;
39653 }
39654 {
39655 if (temp5)
39656 delete arg5;
39657 }
39658 return NULL;
39659 }
39660
39661
39662 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39663 PyObject *resultobj = 0;
39664 wxMenu *arg1 = (wxMenu *) 0 ;
39665 size_t arg2 ;
39666 wxMenuItem *result = 0 ;
39667 void *argp1 = 0 ;
39668 int res1 = 0 ;
39669 size_t val2 ;
39670 int ecode2 = 0 ;
39671 PyObject * obj0 = 0 ;
39672 PyObject * obj1 = 0 ;
39673 char * kwnames[] = {
39674 (char *) "self",(char *) "pos", NULL
39675 };
39676
39677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39679 if (!SWIG_IsOK(res1)) {
39680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39681 }
39682 arg1 = reinterpret_cast< wxMenu * >(argp1);
39683 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39684 if (!SWIG_IsOK(ecode2)) {
39685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39686 }
39687 arg2 = static_cast< size_t >(val2);
39688 {
39689 PyThreadState* __tstate = wxPyBeginAllowThreads();
39690 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39691 wxPyEndAllowThreads(__tstate);
39692 if (PyErr_Occurred()) SWIG_fail;
39693 }
39694 {
39695 resultobj = wxPyMake_wxObject(result, (bool)0);
39696 }
39697 return resultobj;
39698 fail:
39699 return NULL;
39700 }
39701
39702
39703 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39704 PyObject *resultobj = 0;
39705 wxMenu *arg1 = (wxMenu *) 0 ;
39706 size_t arg2 ;
39707 int arg3 ;
39708 wxString *arg4 = 0 ;
39709 wxString const &arg5_defvalue = wxPyEmptyString ;
39710 wxString *arg5 = (wxString *) &arg5_defvalue ;
39711 wxMenuItem *result = 0 ;
39712 void *argp1 = 0 ;
39713 int res1 = 0 ;
39714 size_t val2 ;
39715 int ecode2 = 0 ;
39716 int val3 ;
39717 int ecode3 = 0 ;
39718 bool temp4 = false ;
39719 bool temp5 = false ;
39720 PyObject * obj0 = 0 ;
39721 PyObject * obj1 = 0 ;
39722 PyObject * obj2 = 0 ;
39723 PyObject * obj3 = 0 ;
39724 PyObject * obj4 = 0 ;
39725 char * kwnames[] = {
39726 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39727 };
39728
39729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39731 if (!SWIG_IsOK(res1)) {
39732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39733 }
39734 arg1 = reinterpret_cast< wxMenu * >(argp1);
39735 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39736 if (!SWIG_IsOK(ecode2)) {
39737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39738 }
39739 arg2 = static_cast< size_t >(val2);
39740 ecode3 = SWIG_AsVal_int(obj2, &val3);
39741 if (!SWIG_IsOK(ecode3)) {
39742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39743 }
39744 arg3 = static_cast< int >(val3);
39745 {
39746 arg4 = wxString_in_helper(obj3);
39747 if (arg4 == NULL) SWIG_fail;
39748 temp4 = true;
39749 }
39750 if (obj4) {
39751 {
39752 arg5 = wxString_in_helper(obj4);
39753 if (arg5 == NULL) SWIG_fail;
39754 temp5 = true;
39755 }
39756 }
39757 {
39758 PyThreadState* __tstate = wxPyBeginAllowThreads();
39759 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39760 wxPyEndAllowThreads(__tstate);
39761 if (PyErr_Occurred()) SWIG_fail;
39762 }
39763 {
39764 resultobj = wxPyMake_wxObject(result, (bool)0);
39765 }
39766 {
39767 if (temp4)
39768 delete arg4;
39769 }
39770 {
39771 if (temp5)
39772 delete arg5;
39773 }
39774 return resultobj;
39775 fail:
39776 {
39777 if (temp4)
39778 delete arg4;
39779 }
39780 {
39781 if (temp5)
39782 delete arg5;
39783 }
39784 return NULL;
39785 }
39786
39787
39788 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39789 PyObject *resultobj = 0;
39790 wxMenu *arg1 = (wxMenu *) 0 ;
39791 size_t arg2 ;
39792 int arg3 ;
39793 wxString *arg4 = 0 ;
39794 wxString const &arg5_defvalue = wxPyEmptyString ;
39795 wxString *arg5 = (wxString *) &arg5_defvalue ;
39796 wxMenuItem *result = 0 ;
39797 void *argp1 = 0 ;
39798 int res1 = 0 ;
39799 size_t val2 ;
39800 int ecode2 = 0 ;
39801 int val3 ;
39802 int ecode3 = 0 ;
39803 bool temp4 = false ;
39804 bool temp5 = false ;
39805 PyObject * obj0 = 0 ;
39806 PyObject * obj1 = 0 ;
39807 PyObject * obj2 = 0 ;
39808 PyObject * obj3 = 0 ;
39809 PyObject * obj4 = 0 ;
39810 char * kwnames[] = {
39811 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39812 };
39813
39814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39816 if (!SWIG_IsOK(res1)) {
39817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39818 }
39819 arg1 = reinterpret_cast< wxMenu * >(argp1);
39820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39821 if (!SWIG_IsOK(ecode2)) {
39822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39823 }
39824 arg2 = static_cast< size_t >(val2);
39825 ecode3 = SWIG_AsVal_int(obj2, &val3);
39826 if (!SWIG_IsOK(ecode3)) {
39827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39828 }
39829 arg3 = static_cast< int >(val3);
39830 {
39831 arg4 = wxString_in_helper(obj3);
39832 if (arg4 == NULL) SWIG_fail;
39833 temp4 = true;
39834 }
39835 if (obj4) {
39836 {
39837 arg5 = wxString_in_helper(obj4);
39838 if (arg5 == NULL) SWIG_fail;
39839 temp5 = true;
39840 }
39841 }
39842 {
39843 PyThreadState* __tstate = wxPyBeginAllowThreads();
39844 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39845 wxPyEndAllowThreads(__tstate);
39846 if (PyErr_Occurred()) SWIG_fail;
39847 }
39848 {
39849 resultobj = wxPyMake_wxObject(result, (bool)0);
39850 }
39851 {
39852 if (temp4)
39853 delete arg4;
39854 }
39855 {
39856 if (temp5)
39857 delete arg5;
39858 }
39859 return resultobj;
39860 fail:
39861 {
39862 if (temp4)
39863 delete arg4;
39864 }
39865 {
39866 if (temp5)
39867 delete arg5;
39868 }
39869 return NULL;
39870 }
39871
39872
39873 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39874 PyObject *resultobj = 0;
39875 wxMenu *arg1 = (wxMenu *) 0 ;
39876 size_t arg2 ;
39877 int arg3 ;
39878 wxString *arg4 = 0 ;
39879 wxMenu *arg5 = (wxMenu *) 0 ;
39880 wxString const &arg6_defvalue = wxPyEmptyString ;
39881 wxString *arg6 = (wxString *) &arg6_defvalue ;
39882 wxMenuItem *result = 0 ;
39883 void *argp1 = 0 ;
39884 int res1 = 0 ;
39885 size_t val2 ;
39886 int ecode2 = 0 ;
39887 int val3 ;
39888 int ecode3 = 0 ;
39889 bool temp4 = false ;
39890 void *argp5 = 0 ;
39891 int res5 = 0 ;
39892 bool temp6 = false ;
39893 PyObject * obj0 = 0 ;
39894 PyObject * obj1 = 0 ;
39895 PyObject * obj2 = 0 ;
39896 PyObject * obj3 = 0 ;
39897 PyObject * obj4 = 0 ;
39898 PyObject * obj5 = 0 ;
39899 char * kwnames[] = {
39900 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39901 };
39902
39903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39905 if (!SWIG_IsOK(res1)) {
39906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39907 }
39908 arg1 = reinterpret_cast< wxMenu * >(argp1);
39909 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39910 if (!SWIG_IsOK(ecode2)) {
39911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39912 }
39913 arg2 = static_cast< size_t >(val2);
39914 ecode3 = SWIG_AsVal_int(obj2, &val3);
39915 if (!SWIG_IsOK(ecode3)) {
39916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39917 }
39918 arg3 = static_cast< int >(val3);
39919 {
39920 arg4 = wxString_in_helper(obj3);
39921 if (arg4 == NULL) SWIG_fail;
39922 temp4 = true;
39923 }
39924 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39925 if (!SWIG_IsOK(res5)) {
39926 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39927 }
39928 arg5 = reinterpret_cast< wxMenu * >(argp5);
39929 if (obj5) {
39930 {
39931 arg6 = wxString_in_helper(obj5);
39932 if (arg6 == NULL) SWIG_fail;
39933 temp6 = true;
39934 }
39935 }
39936 {
39937 PyThreadState* __tstate = wxPyBeginAllowThreads();
39938 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39939 wxPyEndAllowThreads(__tstate);
39940 if (PyErr_Occurred()) SWIG_fail;
39941 }
39942 {
39943 resultobj = wxPyMake_wxObject(result, (bool)0);
39944 }
39945 {
39946 if (temp4)
39947 delete arg4;
39948 }
39949 {
39950 if (temp6)
39951 delete arg6;
39952 }
39953 return resultobj;
39954 fail:
39955 {
39956 if (temp4)
39957 delete arg4;
39958 }
39959 {
39960 if (temp6)
39961 delete arg6;
39962 }
39963 return NULL;
39964 }
39965
39966
39967 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39968 PyObject *resultobj = 0;
39969 wxMenu *arg1 = (wxMenu *) 0 ;
39970 int arg2 ;
39971 wxString const &arg3_defvalue = wxPyEmptyString ;
39972 wxString *arg3 = (wxString *) &arg3_defvalue ;
39973 wxString const &arg4_defvalue = wxPyEmptyString ;
39974 wxString *arg4 = (wxString *) &arg4_defvalue ;
39975 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39976 wxMenuItem *result = 0 ;
39977 void *argp1 = 0 ;
39978 int res1 = 0 ;
39979 int val2 ;
39980 int ecode2 = 0 ;
39981 bool temp3 = false ;
39982 bool temp4 = false ;
39983 int val5 ;
39984 int ecode5 = 0 ;
39985 PyObject * obj0 = 0 ;
39986 PyObject * obj1 = 0 ;
39987 PyObject * obj2 = 0 ;
39988 PyObject * obj3 = 0 ;
39989 PyObject * obj4 = 0 ;
39990 char * kwnames[] = {
39991 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39992 };
39993
39994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39996 if (!SWIG_IsOK(res1)) {
39997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39998 }
39999 arg1 = reinterpret_cast< wxMenu * >(argp1);
40000 ecode2 = SWIG_AsVal_int(obj1, &val2);
40001 if (!SWIG_IsOK(ecode2)) {
40002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40003 }
40004 arg2 = static_cast< int >(val2);
40005 if (obj2) {
40006 {
40007 arg3 = wxString_in_helper(obj2);
40008 if (arg3 == NULL) SWIG_fail;
40009 temp3 = true;
40010 }
40011 }
40012 if (obj3) {
40013 {
40014 arg4 = wxString_in_helper(obj3);
40015 if (arg4 == NULL) SWIG_fail;
40016 temp4 = true;
40017 }
40018 }
40019 if (obj4) {
40020 ecode5 = SWIG_AsVal_int(obj4, &val5);
40021 if (!SWIG_IsOK(ecode5)) {
40022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40023 }
40024 arg5 = static_cast< wxItemKind >(val5);
40025 }
40026 {
40027 PyThreadState* __tstate = wxPyBeginAllowThreads();
40028 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40029 wxPyEndAllowThreads(__tstate);
40030 if (PyErr_Occurred()) SWIG_fail;
40031 }
40032 {
40033 resultobj = wxPyMake_wxObject(result, (bool)0);
40034 }
40035 {
40036 if (temp3)
40037 delete arg3;
40038 }
40039 {
40040 if (temp4)
40041 delete arg4;
40042 }
40043 return resultobj;
40044 fail:
40045 {
40046 if (temp3)
40047 delete arg3;
40048 }
40049 {
40050 if (temp4)
40051 delete arg4;
40052 }
40053 return NULL;
40054 }
40055
40056
40057 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40058 PyObject *resultobj = 0;
40059 wxMenu *arg1 = (wxMenu *) 0 ;
40060 wxMenuItem *result = 0 ;
40061 void *argp1 = 0 ;
40062 int res1 = 0 ;
40063 PyObject *swig_obj[1] ;
40064
40065 if (!args) SWIG_fail;
40066 swig_obj[0] = args;
40067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40068 if (!SWIG_IsOK(res1)) {
40069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40070 }
40071 arg1 = reinterpret_cast< wxMenu * >(argp1);
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 result = (wxMenuItem *)(arg1)->PrependSeparator();
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 {
40079 resultobj = wxPyMake_wxObject(result, (bool)0);
40080 }
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = 0;
40089 wxMenu *arg1 = (wxMenu *) 0 ;
40090 int arg2 ;
40091 wxString *arg3 = 0 ;
40092 wxString const &arg4_defvalue = wxPyEmptyString ;
40093 wxString *arg4 = (wxString *) &arg4_defvalue ;
40094 wxMenuItem *result = 0 ;
40095 void *argp1 = 0 ;
40096 int res1 = 0 ;
40097 int val2 ;
40098 int ecode2 = 0 ;
40099 bool temp3 = false ;
40100 bool temp4 = false ;
40101 PyObject * obj0 = 0 ;
40102 PyObject * obj1 = 0 ;
40103 PyObject * obj2 = 0 ;
40104 PyObject * obj3 = 0 ;
40105 char * kwnames[] = {
40106 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40107 };
40108
40109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40111 if (!SWIG_IsOK(res1)) {
40112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40113 }
40114 arg1 = reinterpret_cast< wxMenu * >(argp1);
40115 ecode2 = SWIG_AsVal_int(obj1, &val2);
40116 if (!SWIG_IsOK(ecode2)) {
40117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40118 }
40119 arg2 = static_cast< int >(val2);
40120 {
40121 arg3 = wxString_in_helper(obj2);
40122 if (arg3 == NULL) SWIG_fail;
40123 temp3 = true;
40124 }
40125 if (obj3) {
40126 {
40127 arg4 = wxString_in_helper(obj3);
40128 if (arg4 == NULL) SWIG_fail;
40129 temp4 = true;
40130 }
40131 }
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40135 wxPyEndAllowThreads(__tstate);
40136 if (PyErr_Occurred()) SWIG_fail;
40137 }
40138 {
40139 resultobj = wxPyMake_wxObject(result, (bool)0);
40140 }
40141 {
40142 if (temp3)
40143 delete arg3;
40144 }
40145 {
40146 if (temp4)
40147 delete arg4;
40148 }
40149 return resultobj;
40150 fail:
40151 {
40152 if (temp3)
40153 delete arg3;
40154 }
40155 {
40156 if (temp4)
40157 delete arg4;
40158 }
40159 return NULL;
40160 }
40161
40162
40163 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40164 PyObject *resultobj = 0;
40165 wxMenu *arg1 = (wxMenu *) 0 ;
40166 int arg2 ;
40167 wxString *arg3 = 0 ;
40168 wxString const &arg4_defvalue = wxPyEmptyString ;
40169 wxString *arg4 = (wxString *) &arg4_defvalue ;
40170 wxMenuItem *result = 0 ;
40171 void *argp1 = 0 ;
40172 int res1 = 0 ;
40173 int val2 ;
40174 int ecode2 = 0 ;
40175 bool temp3 = false ;
40176 bool temp4 = false ;
40177 PyObject * obj0 = 0 ;
40178 PyObject * obj1 = 0 ;
40179 PyObject * obj2 = 0 ;
40180 PyObject * obj3 = 0 ;
40181 char * kwnames[] = {
40182 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40183 };
40184
40185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40187 if (!SWIG_IsOK(res1)) {
40188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40189 }
40190 arg1 = reinterpret_cast< wxMenu * >(argp1);
40191 ecode2 = SWIG_AsVal_int(obj1, &val2);
40192 if (!SWIG_IsOK(ecode2)) {
40193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40194 }
40195 arg2 = static_cast< int >(val2);
40196 {
40197 arg3 = wxString_in_helper(obj2);
40198 if (arg3 == NULL) SWIG_fail;
40199 temp3 = true;
40200 }
40201 if (obj3) {
40202 {
40203 arg4 = wxString_in_helper(obj3);
40204 if (arg4 == NULL) SWIG_fail;
40205 temp4 = true;
40206 }
40207 }
40208 {
40209 PyThreadState* __tstate = wxPyBeginAllowThreads();
40210 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40211 wxPyEndAllowThreads(__tstate);
40212 if (PyErr_Occurred()) SWIG_fail;
40213 }
40214 {
40215 resultobj = wxPyMake_wxObject(result, (bool)0);
40216 }
40217 {
40218 if (temp3)
40219 delete arg3;
40220 }
40221 {
40222 if (temp4)
40223 delete arg4;
40224 }
40225 return resultobj;
40226 fail:
40227 {
40228 if (temp3)
40229 delete arg3;
40230 }
40231 {
40232 if (temp4)
40233 delete arg4;
40234 }
40235 return NULL;
40236 }
40237
40238
40239 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40240 PyObject *resultobj = 0;
40241 wxMenu *arg1 = (wxMenu *) 0 ;
40242 int arg2 ;
40243 wxString *arg3 = 0 ;
40244 wxMenu *arg4 = (wxMenu *) 0 ;
40245 wxString const &arg5_defvalue = wxPyEmptyString ;
40246 wxString *arg5 = (wxString *) &arg5_defvalue ;
40247 wxMenuItem *result = 0 ;
40248 void *argp1 = 0 ;
40249 int res1 = 0 ;
40250 int val2 ;
40251 int ecode2 = 0 ;
40252 bool temp3 = false ;
40253 void *argp4 = 0 ;
40254 int res4 = 0 ;
40255 bool temp5 = false ;
40256 PyObject * obj0 = 0 ;
40257 PyObject * obj1 = 0 ;
40258 PyObject * obj2 = 0 ;
40259 PyObject * obj3 = 0 ;
40260 PyObject * obj4 = 0 ;
40261 char * kwnames[] = {
40262 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40263 };
40264
40265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40267 if (!SWIG_IsOK(res1)) {
40268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40269 }
40270 arg1 = reinterpret_cast< wxMenu * >(argp1);
40271 ecode2 = SWIG_AsVal_int(obj1, &val2);
40272 if (!SWIG_IsOK(ecode2)) {
40273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40274 }
40275 arg2 = static_cast< int >(val2);
40276 {
40277 arg3 = wxString_in_helper(obj2);
40278 if (arg3 == NULL) SWIG_fail;
40279 temp3 = true;
40280 }
40281 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40282 if (!SWIG_IsOK(res4)) {
40283 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40284 }
40285 arg4 = reinterpret_cast< wxMenu * >(argp4);
40286 if (obj4) {
40287 {
40288 arg5 = wxString_in_helper(obj4);
40289 if (arg5 == NULL) SWIG_fail;
40290 temp5 = true;
40291 }
40292 }
40293 {
40294 PyThreadState* __tstate = wxPyBeginAllowThreads();
40295 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40296 wxPyEndAllowThreads(__tstate);
40297 if (PyErr_Occurred()) SWIG_fail;
40298 }
40299 {
40300 resultobj = wxPyMake_wxObject(result, (bool)0);
40301 }
40302 {
40303 if (temp3)
40304 delete arg3;
40305 }
40306 {
40307 if (temp5)
40308 delete arg5;
40309 }
40310 return resultobj;
40311 fail:
40312 {
40313 if (temp3)
40314 delete arg3;
40315 }
40316 {
40317 if (temp5)
40318 delete arg5;
40319 }
40320 return NULL;
40321 }
40322
40323
40324 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40325 PyObject *resultobj = 0;
40326 wxMenu *arg1 = (wxMenu *) 0 ;
40327 int arg2 ;
40328 wxMenuItem *result = 0 ;
40329 void *argp1 = 0 ;
40330 int res1 = 0 ;
40331 int val2 ;
40332 int ecode2 = 0 ;
40333 PyObject * obj0 = 0 ;
40334 PyObject * obj1 = 0 ;
40335 char * kwnames[] = {
40336 (char *) "self",(char *) "id", NULL
40337 };
40338
40339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40341 if (!SWIG_IsOK(res1)) {
40342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40343 }
40344 arg1 = reinterpret_cast< wxMenu * >(argp1);
40345 ecode2 = SWIG_AsVal_int(obj1, &val2);
40346 if (!SWIG_IsOK(ecode2)) {
40347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40348 }
40349 arg2 = static_cast< int >(val2);
40350 {
40351 PyThreadState* __tstate = wxPyBeginAllowThreads();
40352 result = (wxMenuItem *)(arg1)->Remove(arg2);
40353 wxPyEndAllowThreads(__tstate);
40354 if (PyErr_Occurred()) SWIG_fail;
40355 }
40356 {
40357 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40358 }
40359 return resultobj;
40360 fail:
40361 return NULL;
40362 }
40363
40364
40365 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40366 PyObject *resultobj = 0;
40367 wxMenu *arg1 = (wxMenu *) 0 ;
40368 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40369 wxMenuItem *result = 0 ;
40370 void *argp1 = 0 ;
40371 int res1 = 0 ;
40372 void *argp2 = 0 ;
40373 int res2 = 0 ;
40374 PyObject * obj0 = 0 ;
40375 PyObject * obj1 = 0 ;
40376 char * kwnames[] = {
40377 (char *) "self",(char *) "item", NULL
40378 };
40379
40380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40382 if (!SWIG_IsOK(res1)) {
40383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40384 }
40385 arg1 = reinterpret_cast< wxMenu * >(argp1);
40386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40387 if (!SWIG_IsOK(res2)) {
40388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40389 }
40390 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40391 {
40392 PyThreadState* __tstate = wxPyBeginAllowThreads();
40393 result = (wxMenuItem *)(arg1)->Remove(arg2);
40394 wxPyEndAllowThreads(__tstate);
40395 if (PyErr_Occurred()) SWIG_fail;
40396 }
40397 {
40398 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40399 }
40400 return resultobj;
40401 fail:
40402 return NULL;
40403 }
40404
40405
40406 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40407 PyObject *resultobj = 0;
40408 wxMenu *arg1 = (wxMenu *) 0 ;
40409 int arg2 ;
40410 bool result;
40411 void *argp1 = 0 ;
40412 int res1 = 0 ;
40413 int val2 ;
40414 int ecode2 = 0 ;
40415 PyObject * obj0 = 0 ;
40416 PyObject * obj1 = 0 ;
40417 char * kwnames[] = {
40418 (char *) "self",(char *) "id", NULL
40419 };
40420
40421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40423 if (!SWIG_IsOK(res1)) {
40424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40425 }
40426 arg1 = reinterpret_cast< wxMenu * >(argp1);
40427 ecode2 = SWIG_AsVal_int(obj1, &val2);
40428 if (!SWIG_IsOK(ecode2)) {
40429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40430 }
40431 arg2 = static_cast< int >(val2);
40432 {
40433 PyThreadState* __tstate = wxPyBeginAllowThreads();
40434 result = (bool)(arg1)->Delete(arg2);
40435 wxPyEndAllowThreads(__tstate);
40436 if (PyErr_Occurred()) SWIG_fail;
40437 }
40438 {
40439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40440 }
40441 return resultobj;
40442 fail:
40443 return NULL;
40444 }
40445
40446
40447 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40448 PyObject *resultobj = 0;
40449 wxMenu *arg1 = (wxMenu *) 0 ;
40450 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40451 bool result;
40452 void *argp1 = 0 ;
40453 int res1 = 0 ;
40454 void *argp2 = 0 ;
40455 int res2 = 0 ;
40456 PyObject * obj0 = 0 ;
40457 PyObject * obj1 = 0 ;
40458 char * kwnames[] = {
40459 (char *) "self",(char *) "item", NULL
40460 };
40461
40462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40464 if (!SWIG_IsOK(res1)) {
40465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40466 }
40467 arg1 = reinterpret_cast< wxMenu * >(argp1);
40468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40469 if (!SWIG_IsOK(res2)) {
40470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40471 }
40472 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40473 {
40474 PyThreadState* __tstate = wxPyBeginAllowThreads();
40475 result = (bool)(arg1)->Delete(arg2);
40476 wxPyEndAllowThreads(__tstate);
40477 if (PyErr_Occurred()) SWIG_fail;
40478 }
40479 {
40480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40481 }
40482 return resultobj;
40483 fail:
40484 return NULL;
40485 }
40486
40487
40488 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40489 PyObject *resultobj = 0;
40490 wxMenu *arg1 = (wxMenu *) 0 ;
40491 void *argp1 = 0 ;
40492 int res1 = 0 ;
40493 PyObject *swig_obj[1] ;
40494
40495 if (!args) SWIG_fail;
40496 swig_obj[0] = args;
40497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40498 if (!SWIG_IsOK(res1)) {
40499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40500 }
40501 arg1 = reinterpret_cast< wxMenu * >(argp1);
40502 {
40503 PyThreadState* __tstate = wxPyBeginAllowThreads();
40504 wxMenu_Destroy(arg1);
40505 wxPyEndAllowThreads(__tstate);
40506 if (PyErr_Occurred()) SWIG_fail;
40507 }
40508 resultobj = SWIG_Py_Void();
40509 return resultobj;
40510 fail:
40511 return NULL;
40512 }
40513
40514
40515 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40516 PyObject *resultobj = 0;
40517 wxMenu *arg1 = (wxMenu *) 0 ;
40518 int arg2 ;
40519 bool result;
40520 void *argp1 = 0 ;
40521 int res1 = 0 ;
40522 int val2 ;
40523 int ecode2 = 0 ;
40524 PyObject * obj0 = 0 ;
40525 PyObject * obj1 = 0 ;
40526 char * kwnames[] = {
40527 (char *) "self",(char *) "id", NULL
40528 };
40529
40530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40532 if (!SWIG_IsOK(res1)) {
40533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40534 }
40535 arg1 = reinterpret_cast< wxMenu * >(argp1);
40536 ecode2 = SWIG_AsVal_int(obj1, &val2);
40537 if (!SWIG_IsOK(ecode2)) {
40538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40539 }
40540 arg2 = static_cast< int >(val2);
40541 {
40542 PyThreadState* __tstate = wxPyBeginAllowThreads();
40543 result = (bool)(arg1)->Destroy(arg2);
40544 wxPyEndAllowThreads(__tstate);
40545 if (PyErr_Occurred()) SWIG_fail;
40546 }
40547 {
40548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40549 }
40550 return resultobj;
40551 fail:
40552 return NULL;
40553 }
40554
40555
40556 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40557 PyObject *resultobj = 0;
40558 wxMenu *arg1 = (wxMenu *) 0 ;
40559 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40560 bool result;
40561 void *argp1 = 0 ;
40562 int res1 = 0 ;
40563 void *argp2 = 0 ;
40564 int res2 = 0 ;
40565 PyObject * obj0 = 0 ;
40566 PyObject * obj1 = 0 ;
40567 char * kwnames[] = {
40568 (char *) "self",(char *) "item", NULL
40569 };
40570
40571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40573 if (!SWIG_IsOK(res1)) {
40574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40575 }
40576 arg1 = reinterpret_cast< wxMenu * >(argp1);
40577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40578 if (!SWIG_IsOK(res2)) {
40579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40580 }
40581 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40582 {
40583 PyThreadState* __tstate = wxPyBeginAllowThreads();
40584 result = (bool)(arg1)->Destroy(arg2);
40585 wxPyEndAllowThreads(__tstate);
40586 if (PyErr_Occurred()) SWIG_fail;
40587 }
40588 {
40589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40590 }
40591 return resultobj;
40592 fail:
40593 return NULL;
40594 }
40595
40596
40597 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40598 PyObject *resultobj = 0;
40599 wxMenu *arg1 = (wxMenu *) 0 ;
40600 size_t result;
40601 void *argp1 = 0 ;
40602 int res1 = 0 ;
40603 PyObject *swig_obj[1] ;
40604
40605 if (!args) SWIG_fail;
40606 swig_obj[0] = args;
40607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40608 if (!SWIG_IsOK(res1)) {
40609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40610 }
40611 arg1 = reinterpret_cast< wxMenu * >(argp1);
40612 {
40613 PyThreadState* __tstate = wxPyBeginAllowThreads();
40614 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40615 wxPyEndAllowThreads(__tstate);
40616 if (PyErr_Occurred()) SWIG_fail;
40617 }
40618 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40619 return resultobj;
40620 fail:
40621 return NULL;
40622 }
40623
40624
40625 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40626 PyObject *resultobj = 0;
40627 wxMenu *arg1 = (wxMenu *) 0 ;
40628 PyObject *result = 0 ;
40629 void *argp1 = 0 ;
40630 int res1 = 0 ;
40631 PyObject *swig_obj[1] ;
40632
40633 if (!args) SWIG_fail;
40634 swig_obj[0] = args;
40635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40636 if (!SWIG_IsOK(res1)) {
40637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40638 }
40639 arg1 = reinterpret_cast< wxMenu * >(argp1);
40640 {
40641 PyThreadState* __tstate = wxPyBeginAllowThreads();
40642 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40643 wxPyEndAllowThreads(__tstate);
40644 if (PyErr_Occurred()) SWIG_fail;
40645 }
40646 resultobj = result;
40647 return resultobj;
40648 fail:
40649 return NULL;
40650 }
40651
40652
40653 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40654 PyObject *resultobj = 0;
40655 wxMenu *arg1 = (wxMenu *) 0 ;
40656 wxString *arg2 = 0 ;
40657 int result;
40658 void *argp1 = 0 ;
40659 int res1 = 0 ;
40660 bool temp2 = false ;
40661 PyObject * obj0 = 0 ;
40662 PyObject * obj1 = 0 ;
40663 char * kwnames[] = {
40664 (char *) "self",(char *) "item", NULL
40665 };
40666
40667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40669 if (!SWIG_IsOK(res1)) {
40670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40671 }
40672 arg1 = reinterpret_cast< wxMenu * >(argp1);
40673 {
40674 arg2 = wxString_in_helper(obj1);
40675 if (arg2 == NULL) SWIG_fail;
40676 temp2 = true;
40677 }
40678 {
40679 PyThreadState* __tstate = wxPyBeginAllowThreads();
40680 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40681 wxPyEndAllowThreads(__tstate);
40682 if (PyErr_Occurred()) SWIG_fail;
40683 }
40684 resultobj = SWIG_From_int(static_cast< int >(result));
40685 {
40686 if (temp2)
40687 delete arg2;
40688 }
40689 return resultobj;
40690 fail:
40691 {
40692 if (temp2)
40693 delete arg2;
40694 }
40695 return NULL;
40696 }
40697
40698
40699 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40700 PyObject *resultobj = 0;
40701 wxMenu *arg1 = (wxMenu *) 0 ;
40702 int arg2 ;
40703 wxMenuItem *result = 0 ;
40704 void *argp1 = 0 ;
40705 int res1 = 0 ;
40706 int val2 ;
40707 int ecode2 = 0 ;
40708 PyObject * obj0 = 0 ;
40709 PyObject * obj1 = 0 ;
40710 char * kwnames[] = {
40711 (char *) "self",(char *) "id", NULL
40712 };
40713
40714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40716 if (!SWIG_IsOK(res1)) {
40717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40718 }
40719 arg1 = reinterpret_cast< wxMenu * >(argp1);
40720 ecode2 = SWIG_AsVal_int(obj1, &val2);
40721 if (!SWIG_IsOK(ecode2)) {
40722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40723 }
40724 arg2 = static_cast< int >(val2);
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 {
40732 resultobj = wxPyMake_wxObject(result, (bool)0);
40733 }
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj = 0;
40742 wxMenu *arg1 = (wxMenu *) 0 ;
40743 size_t arg2 ;
40744 wxMenuItem *result = 0 ;
40745 void *argp1 = 0 ;
40746 int res1 = 0 ;
40747 size_t val2 ;
40748 int ecode2 = 0 ;
40749 PyObject * obj0 = 0 ;
40750 PyObject * obj1 = 0 ;
40751 char * kwnames[] = {
40752 (char *) "self",(char *) "position", NULL
40753 };
40754
40755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40757 if (!SWIG_IsOK(res1)) {
40758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40759 }
40760 arg1 = reinterpret_cast< wxMenu * >(argp1);
40761 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40762 if (!SWIG_IsOK(ecode2)) {
40763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40764 }
40765 arg2 = static_cast< size_t >(val2);
40766 {
40767 PyThreadState* __tstate = wxPyBeginAllowThreads();
40768 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40769 wxPyEndAllowThreads(__tstate);
40770 if (PyErr_Occurred()) SWIG_fail;
40771 }
40772 {
40773 resultobj = wxPyMake_wxObject(result, (bool)0);
40774 }
40775 return resultobj;
40776 fail:
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40782 PyObject *resultobj = 0;
40783 wxMenu *arg1 = (wxMenu *) 0 ;
40784 int arg2 ;
40785 bool arg3 ;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 int val2 ;
40789 int ecode2 = 0 ;
40790 bool val3 ;
40791 int ecode3 = 0 ;
40792 PyObject * obj0 = 0 ;
40793 PyObject * obj1 = 0 ;
40794 PyObject * obj2 = 0 ;
40795 char * kwnames[] = {
40796 (char *) "self",(char *) "id",(char *) "enable", NULL
40797 };
40798
40799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40801 if (!SWIG_IsOK(res1)) {
40802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40803 }
40804 arg1 = reinterpret_cast< wxMenu * >(argp1);
40805 ecode2 = SWIG_AsVal_int(obj1, &val2);
40806 if (!SWIG_IsOK(ecode2)) {
40807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40808 }
40809 arg2 = static_cast< int >(val2);
40810 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40811 if (!SWIG_IsOK(ecode3)) {
40812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40813 }
40814 arg3 = static_cast< bool >(val3);
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 (arg1)->Enable(arg2,arg3);
40818 wxPyEndAllowThreads(__tstate);
40819 if (PyErr_Occurred()) SWIG_fail;
40820 }
40821 resultobj = SWIG_Py_Void();
40822 return resultobj;
40823 fail:
40824 return NULL;
40825 }
40826
40827
40828 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40829 PyObject *resultobj = 0;
40830 wxMenu *arg1 = (wxMenu *) 0 ;
40831 int arg2 ;
40832 bool result;
40833 void *argp1 = 0 ;
40834 int res1 = 0 ;
40835 int val2 ;
40836 int ecode2 = 0 ;
40837 PyObject * obj0 = 0 ;
40838 PyObject * obj1 = 0 ;
40839 char * kwnames[] = {
40840 (char *) "self",(char *) "id", NULL
40841 };
40842
40843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40845 if (!SWIG_IsOK(res1)) {
40846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40847 }
40848 arg1 = reinterpret_cast< wxMenu * >(argp1);
40849 ecode2 = SWIG_AsVal_int(obj1, &val2);
40850 if (!SWIG_IsOK(ecode2)) {
40851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40852 }
40853 arg2 = static_cast< int >(val2);
40854 {
40855 PyThreadState* __tstate = wxPyBeginAllowThreads();
40856 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40857 wxPyEndAllowThreads(__tstate);
40858 if (PyErr_Occurred()) SWIG_fail;
40859 }
40860 {
40861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40862 }
40863 return resultobj;
40864 fail:
40865 return NULL;
40866 }
40867
40868
40869 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40870 PyObject *resultobj = 0;
40871 wxMenu *arg1 = (wxMenu *) 0 ;
40872 int arg2 ;
40873 bool arg3 ;
40874 void *argp1 = 0 ;
40875 int res1 = 0 ;
40876 int val2 ;
40877 int ecode2 = 0 ;
40878 bool val3 ;
40879 int ecode3 = 0 ;
40880 PyObject * obj0 = 0 ;
40881 PyObject * obj1 = 0 ;
40882 PyObject * obj2 = 0 ;
40883 char * kwnames[] = {
40884 (char *) "self",(char *) "id",(char *) "check", NULL
40885 };
40886
40887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40889 if (!SWIG_IsOK(res1)) {
40890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40891 }
40892 arg1 = reinterpret_cast< wxMenu * >(argp1);
40893 ecode2 = SWIG_AsVal_int(obj1, &val2);
40894 if (!SWIG_IsOK(ecode2)) {
40895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40896 }
40897 arg2 = static_cast< int >(val2);
40898 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40899 if (!SWIG_IsOK(ecode3)) {
40900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40901 }
40902 arg3 = static_cast< bool >(val3);
40903 {
40904 PyThreadState* __tstate = wxPyBeginAllowThreads();
40905 (arg1)->Check(arg2,arg3);
40906 wxPyEndAllowThreads(__tstate);
40907 if (PyErr_Occurred()) SWIG_fail;
40908 }
40909 resultobj = SWIG_Py_Void();
40910 return resultobj;
40911 fail:
40912 return NULL;
40913 }
40914
40915
40916 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40917 PyObject *resultobj = 0;
40918 wxMenu *arg1 = (wxMenu *) 0 ;
40919 int arg2 ;
40920 bool result;
40921 void *argp1 = 0 ;
40922 int res1 = 0 ;
40923 int val2 ;
40924 int ecode2 = 0 ;
40925 PyObject * obj0 = 0 ;
40926 PyObject * obj1 = 0 ;
40927 char * kwnames[] = {
40928 (char *) "self",(char *) "id", NULL
40929 };
40930
40931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40933 if (!SWIG_IsOK(res1)) {
40934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40935 }
40936 arg1 = reinterpret_cast< wxMenu * >(argp1);
40937 ecode2 = SWIG_AsVal_int(obj1, &val2);
40938 if (!SWIG_IsOK(ecode2)) {
40939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40940 }
40941 arg2 = static_cast< int >(val2);
40942 {
40943 PyThreadState* __tstate = wxPyBeginAllowThreads();
40944 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40945 wxPyEndAllowThreads(__tstate);
40946 if (PyErr_Occurred()) SWIG_fail;
40947 }
40948 {
40949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40950 }
40951 return resultobj;
40952 fail:
40953 return NULL;
40954 }
40955
40956
40957 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40958 PyObject *resultobj = 0;
40959 wxMenu *arg1 = (wxMenu *) 0 ;
40960 int arg2 ;
40961 wxString *arg3 = 0 ;
40962 void *argp1 = 0 ;
40963 int res1 = 0 ;
40964 int val2 ;
40965 int ecode2 = 0 ;
40966 bool temp3 = false ;
40967 PyObject * obj0 = 0 ;
40968 PyObject * obj1 = 0 ;
40969 PyObject * obj2 = 0 ;
40970 char * kwnames[] = {
40971 (char *) "self",(char *) "id",(char *) "label", NULL
40972 };
40973
40974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40976 if (!SWIG_IsOK(res1)) {
40977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40978 }
40979 arg1 = reinterpret_cast< wxMenu * >(argp1);
40980 ecode2 = SWIG_AsVal_int(obj1, &val2);
40981 if (!SWIG_IsOK(ecode2)) {
40982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40983 }
40984 arg2 = static_cast< int >(val2);
40985 {
40986 arg3 = wxString_in_helper(obj2);
40987 if (arg3 == NULL) SWIG_fail;
40988 temp3 = true;
40989 }
40990 {
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40993 wxPyEndAllowThreads(__tstate);
40994 if (PyErr_Occurred()) SWIG_fail;
40995 }
40996 resultobj = SWIG_Py_Void();
40997 {
40998 if (temp3)
40999 delete arg3;
41000 }
41001 return resultobj;
41002 fail:
41003 {
41004 if (temp3)
41005 delete arg3;
41006 }
41007 return NULL;
41008 }
41009
41010
41011 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41012 PyObject *resultobj = 0;
41013 wxMenu *arg1 = (wxMenu *) 0 ;
41014 int arg2 ;
41015 wxString result;
41016 void *argp1 = 0 ;
41017 int res1 = 0 ;
41018 int val2 ;
41019 int ecode2 = 0 ;
41020 PyObject * obj0 = 0 ;
41021 PyObject * obj1 = 0 ;
41022 char * kwnames[] = {
41023 (char *) "self",(char *) "id", NULL
41024 };
41025
41026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41028 if (!SWIG_IsOK(res1)) {
41029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41030 }
41031 arg1 = reinterpret_cast< wxMenu * >(argp1);
41032 ecode2 = SWIG_AsVal_int(obj1, &val2);
41033 if (!SWIG_IsOK(ecode2)) {
41034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41035 }
41036 arg2 = static_cast< int >(val2);
41037 {
41038 PyThreadState* __tstate = wxPyBeginAllowThreads();
41039 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41040 wxPyEndAllowThreads(__tstate);
41041 if (PyErr_Occurred()) SWIG_fail;
41042 }
41043 {
41044 #if wxUSE_UNICODE
41045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41046 #else
41047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41048 #endif
41049 }
41050 return resultobj;
41051 fail:
41052 return NULL;
41053 }
41054
41055
41056 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41057 PyObject *resultobj = 0;
41058 wxMenu *arg1 = (wxMenu *) 0 ;
41059 int arg2 ;
41060 wxString *arg3 = 0 ;
41061 void *argp1 = 0 ;
41062 int res1 = 0 ;
41063 int val2 ;
41064 int ecode2 = 0 ;
41065 bool temp3 = false ;
41066 PyObject * obj0 = 0 ;
41067 PyObject * obj1 = 0 ;
41068 PyObject * obj2 = 0 ;
41069 char * kwnames[] = {
41070 (char *) "self",(char *) "id",(char *) "helpString", NULL
41071 };
41072
41073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41075 if (!SWIG_IsOK(res1)) {
41076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41077 }
41078 arg1 = reinterpret_cast< wxMenu * >(argp1);
41079 ecode2 = SWIG_AsVal_int(obj1, &val2);
41080 if (!SWIG_IsOK(ecode2)) {
41081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41082 }
41083 arg2 = static_cast< int >(val2);
41084 {
41085 arg3 = wxString_in_helper(obj2);
41086 if (arg3 == NULL) SWIG_fail;
41087 temp3 = true;
41088 }
41089 {
41090 PyThreadState* __tstate = wxPyBeginAllowThreads();
41091 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41092 wxPyEndAllowThreads(__tstate);
41093 if (PyErr_Occurred()) SWIG_fail;
41094 }
41095 resultobj = SWIG_Py_Void();
41096 {
41097 if (temp3)
41098 delete arg3;
41099 }
41100 return resultobj;
41101 fail:
41102 {
41103 if (temp3)
41104 delete arg3;
41105 }
41106 return NULL;
41107 }
41108
41109
41110 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41111 PyObject *resultobj = 0;
41112 wxMenu *arg1 = (wxMenu *) 0 ;
41113 int arg2 ;
41114 wxString result;
41115 void *argp1 = 0 ;
41116 int res1 = 0 ;
41117 int val2 ;
41118 int ecode2 = 0 ;
41119 PyObject * obj0 = 0 ;
41120 PyObject * obj1 = 0 ;
41121 char * kwnames[] = {
41122 (char *) "self",(char *) "id", NULL
41123 };
41124
41125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41127 if (!SWIG_IsOK(res1)) {
41128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41129 }
41130 arg1 = reinterpret_cast< wxMenu * >(argp1);
41131 ecode2 = SWIG_AsVal_int(obj1, &val2);
41132 if (!SWIG_IsOK(ecode2)) {
41133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41134 }
41135 arg2 = static_cast< int >(val2);
41136 {
41137 PyThreadState* __tstate = wxPyBeginAllowThreads();
41138 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41139 wxPyEndAllowThreads(__tstate);
41140 if (PyErr_Occurred()) SWIG_fail;
41141 }
41142 {
41143 #if wxUSE_UNICODE
41144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41145 #else
41146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41147 #endif
41148 }
41149 return resultobj;
41150 fail:
41151 return NULL;
41152 }
41153
41154
41155 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41156 PyObject *resultobj = 0;
41157 wxMenu *arg1 = (wxMenu *) 0 ;
41158 wxString *arg2 = 0 ;
41159 void *argp1 = 0 ;
41160 int res1 = 0 ;
41161 bool temp2 = false ;
41162 PyObject * obj0 = 0 ;
41163 PyObject * obj1 = 0 ;
41164 char * kwnames[] = {
41165 (char *) "self",(char *) "title", NULL
41166 };
41167
41168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41170 if (!SWIG_IsOK(res1)) {
41171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41172 }
41173 arg1 = reinterpret_cast< wxMenu * >(argp1);
41174 {
41175 arg2 = wxString_in_helper(obj1);
41176 if (arg2 == NULL) SWIG_fail;
41177 temp2 = true;
41178 }
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 (arg1)->SetTitle((wxString const &)*arg2);
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 resultobj = SWIG_Py_Void();
41186 {
41187 if (temp2)
41188 delete arg2;
41189 }
41190 return resultobj;
41191 fail:
41192 {
41193 if (temp2)
41194 delete arg2;
41195 }
41196 return NULL;
41197 }
41198
41199
41200 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41201 PyObject *resultobj = 0;
41202 wxMenu *arg1 = (wxMenu *) 0 ;
41203 wxString result;
41204 void *argp1 = 0 ;
41205 int res1 = 0 ;
41206 PyObject *swig_obj[1] ;
41207
41208 if (!args) SWIG_fail;
41209 swig_obj[0] = args;
41210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41211 if (!SWIG_IsOK(res1)) {
41212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41213 }
41214 arg1 = reinterpret_cast< wxMenu * >(argp1);
41215 {
41216 PyThreadState* __tstate = wxPyBeginAllowThreads();
41217 result = ((wxMenu const *)arg1)->GetTitle();
41218 wxPyEndAllowThreads(__tstate);
41219 if (PyErr_Occurred()) SWIG_fail;
41220 }
41221 {
41222 #if wxUSE_UNICODE
41223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41224 #else
41225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41226 #endif
41227 }
41228 return resultobj;
41229 fail:
41230 return NULL;
41231 }
41232
41233
41234 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41235 PyObject *resultobj = 0;
41236 wxMenu *arg1 = (wxMenu *) 0 ;
41237 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41238 void *argp1 = 0 ;
41239 int res1 = 0 ;
41240 void *argp2 = 0 ;
41241 int res2 = 0 ;
41242 PyObject * obj0 = 0 ;
41243 PyObject * obj1 = 0 ;
41244 char * kwnames[] = {
41245 (char *) "self",(char *) "handler", NULL
41246 };
41247
41248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41252 }
41253 arg1 = reinterpret_cast< wxMenu * >(argp1);
41254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41255 if (!SWIG_IsOK(res2)) {
41256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41257 }
41258 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41259 {
41260 PyThreadState* __tstate = wxPyBeginAllowThreads();
41261 (arg1)->SetEventHandler(arg2);
41262 wxPyEndAllowThreads(__tstate);
41263 if (PyErr_Occurred()) SWIG_fail;
41264 }
41265 resultobj = SWIG_Py_Void();
41266 return resultobj;
41267 fail:
41268 return NULL;
41269 }
41270
41271
41272 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41273 PyObject *resultobj = 0;
41274 wxMenu *arg1 = (wxMenu *) 0 ;
41275 wxEvtHandler *result = 0 ;
41276 void *argp1 = 0 ;
41277 int res1 = 0 ;
41278 PyObject *swig_obj[1] ;
41279
41280 if (!args) SWIG_fail;
41281 swig_obj[0] = args;
41282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41283 if (!SWIG_IsOK(res1)) {
41284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41285 }
41286 arg1 = reinterpret_cast< wxMenu * >(argp1);
41287 {
41288 PyThreadState* __tstate = wxPyBeginAllowThreads();
41289 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41290 wxPyEndAllowThreads(__tstate);
41291 if (PyErr_Occurred()) SWIG_fail;
41292 }
41293 {
41294 resultobj = wxPyMake_wxObject(result, 0);
41295 }
41296 return resultobj;
41297 fail:
41298 return NULL;
41299 }
41300
41301
41302 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41303 PyObject *resultobj = 0;
41304 wxMenu *arg1 = (wxMenu *) 0 ;
41305 wxWindow *arg2 = (wxWindow *) 0 ;
41306 void *argp1 = 0 ;
41307 int res1 = 0 ;
41308 void *argp2 = 0 ;
41309 int res2 = 0 ;
41310 PyObject * obj0 = 0 ;
41311 PyObject * obj1 = 0 ;
41312 char * kwnames[] = {
41313 (char *) "self",(char *) "win", NULL
41314 };
41315
41316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41318 if (!SWIG_IsOK(res1)) {
41319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41320 }
41321 arg1 = reinterpret_cast< wxMenu * >(argp1);
41322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41323 if (!SWIG_IsOK(res2)) {
41324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41325 }
41326 arg2 = reinterpret_cast< wxWindow * >(argp2);
41327 {
41328 PyThreadState* __tstate = wxPyBeginAllowThreads();
41329 (arg1)->SetInvokingWindow(arg2);
41330 wxPyEndAllowThreads(__tstate);
41331 if (PyErr_Occurred()) SWIG_fail;
41332 }
41333 resultobj = SWIG_Py_Void();
41334 return resultobj;
41335 fail:
41336 return NULL;
41337 }
41338
41339
41340 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41341 PyObject *resultobj = 0;
41342 wxMenu *arg1 = (wxMenu *) 0 ;
41343 wxWindow *result = 0 ;
41344 void *argp1 = 0 ;
41345 int res1 = 0 ;
41346 PyObject *swig_obj[1] ;
41347
41348 if (!args) SWIG_fail;
41349 swig_obj[0] = args;
41350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41351 if (!SWIG_IsOK(res1)) {
41352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41353 }
41354 arg1 = reinterpret_cast< wxMenu * >(argp1);
41355 {
41356 PyThreadState* __tstate = wxPyBeginAllowThreads();
41357 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41358 wxPyEndAllowThreads(__tstate);
41359 if (PyErr_Occurred()) SWIG_fail;
41360 }
41361 {
41362 resultobj = wxPyMake_wxObject(result, 0);
41363 }
41364 return resultobj;
41365 fail:
41366 return NULL;
41367 }
41368
41369
41370 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41371 PyObject *resultobj = 0;
41372 wxMenu *arg1 = (wxMenu *) 0 ;
41373 long result;
41374 void *argp1 = 0 ;
41375 int res1 = 0 ;
41376 PyObject *swig_obj[1] ;
41377
41378 if (!args) SWIG_fail;
41379 swig_obj[0] = args;
41380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41381 if (!SWIG_IsOK(res1)) {
41382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41383 }
41384 arg1 = reinterpret_cast< wxMenu * >(argp1);
41385 {
41386 PyThreadState* __tstate = wxPyBeginAllowThreads();
41387 result = (long)((wxMenu const *)arg1)->GetStyle();
41388 wxPyEndAllowThreads(__tstate);
41389 if (PyErr_Occurred()) SWIG_fail;
41390 }
41391 resultobj = SWIG_From_long(static_cast< long >(result));
41392 return resultobj;
41393 fail:
41394 return NULL;
41395 }
41396
41397
41398 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41399 PyObject *resultobj = 0;
41400 wxMenu *arg1 = (wxMenu *) 0 ;
41401 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41402 void *argp1 = 0 ;
41403 int res1 = 0 ;
41404 void *argp2 = 0 ;
41405 int res2 = 0 ;
41406 PyObject * obj0 = 0 ;
41407 PyObject * obj1 = 0 ;
41408 char * kwnames[] = {
41409 (char *) "self",(char *) "source", NULL
41410 };
41411
41412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41414 if (!SWIG_IsOK(res1)) {
41415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41416 }
41417 arg1 = reinterpret_cast< wxMenu * >(argp1);
41418 if (obj1) {
41419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41420 if (!SWIG_IsOK(res2)) {
41421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41422 }
41423 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41424 }
41425 {
41426 PyThreadState* __tstate = wxPyBeginAllowThreads();
41427 (arg1)->UpdateUI(arg2);
41428 wxPyEndAllowThreads(__tstate);
41429 if (PyErr_Occurred()) SWIG_fail;
41430 }
41431 resultobj = SWIG_Py_Void();
41432 return resultobj;
41433 fail:
41434 return NULL;
41435 }
41436
41437
41438 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41439 PyObject *resultobj = 0;
41440 wxMenu *arg1 = (wxMenu *) 0 ;
41441 wxMenuBar *result = 0 ;
41442 void *argp1 = 0 ;
41443 int res1 = 0 ;
41444 PyObject *swig_obj[1] ;
41445
41446 if (!args) SWIG_fail;
41447 swig_obj[0] = args;
41448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41449 if (!SWIG_IsOK(res1)) {
41450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41451 }
41452 arg1 = reinterpret_cast< wxMenu * >(argp1);
41453 {
41454 PyThreadState* __tstate = wxPyBeginAllowThreads();
41455 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41456 wxPyEndAllowThreads(__tstate);
41457 if (PyErr_Occurred()) SWIG_fail;
41458 }
41459 {
41460 resultobj = wxPyMake_wxObject(result, (bool)0);
41461 }
41462 return resultobj;
41463 fail:
41464 return NULL;
41465 }
41466
41467
41468 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41469 PyObject *resultobj = 0;
41470 wxMenu *arg1 = (wxMenu *) 0 ;
41471 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41472 void *argp1 = 0 ;
41473 int res1 = 0 ;
41474 void *argp2 = 0 ;
41475 int res2 = 0 ;
41476 PyObject * obj0 = 0 ;
41477 PyObject * obj1 = 0 ;
41478 char * kwnames[] = {
41479 (char *) "self",(char *) "menubar", NULL
41480 };
41481
41482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41484 if (!SWIG_IsOK(res1)) {
41485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41486 }
41487 arg1 = reinterpret_cast< wxMenu * >(argp1);
41488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41489 if (!SWIG_IsOK(res2)) {
41490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41491 }
41492 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 (arg1)->Attach(arg2);
41496 wxPyEndAllowThreads(__tstate);
41497 if (PyErr_Occurred()) SWIG_fail;
41498 }
41499 resultobj = SWIG_Py_Void();
41500 return resultobj;
41501 fail:
41502 return NULL;
41503 }
41504
41505
41506 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41507 PyObject *resultobj = 0;
41508 wxMenu *arg1 = (wxMenu *) 0 ;
41509 void *argp1 = 0 ;
41510 int res1 = 0 ;
41511 PyObject *swig_obj[1] ;
41512
41513 if (!args) SWIG_fail;
41514 swig_obj[0] = args;
41515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41516 if (!SWIG_IsOK(res1)) {
41517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41518 }
41519 arg1 = reinterpret_cast< wxMenu * >(argp1);
41520 {
41521 PyThreadState* __tstate = wxPyBeginAllowThreads();
41522 (arg1)->Detach();
41523 wxPyEndAllowThreads(__tstate);
41524 if (PyErr_Occurred()) SWIG_fail;
41525 }
41526 resultobj = SWIG_Py_Void();
41527 return resultobj;
41528 fail:
41529 return NULL;
41530 }
41531
41532
41533 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41534 PyObject *resultobj = 0;
41535 wxMenu *arg1 = (wxMenu *) 0 ;
41536 bool result;
41537 void *argp1 = 0 ;
41538 int res1 = 0 ;
41539 PyObject *swig_obj[1] ;
41540
41541 if (!args) SWIG_fail;
41542 swig_obj[0] = args;
41543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41544 if (!SWIG_IsOK(res1)) {
41545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41546 }
41547 arg1 = reinterpret_cast< wxMenu * >(argp1);
41548 {
41549 PyThreadState* __tstate = wxPyBeginAllowThreads();
41550 result = (bool)((wxMenu const *)arg1)->IsAttached();
41551 wxPyEndAllowThreads(__tstate);
41552 if (PyErr_Occurred()) SWIG_fail;
41553 }
41554 {
41555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41556 }
41557 return resultobj;
41558 fail:
41559 return NULL;
41560 }
41561
41562
41563 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41564 PyObject *resultobj = 0;
41565 wxMenu *arg1 = (wxMenu *) 0 ;
41566 wxMenu *arg2 = (wxMenu *) 0 ;
41567 void *argp1 = 0 ;
41568 int res1 = 0 ;
41569 void *argp2 = 0 ;
41570 int res2 = 0 ;
41571 PyObject * obj0 = 0 ;
41572 PyObject * obj1 = 0 ;
41573 char * kwnames[] = {
41574 (char *) "self",(char *) "parent", NULL
41575 };
41576
41577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41579 if (!SWIG_IsOK(res1)) {
41580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41581 }
41582 arg1 = reinterpret_cast< wxMenu * >(argp1);
41583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41584 if (!SWIG_IsOK(res2)) {
41585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41586 }
41587 arg2 = reinterpret_cast< wxMenu * >(argp2);
41588 {
41589 PyThreadState* __tstate = wxPyBeginAllowThreads();
41590 (arg1)->SetParent(arg2);
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 resultobj = SWIG_Py_Void();
41595 return resultobj;
41596 fail:
41597 return NULL;
41598 }
41599
41600
41601 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41602 PyObject *resultobj = 0;
41603 wxMenu *arg1 = (wxMenu *) 0 ;
41604 wxMenu *result = 0 ;
41605 void *argp1 = 0 ;
41606 int res1 = 0 ;
41607 PyObject *swig_obj[1] ;
41608
41609 if (!args) SWIG_fail;
41610 swig_obj[0] = args;
41611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41612 if (!SWIG_IsOK(res1)) {
41613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41614 }
41615 arg1 = reinterpret_cast< wxMenu * >(argp1);
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 {
41623 resultobj = wxPyMake_wxObject(result, 0);
41624 }
41625 return resultobj;
41626 fail:
41627 return NULL;
41628 }
41629
41630
41631 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41632 PyObject *obj;
41633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41634 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41635 return SWIG_Py_Void();
41636 }
41637
41638 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41639 return SWIG_Python_InitShadowInstance(args);
41640 }
41641
41642 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41643 PyObject *resultobj = 0;
41644 long arg1 = (long) 0 ;
41645 wxMenuBar *result = 0 ;
41646 long val1 ;
41647 int ecode1 = 0 ;
41648 PyObject * obj0 = 0 ;
41649 char * kwnames[] = {
41650 (char *) "style", NULL
41651 };
41652
41653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41654 if (obj0) {
41655 ecode1 = SWIG_AsVal_long(obj0, &val1);
41656 if (!SWIG_IsOK(ecode1)) {
41657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41658 }
41659 arg1 = static_cast< long >(val1);
41660 }
41661 {
41662 if (!wxPyCheckForApp()) SWIG_fail;
41663 PyThreadState* __tstate = wxPyBeginAllowThreads();
41664 result = (wxMenuBar *)new wxMenuBar(arg1);
41665 wxPyEndAllowThreads(__tstate);
41666 if (PyErr_Occurred()) SWIG_fail;
41667 }
41668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41669 return resultobj;
41670 fail:
41671 return NULL;
41672 }
41673
41674
41675 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41676 PyObject *resultobj = 0;
41677 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41678 wxMenu *arg2 = (wxMenu *) 0 ;
41679 wxString *arg3 = 0 ;
41680 bool result;
41681 void *argp1 = 0 ;
41682 int res1 = 0 ;
41683 void *argp2 = 0 ;
41684 int res2 = 0 ;
41685 bool temp3 = false ;
41686 PyObject * obj0 = 0 ;
41687 PyObject * obj1 = 0 ;
41688 PyObject * obj2 = 0 ;
41689 char * kwnames[] = {
41690 (char *) "self",(char *) "menu",(char *) "title", NULL
41691 };
41692
41693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41695 if (!SWIG_IsOK(res1)) {
41696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41697 }
41698 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41700 if (!SWIG_IsOK(res2)) {
41701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41702 }
41703 arg2 = reinterpret_cast< wxMenu * >(argp2);
41704 {
41705 arg3 = wxString_in_helper(obj2);
41706 if (arg3 == NULL) SWIG_fail;
41707 temp3 = true;
41708 }
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41712 wxPyEndAllowThreads(__tstate);
41713 if (PyErr_Occurred()) SWIG_fail;
41714 }
41715 {
41716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41717 }
41718 {
41719 if (temp3)
41720 delete arg3;
41721 }
41722 return resultobj;
41723 fail:
41724 {
41725 if (temp3)
41726 delete arg3;
41727 }
41728 return NULL;
41729 }
41730
41731
41732 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41733 PyObject *resultobj = 0;
41734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41735 size_t arg2 ;
41736 wxMenu *arg3 = (wxMenu *) 0 ;
41737 wxString *arg4 = 0 ;
41738 bool result;
41739 void *argp1 = 0 ;
41740 int res1 = 0 ;
41741 size_t val2 ;
41742 int ecode2 = 0 ;
41743 void *argp3 = 0 ;
41744 int res3 = 0 ;
41745 bool temp4 = false ;
41746 PyObject * obj0 = 0 ;
41747 PyObject * obj1 = 0 ;
41748 PyObject * obj2 = 0 ;
41749 PyObject * obj3 = 0 ;
41750 char * kwnames[] = {
41751 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41752 };
41753
41754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41756 if (!SWIG_IsOK(res1)) {
41757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41758 }
41759 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41760 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41761 if (!SWIG_IsOK(ecode2)) {
41762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41763 }
41764 arg2 = static_cast< size_t >(val2);
41765 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41766 if (!SWIG_IsOK(res3)) {
41767 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41768 }
41769 arg3 = reinterpret_cast< wxMenu * >(argp3);
41770 {
41771 arg4 = wxString_in_helper(obj3);
41772 if (arg4 == NULL) SWIG_fail;
41773 temp4 = true;
41774 }
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41778 wxPyEndAllowThreads(__tstate);
41779 if (PyErr_Occurred()) SWIG_fail;
41780 }
41781 {
41782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41783 }
41784 {
41785 if (temp4)
41786 delete arg4;
41787 }
41788 return resultobj;
41789 fail:
41790 {
41791 if (temp4)
41792 delete arg4;
41793 }
41794 return NULL;
41795 }
41796
41797
41798 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41799 PyObject *resultobj = 0;
41800 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41801 size_t result;
41802 void *argp1 = 0 ;
41803 int res1 = 0 ;
41804 PyObject *swig_obj[1] ;
41805
41806 if (!args) SWIG_fail;
41807 swig_obj[0] = args;
41808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41809 if (!SWIG_IsOK(res1)) {
41810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41811 }
41812 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41813 {
41814 PyThreadState* __tstate = wxPyBeginAllowThreads();
41815 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41816 wxPyEndAllowThreads(__tstate);
41817 if (PyErr_Occurred()) SWIG_fail;
41818 }
41819 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41820 return resultobj;
41821 fail:
41822 return NULL;
41823 }
41824
41825
41826 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41827 PyObject *resultobj = 0;
41828 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41829 size_t arg2 ;
41830 wxMenu *result = 0 ;
41831 void *argp1 = 0 ;
41832 int res1 = 0 ;
41833 size_t val2 ;
41834 int ecode2 = 0 ;
41835 PyObject * obj0 = 0 ;
41836 PyObject * obj1 = 0 ;
41837 char * kwnames[] = {
41838 (char *) "self",(char *) "pos", NULL
41839 };
41840
41841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41843 if (!SWIG_IsOK(res1)) {
41844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41845 }
41846 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41847 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41848 if (!SWIG_IsOK(ecode2)) {
41849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41850 }
41851 arg2 = static_cast< size_t >(val2);
41852 {
41853 PyThreadState* __tstate = wxPyBeginAllowThreads();
41854 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41855 wxPyEndAllowThreads(__tstate);
41856 if (PyErr_Occurred()) SWIG_fail;
41857 }
41858 {
41859 resultobj = wxPyMake_wxObject(result, 0);
41860 }
41861 return resultobj;
41862 fail:
41863 return NULL;
41864 }
41865
41866
41867 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41868 PyObject *resultobj = 0;
41869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41870 size_t arg2 ;
41871 wxMenu *arg3 = (wxMenu *) 0 ;
41872 wxString *arg4 = 0 ;
41873 wxMenu *result = 0 ;
41874 void *argp1 = 0 ;
41875 int res1 = 0 ;
41876 size_t val2 ;
41877 int ecode2 = 0 ;
41878 void *argp3 = 0 ;
41879 int res3 = 0 ;
41880 bool temp4 = false ;
41881 PyObject * obj0 = 0 ;
41882 PyObject * obj1 = 0 ;
41883 PyObject * obj2 = 0 ;
41884 PyObject * obj3 = 0 ;
41885 char * kwnames[] = {
41886 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41887 };
41888
41889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41891 if (!SWIG_IsOK(res1)) {
41892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41893 }
41894 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41895 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41896 if (!SWIG_IsOK(ecode2)) {
41897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41898 }
41899 arg2 = static_cast< size_t >(val2);
41900 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41901 if (!SWIG_IsOK(res3)) {
41902 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41903 }
41904 arg3 = reinterpret_cast< wxMenu * >(argp3);
41905 {
41906 arg4 = wxString_in_helper(obj3);
41907 if (arg4 == NULL) SWIG_fail;
41908 temp4 = true;
41909 }
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 {
41917 resultobj = wxPyMake_wxObject(result, 0);
41918 }
41919 {
41920 if (temp4)
41921 delete arg4;
41922 }
41923 return resultobj;
41924 fail:
41925 {
41926 if (temp4)
41927 delete arg4;
41928 }
41929 return NULL;
41930 }
41931
41932
41933 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41934 PyObject *resultobj = 0;
41935 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41936 size_t arg2 ;
41937 wxMenu *result = 0 ;
41938 void *argp1 = 0 ;
41939 int res1 = 0 ;
41940 size_t val2 ;
41941 int ecode2 = 0 ;
41942 PyObject * obj0 = 0 ;
41943 PyObject * obj1 = 0 ;
41944 char * kwnames[] = {
41945 (char *) "self",(char *) "pos", NULL
41946 };
41947
41948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41950 if (!SWIG_IsOK(res1)) {
41951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41952 }
41953 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41954 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41955 if (!SWIG_IsOK(ecode2)) {
41956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41957 }
41958 arg2 = static_cast< size_t >(val2);
41959 {
41960 PyThreadState* __tstate = wxPyBeginAllowThreads();
41961 result = (wxMenu *)(arg1)->Remove(arg2);
41962 wxPyEndAllowThreads(__tstate);
41963 if (PyErr_Occurred()) SWIG_fail;
41964 }
41965 {
41966 resultobj = wxPyMake_wxObject(result, 0);
41967 }
41968 return resultobj;
41969 fail:
41970 return NULL;
41971 }
41972
41973
41974 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41975 PyObject *resultobj = 0;
41976 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41977 size_t arg2 ;
41978 bool arg3 ;
41979 void *argp1 = 0 ;
41980 int res1 = 0 ;
41981 size_t val2 ;
41982 int ecode2 = 0 ;
41983 bool val3 ;
41984 int ecode3 = 0 ;
41985 PyObject * obj0 = 0 ;
41986 PyObject * obj1 = 0 ;
41987 PyObject * obj2 = 0 ;
41988 char * kwnames[] = {
41989 (char *) "self",(char *) "pos",(char *) "enable", NULL
41990 };
41991
41992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41994 if (!SWIG_IsOK(res1)) {
41995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41996 }
41997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41998 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41999 if (!SWIG_IsOK(ecode2)) {
42000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42001 }
42002 arg2 = static_cast< size_t >(val2);
42003 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42004 if (!SWIG_IsOK(ecode3)) {
42005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42006 }
42007 arg3 = static_cast< bool >(val3);
42008 {
42009 PyThreadState* __tstate = wxPyBeginAllowThreads();
42010 (arg1)->EnableTop(arg2,arg3);
42011 wxPyEndAllowThreads(__tstate);
42012 if (PyErr_Occurred()) SWIG_fail;
42013 }
42014 resultobj = SWIG_Py_Void();
42015 return resultobj;
42016 fail:
42017 return NULL;
42018 }
42019
42020
42021 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42022 PyObject *resultobj = 0;
42023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42024 size_t arg2 ;
42025 bool result;
42026 void *argp1 = 0 ;
42027 int res1 = 0 ;
42028 size_t val2 ;
42029 int ecode2 = 0 ;
42030 PyObject * obj0 = 0 ;
42031 PyObject * obj1 = 0 ;
42032 char * kwnames[] = {
42033 (char *) "self",(char *) "pos", NULL
42034 };
42035
42036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42038 if (!SWIG_IsOK(res1)) {
42039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42040 }
42041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42042 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42043 if (!SWIG_IsOK(ecode2)) {
42044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42045 }
42046 arg2 = static_cast< size_t >(val2);
42047 {
42048 PyThreadState* __tstate = wxPyBeginAllowThreads();
42049 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42050 wxPyEndAllowThreads(__tstate);
42051 if (PyErr_Occurred()) SWIG_fail;
42052 }
42053 {
42054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42055 }
42056 return resultobj;
42057 fail:
42058 return NULL;
42059 }
42060
42061
42062 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42063 PyObject *resultobj = 0;
42064 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42065 size_t arg2 ;
42066 wxString *arg3 = 0 ;
42067 void *argp1 = 0 ;
42068 int res1 = 0 ;
42069 size_t val2 ;
42070 int ecode2 = 0 ;
42071 bool temp3 = false ;
42072 PyObject * obj0 = 0 ;
42073 PyObject * obj1 = 0 ;
42074 PyObject * obj2 = 0 ;
42075 char * kwnames[] = {
42076 (char *) "self",(char *) "pos",(char *) "label", NULL
42077 };
42078
42079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42081 if (!SWIG_IsOK(res1)) {
42082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42083 }
42084 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42085 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42086 if (!SWIG_IsOK(ecode2)) {
42087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42088 }
42089 arg2 = static_cast< size_t >(val2);
42090 {
42091 arg3 = wxString_in_helper(obj2);
42092 if (arg3 == NULL) SWIG_fail;
42093 temp3 = true;
42094 }
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42098 wxPyEndAllowThreads(__tstate);
42099 if (PyErr_Occurred()) SWIG_fail;
42100 }
42101 resultobj = SWIG_Py_Void();
42102 {
42103 if (temp3)
42104 delete arg3;
42105 }
42106 return resultobj;
42107 fail:
42108 {
42109 if (temp3)
42110 delete arg3;
42111 }
42112 return NULL;
42113 }
42114
42115
42116 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42117 PyObject *resultobj = 0;
42118 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42119 size_t arg2 ;
42120 wxString result;
42121 void *argp1 = 0 ;
42122 int res1 = 0 ;
42123 size_t val2 ;
42124 int ecode2 = 0 ;
42125 PyObject * obj0 = 0 ;
42126 PyObject * obj1 = 0 ;
42127 char * kwnames[] = {
42128 (char *) "self",(char *) "pos", NULL
42129 };
42130
42131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42133 if (!SWIG_IsOK(res1)) {
42134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42135 }
42136 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42137 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42138 if (!SWIG_IsOK(ecode2)) {
42139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42140 }
42141 arg2 = static_cast< size_t >(val2);
42142 {
42143 PyThreadState* __tstate = wxPyBeginAllowThreads();
42144 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 {
42149 #if wxUSE_UNICODE
42150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42151 #else
42152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42153 #endif
42154 }
42155 return resultobj;
42156 fail:
42157 return NULL;
42158 }
42159
42160
42161 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42162 PyObject *resultobj = 0;
42163 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42164 wxString *arg2 = 0 ;
42165 wxString *arg3 = 0 ;
42166 int result;
42167 void *argp1 = 0 ;
42168 int res1 = 0 ;
42169 bool temp2 = false ;
42170 bool temp3 = false ;
42171 PyObject * obj0 = 0 ;
42172 PyObject * obj1 = 0 ;
42173 PyObject * obj2 = 0 ;
42174 char * kwnames[] = {
42175 (char *) "self",(char *) "menu",(char *) "item", NULL
42176 };
42177
42178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42180 if (!SWIG_IsOK(res1)) {
42181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42182 }
42183 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42184 {
42185 arg2 = wxString_in_helper(obj1);
42186 if (arg2 == NULL) SWIG_fail;
42187 temp2 = true;
42188 }
42189 {
42190 arg3 = wxString_in_helper(obj2);
42191 if (arg3 == NULL) SWIG_fail;
42192 temp3 = true;
42193 }
42194 {
42195 PyThreadState* __tstate = wxPyBeginAllowThreads();
42196 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42197 wxPyEndAllowThreads(__tstate);
42198 if (PyErr_Occurred()) SWIG_fail;
42199 }
42200 resultobj = SWIG_From_int(static_cast< int >(result));
42201 {
42202 if (temp2)
42203 delete arg2;
42204 }
42205 {
42206 if (temp3)
42207 delete arg3;
42208 }
42209 return resultobj;
42210 fail:
42211 {
42212 if (temp2)
42213 delete arg2;
42214 }
42215 {
42216 if (temp3)
42217 delete arg3;
42218 }
42219 return NULL;
42220 }
42221
42222
42223 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42224 PyObject *resultobj = 0;
42225 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42226 int arg2 ;
42227 wxMenuItem *result = 0 ;
42228 void *argp1 = 0 ;
42229 int res1 = 0 ;
42230 int val2 ;
42231 int ecode2 = 0 ;
42232 PyObject * obj0 = 0 ;
42233 PyObject * obj1 = 0 ;
42234 char * kwnames[] = {
42235 (char *) "self",(char *) "id", NULL
42236 };
42237
42238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42240 if (!SWIG_IsOK(res1)) {
42241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42242 }
42243 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42244 ecode2 = SWIG_AsVal_int(obj1, &val2);
42245 if (!SWIG_IsOK(ecode2)) {
42246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42247 }
42248 arg2 = static_cast< int >(val2);
42249 {
42250 PyThreadState* __tstate = wxPyBeginAllowThreads();
42251 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42252 wxPyEndAllowThreads(__tstate);
42253 if (PyErr_Occurred()) SWIG_fail;
42254 }
42255 {
42256 resultobj = wxPyMake_wxObject(result, (bool)0);
42257 }
42258 return resultobj;
42259 fail:
42260 return NULL;
42261 }
42262
42263
42264 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42265 PyObject *resultobj = 0;
42266 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42267 wxString *arg2 = 0 ;
42268 int result;
42269 void *argp1 = 0 ;
42270 int res1 = 0 ;
42271 bool temp2 = false ;
42272 PyObject * obj0 = 0 ;
42273 PyObject * obj1 = 0 ;
42274 char * kwnames[] = {
42275 (char *) "self",(char *) "title", NULL
42276 };
42277
42278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42280 if (!SWIG_IsOK(res1)) {
42281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42282 }
42283 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42284 {
42285 arg2 = wxString_in_helper(obj1);
42286 if (arg2 == NULL) SWIG_fail;
42287 temp2 = true;
42288 }
42289 {
42290 PyThreadState* __tstate = wxPyBeginAllowThreads();
42291 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42292 wxPyEndAllowThreads(__tstate);
42293 if (PyErr_Occurred()) SWIG_fail;
42294 }
42295 resultobj = SWIG_From_int(static_cast< int >(result));
42296 {
42297 if (temp2)
42298 delete arg2;
42299 }
42300 return resultobj;
42301 fail:
42302 {
42303 if (temp2)
42304 delete arg2;
42305 }
42306 return NULL;
42307 }
42308
42309
42310 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42311 PyObject *resultobj = 0;
42312 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42313 int arg2 ;
42314 bool arg3 ;
42315 void *argp1 = 0 ;
42316 int res1 = 0 ;
42317 int val2 ;
42318 int ecode2 = 0 ;
42319 bool val3 ;
42320 int ecode3 = 0 ;
42321 PyObject * obj0 = 0 ;
42322 PyObject * obj1 = 0 ;
42323 PyObject * obj2 = 0 ;
42324 char * kwnames[] = {
42325 (char *) "self",(char *) "id",(char *) "enable", NULL
42326 };
42327
42328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42330 if (!SWIG_IsOK(res1)) {
42331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42332 }
42333 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42334 ecode2 = SWIG_AsVal_int(obj1, &val2);
42335 if (!SWIG_IsOK(ecode2)) {
42336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42337 }
42338 arg2 = static_cast< int >(val2);
42339 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42340 if (!SWIG_IsOK(ecode3)) {
42341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42342 }
42343 arg3 = static_cast< bool >(val3);
42344 {
42345 PyThreadState* __tstate = wxPyBeginAllowThreads();
42346 (arg1)->Enable(arg2,arg3);
42347 wxPyEndAllowThreads(__tstate);
42348 if (PyErr_Occurred()) SWIG_fail;
42349 }
42350 resultobj = SWIG_Py_Void();
42351 return resultobj;
42352 fail:
42353 return NULL;
42354 }
42355
42356
42357 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42358 PyObject *resultobj = 0;
42359 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42360 int arg2 ;
42361 bool arg3 ;
42362 void *argp1 = 0 ;
42363 int res1 = 0 ;
42364 int val2 ;
42365 int ecode2 = 0 ;
42366 bool val3 ;
42367 int ecode3 = 0 ;
42368 PyObject * obj0 = 0 ;
42369 PyObject * obj1 = 0 ;
42370 PyObject * obj2 = 0 ;
42371 char * kwnames[] = {
42372 (char *) "self",(char *) "id",(char *) "check", NULL
42373 };
42374
42375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42377 if (!SWIG_IsOK(res1)) {
42378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42379 }
42380 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42381 ecode2 = SWIG_AsVal_int(obj1, &val2);
42382 if (!SWIG_IsOK(ecode2)) {
42383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42384 }
42385 arg2 = static_cast< int >(val2);
42386 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42387 if (!SWIG_IsOK(ecode3)) {
42388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42389 }
42390 arg3 = static_cast< bool >(val3);
42391 {
42392 PyThreadState* __tstate = wxPyBeginAllowThreads();
42393 (arg1)->Check(arg2,arg3);
42394 wxPyEndAllowThreads(__tstate);
42395 if (PyErr_Occurred()) SWIG_fail;
42396 }
42397 resultobj = SWIG_Py_Void();
42398 return resultobj;
42399 fail:
42400 return NULL;
42401 }
42402
42403
42404 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42405 PyObject *resultobj = 0;
42406 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42407 int arg2 ;
42408 bool result;
42409 void *argp1 = 0 ;
42410 int res1 = 0 ;
42411 int val2 ;
42412 int ecode2 = 0 ;
42413 PyObject * obj0 = 0 ;
42414 PyObject * obj1 = 0 ;
42415 char * kwnames[] = {
42416 (char *) "self",(char *) "id", NULL
42417 };
42418
42419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42421 if (!SWIG_IsOK(res1)) {
42422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42423 }
42424 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42425 ecode2 = SWIG_AsVal_int(obj1, &val2);
42426 if (!SWIG_IsOK(ecode2)) {
42427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42428 }
42429 arg2 = static_cast< int >(val2);
42430 {
42431 PyThreadState* __tstate = wxPyBeginAllowThreads();
42432 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42433 wxPyEndAllowThreads(__tstate);
42434 if (PyErr_Occurred()) SWIG_fail;
42435 }
42436 {
42437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42438 }
42439 return resultobj;
42440 fail:
42441 return NULL;
42442 }
42443
42444
42445 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42446 PyObject *resultobj = 0;
42447 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42448 int arg2 ;
42449 bool result;
42450 void *argp1 = 0 ;
42451 int res1 = 0 ;
42452 int val2 ;
42453 int ecode2 = 0 ;
42454 PyObject * obj0 = 0 ;
42455 PyObject * obj1 = 0 ;
42456 char * kwnames[] = {
42457 (char *) "self",(char *) "id", NULL
42458 };
42459
42460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42462 if (!SWIG_IsOK(res1)) {
42463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42464 }
42465 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42466 ecode2 = SWIG_AsVal_int(obj1, &val2);
42467 if (!SWIG_IsOK(ecode2)) {
42468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42469 }
42470 arg2 = static_cast< int >(val2);
42471 {
42472 PyThreadState* __tstate = wxPyBeginAllowThreads();
42473 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42474 wxPyEndAllowThreads(__tstate);
42475 if (PyErr_Occurred()) SWIG_fail;
42476 }
42477 {
42478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42479 }
42480 return resultobj;
42481 fail:
42482 return NULL;
42483 }
42484
42485
42486 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42487 PyObject *resultobj = 0;
42488 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42489 int arg2 ;
42490 wxString *arg3 = 0 ;
42491 void *argp1 = 0 ;
42492 int res1 = 0 ;
42493 int val2 ;
42494 int ecode2 = 0 ;
42495 bool temp3 = false ;
42496 PyObject * obj0 = 0 ;
42497 PyObject * obj1 = 0 ;
42498 PyObject * obj2 = 0 ;
42499 char * kwnames[] = {
42500 (char *) "self",(char *) "id",(char *) "label", NULL
42501 };
42502
42503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42505 if (!SWIG_IsOK(res1)) {
42506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42507 }
42508 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42509 ecode2 = SWIG_AsVal_int(obj1, &val2);
42510 if (!SWIG_IsOK(ecode2)) {
42511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42512 }
42513 arg2 = static_cast< int >(val2);
42514 {
42515 arg3 = wxString_in_helper(obj2);
42516 if (arg3 == NULL) SWIG_fail;
42517 temp3 = true;
42518 }
42519 {
42520 PyThreadState* __tstate = wxPyBeginAllowThreads();
42521 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42522 wxPyEndAllowThreads(__tstate);
42523 if (PyErr_Occurred()) SWIG_fail;
42524 }
42525 resultobj = SWIG_Py_Void();
42526 {
42527 if (temp3)
42528 delete arg3;
42529 }
42530 return resultobj;
42531 fail:
42532 {
42533 if (temp3)
42534 delete arg3;
42535 }
42536 return NULL;
42537 }
42538
42539
42540 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42541 PyObject *resultobj = 0;
42542 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42543 int arg2 ;
42544 wxString result;
42545 void *argp1 = 0 ;
42546 int res1 = 0 ;
42547 int val2 ;
42548 int ecode2 = 0 ;
42549 PyObject * obj0 = 0 ;
42550 PyObject * obj1 = 0 ;
42551 char * kwnames[] = {
42552 (char *) "self",(char *) "id", NULL
42553 };
42554
42555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42557 if (!SWIG_IsOK(res1)) {
42558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42559 }
42560 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42561 ecode2 = SWIG_AsVal_int(obj1, &val2);
42562 if (!SWIG_IsOK(ecode2)) {
42563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42564 }
42565 arg2 = static_cast< int >(val2);
42566 {
42567 PyThreadState* __tstate = wxPyBeginAllowThreads();
42568 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42569 wxPyEndAllowThreads(__tstate);
42570 if (PyErr_Occurred()) SWIG_fail;
42571 }
42572 {
42573 #if wxUSE_UNICODE
42574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42575 #else
42576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42577 #endif
42578 }
42579 return resultobj;
42580 fail:
42581 return NULL;
42582 }
42583
42584
42585 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42586 PyObject *resultobj = 0;
42587 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42588 int arg2 ;
42589 wxString *arg3 = 0 ;
42590 void *argp1 = 0 ;
42591 int res1 = 0 ;
42592 int val2 ;
42593 int ecode2 = 0 ;
42594 bool temp3 = false ;
42595 PyObject * obj0 = 0 ;
42596 PyObject * obj1 = 0 ;
42597 PyObject * obj2 = 0 ;
42598 char * kwnames[] = {
42599 (char *) "self",(char *) "id",(char *) "helpString", NULL
42600 };
42601
42602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42604 if (!SWIG_IsOK(res1)) {
42605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42606 }
42607 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42608 ecode2 = SWIG_AsVal_int(obj1, &val2);
42609 if (!SWIG_IsOK(ecode2)) {
42610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42611 }
42612 arg2 = static_cast< int >(val2);
42613 {
42614 arg3 = wxString_in_helper(obj2);
42615 if (arg3 == NULL) SWIG_fail;
42616 temp3 = true;
42617 }
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42621 wxPyEndAllowThreads(__tstate);
42622 if (PyErr_Occurred()) SWIG_fail;
42623 }
42624 resultobj = SWIG_Py_Void();
42625 {
42626 if (temp3)
42627 delete arg3;
42628 }
42629 return resultobj;
42630 fail:
42631 {
42632 if (temp3)
42633 delete arg3;
42634 }
42635 return NULL;
42636 }
42637
42638
42639 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42640 PyObject *resultobj = 0;
42641 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42642 int arg2 ;
42643 wxString result;
42644 void *argp1 = 0 ;
42645 int res1 = 0 ;
42646 int val2 ;
42647 int ecode2 = 0 ;
42648 PyObject * obj0 = 0 ;
42649 PyObject * obj1 = 0 ;
42650 char * kwnames[] = {
42651 (char *) "self",(char *) "id", NULL
42652 };
42653
42654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42656 if (!SWIG_IsOK(res1)) {
42657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42658 }
42659 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42660 ecode2 = SWIG_AsVal_int(obj1, &val2);
42661 if (!SWIG_IsOK(ecode2)) {
42662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42663 }
42664 arg2 = static_cast< int >(val2);
42665 {
42666 PyThreadState* __tstate = wxPyBeginAllowThreads();
42667 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42668 wxPyEndAllowThreads(__tstate);
42669 if (PyErr_Occurred()) SWIG_fail;
42670 }
42671 {
42672 #if wxUSE_UNICODE
42673 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42674 #else
42675 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42676 #endif
42677 }
42678 return resultobj;
42679 fail:
42680 return NULL;
42681 }
42682
42683
42684 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42685 PyObject *resultobj = 0;
42686 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42687 wxFrame *result = 0 ;
42688 void *argp1 = 0 ;
42689 int res1 = 0 ;
42690 PyObject *swig_obj[1] ;
42691
42692 if (!args) SWIG_fail;
42693 swig_obj[0] = args;
42694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42695 if (!SWIG_IsOK(res1)) {
42696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42697 }
42698 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42699 {
42700 PyThreadState* __tstate = wxPyBeginAllowThreads();
42701 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42702 wxPyEndAllowThreads(__tstate);
42703 if (PyErr_Occurred()) SWIG_fail;
42704 }
42705 {
42706 resultobj = wxPyMake_wxObject(result, (bool)0);
42707 }
42708 return resultobj;
42709 fail:
42710 return NULL;
42711 }
42712
42713
42714 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42715 PyObject *resultobj = 0;
42716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42717 bool result;
42718 void *argp1 = 0 ;
42719 int res1 = 0 ;
42720 PyObject *swig_obj[1] ;
42721
42722 if (!args) SWIG_fail;
42723 swig_obj[0] = args;
42724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42725 if (!SWIG_IsOK(res1)) {
42726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42727 }
42728 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42729 {
42730 PyThreadState* __tstate = wxPyBeginAllowThreads();
42731 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42732 wxPyEndAllowThreads(__tstate);
42733 if (PyErr_Occurred()) SWIG_fail;
42734 }
42735 {
42736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42737 }
42738 return resultobj;
42739 fail:
42740 return NULL;
42741 }
42742
42743
42744 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42745 PyObject *resultobj = 0;
42746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42747 wxFrame *arg2 = (wxFrame *) 0 ;
42748 void *argp1 = 0 ;
42749 int res1 = 0 ;
42750 void *argp2 = 0 ;
42751 int res2 = 0 ;
42752 PyObject * obj0 = 0 ;
42753 PyObject * obj1 = 0 ;
42754 char * kwnames[] = {
42755 (char *) "self",(char *) "frame", NULL
42756 };
42757
42758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42760 if (!SWIG_IsOK(res1)) {
42761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42762 }
42763 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42764 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42765 if (!SWIG_IsOK(res2)) {
42766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42767 }
42768 arg2 = reinterpret_cast< wxFrame * >(argp2);
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 (arg1)->Attach(arg2);
42772 wxPyEndAllowThreads(__tstate);
42773 if (PyErr_Occurred()) SWIG_fail;
42774 }
42775 resultobj = SWIG_Py_Void();
42776 return resultobj;
42777 fail:
42778 return NULL;
42779 }
42780
42781
42782 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42783 PyObject *resultobj = 0;
42784 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42785 void *argp1 = 0 ;
42786 int res1 = 0 ;
42787 PyObject *swig_obj[1] ;
42788
42789 if (!args) SWIG_fail;
42790 swig_obj[0] = args;
42791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42792 if (!SWIG_IsOK(res1)) {
42793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42794 }
42795 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42796 {
42797 PyThreadState* __tstate = wxPyBeginAllowThreads();
42798 (arg1)->Detach();
42799 wxPyEndAllowThreads(__tstate);
42800 if (PyErr_Occurred()) SWIG_fail;
42801 }
42802 resultobj = SWIG_Py_Void();
42803 return resultobj;
42804 fail:
42805 return NULL;
42806 }
42807
42808
42809 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42810 PyObject *resultobj = 0;
42811 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42812 void *argp1 = 0 ;
42813 int res1 = 0 ;
42814 PyObject *swig_obj[1] ;
42815
42816 if (!args) SWIG_fail;
42817 swig_obj[0] = args;
42818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42819 if (!SWIG_IsOK(res1)) {
42820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42821 }
42822 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42823 {
42824 PyThreadState* __tstate = wxPyBeginAllowThreads();
42825 (arg1)->UpdateMenus();
42826 wxPyEndAllowThreads(__tstate);
42827 if (PyErr_Occurred()) SWIG_fail;
42828 }
42829 resultobj = SWIG_Py_Void();
42830 return resultobj;
42831 fail:
42832 return NULL;
42833 }
42834
42835
42836 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42837 PyObject *resultobj = 0;
42838 bool arg1 ;
42839 bool val1 ;
42840 int ecode1 = 0 ;
42841 PyObject * obj0 = 0 ;
42842 char * kwnames[] = {
42843 (char *) "enable", NULL
42844 };
42845
42846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42847 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42848 if (!SWIG_IsOK(ecode1)) {
42849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42850 }
42851 arg1 = static_cast< bool >(val1);
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 wxMenuBar_SetAutoWindowMenu(arg1);
42855 wxPyEndAllowThreads(__tstate);
42856 if (PyErr_Occurred()) SWIG_fail;
42857 }
42858 resultobj = SWIG_Py_Void();
42859 return resultobj;
42860 fail:
42861 return NULL;
42862 }
42863
42864
42865 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42866 PyObject *resultobj = 0;
42867 bool result;
42868
42869 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42870 {
42871 PyThreadState* __tstate = wxPyBeginAllowThreads();
42872 result = (bool)wxMenuBar_GetAutoWindowMenu();
42873 wxPyEndAllowThreads(__tstate);
42874 if (PyErr_Occurred()) SWIG_fail;
42875 }
42876 {
42877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42878 }
42879 return resultobj;
42880 fail:
42881 return NULL;
42882 }
42883
42884
42885 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42886 PyObject *obj;
42887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42888 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42889 return SWIG_Py_Void();
42890 }
42891
42892 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42893 return SWIG_Python_InitShadowInstance(args);
42894 }
42895
42896 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42897 PyObject *resultobj = 0;
42898 wxMenu *arg1 = (wxMenu *) NULL ;
42899 int arg2 = (int) wxID_ANY ;
42900 wxString const &arg3_defvalue = wxPyEmptyString ;
42901 wxString *arg3 = (wxString *) &arg3_defvalue ;
42902 wxString const &arg4_defvalue = wxPyEmptyString ;
42903 wxString *arg4 = (wxString *) &arg4_defvalue ;
42904 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42905 wxMenu *arg6 = (wxMenu *) NULL ;
42906 wxMenuItem *result = 0 ;
42907 void *argp1 = 0 ;
42908 int res1 = 0 ;
42909 int val2 ;
42910 int ecode2 = 0 ;
42911 bool temp3 = false ;
42912 bool temp4 = false ;
42913 int val5 ;
42914 int ecode5 = 0 ;
42915 void *argp6 = 0 ;
42916 int res6 = 0 ;
42917 PyObject * obj0 = 0 ;
42918 PyObject * obj1 = 0 ;
42919 PyObject * obj2 = 0 ;
42920 PyObject * obj3 = 0 ;
42921 PyObject * obj4 = 0 ;
42922 PyObject * obj5 = 0 ;
42923 char * kwnames[] = {
42924 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42925 };
42926
42927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42928 if (obj0) {
42929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42930 if (!SWIG_IsOK(res1)) {
42931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42932 }
42933 arg1 = reinterpret_cast< wxMenu * >(argp1);
42934 }
42935 if (obj1) {
42936 ecode2 = SWIG_AsVal_int(obj1, &val2);
42937 if (!SWIG_IsOK(ecode2)) {
42938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42939 }
42940 arg2 = static_cast< int >(val2);
42941 }
42942 if (obj2) {
42943 {
42944 arg3 = wxString_in_helper(obj2);
42945 if (arg3 == NULL) SWIG_fail;
42946 temp3 = true;
42947 }
42948 }
42949 if (obj3) {
42950 {
42951 arg4 = wxString_in_helper(obj3);
42952 if (arg4 == NULL) SWIG_fail;
42953 temp4 = true;
42954 }
42955 }
42956 if (obj4) {
42957 ecode5 = SWIG_AsVal_int(obj4, &val5);
42958 if (!SWIG_IsOK(ecode5)) {
42959 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42960 }
42961 arg5 = static_cast< wxItemKind >(val5);
42962 }
42963 if (obj5) {
42964 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42965 if (!SWIG_IsOK(res6)) {
42966 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42967 }
42968 arg6 = reinterpret_cast< wxMenu * >(argp6);
42969 }
42970 {
42971 PyThreadState* __tstate = wxPyBeginAllowThreads();
42972 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42973 wxPyEndAllowThreads(__tstate);
42974 if (PyErr_Occurred()) SWIG_fail;
42975 }
42976 {
42977 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42978 }
42979 {
42980 if (temp3)
42981 delete arg3;
42982 }
42983 {
42984 if (temp4)
42985 delete arg4;
42986 }
42987 return resultobj;
42988 fail:
42989 {
42990 if (temp3)
42991 delete arg3;
42992 }
42993 {
42994 if (temp4)
42995 delete arg4;
42996 }
42997 return NULL;
42998 }
42999
43000
43001 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43002 PyObject *resultobj = 0;
43003 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43004 void *argp1 = 0 ;
43005 int res1 = 0 ;
43006 PyObject *swig_obj[1] ;
43007
43008 if (!args) SWIG_fail;
43009 swig_obj[0] = args;
43010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43011 if (!SWIG_IsOK(res1)) {
43012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43013 }
43014 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43015 {
43016 PyThreadState* __tstate = wxPyBeginAllowThreads();
43017 delete arg1;
43018
43019 wxPyEndAllowThreads(__tstate);
43020 if (PyErr_Occurred()) SWIG_fail;
43021 }
43022 resultobj = SWIG_Py_Void();
43023 return resultobj;
43024 fail:
43025 return NULL;
43026 }
43027
43028
43029 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43030 PyObject *resultobj = 0;
43031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43032 wxMenu *result = 0 ;
43033 void *argp1 = 0 ;
43034 int res1 = 0 ;
43035 PyObject *swig_obj[1] ;
43036
43037 if (!args) SWIG_fail;
43038 swig_obj[0] = args;
43039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43040 if (!SWIG_IsOK(res1)) {
43041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43042 }
43043 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43044 {
43045 PyThreadState* __tstate = wxPyBeginAllowThreads();
43046 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43047 wxPyEndAllowThreads(__tstate);
43048 if (PyErr_Occurred()) SWIG_fail;
43049 }
43050 {
43051 resultobj = wxPyMake_wxObject(result, 0);
43052 }
43053 return resultobj;
43054 fail:
43055 return NULL;
43056 }
43057
43058
43059 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43060 PyObject *resultobj = 0;
43061 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43062 wxMenu *arg2 = (wxMenu *) 0 ;
43063 void *argp1 = 0 ;
43064 int res1 = 0 ;
43065 void *argp2 = 0 ;
43066 int res2 = 0 ;
43067 PyObject * obj0 = 0 ;
43068 PyObject * obj1 = 0 ;
43069 char * kwnames[] = {
43070 (char *) "self",(char *) "menu", NULL
43071 };
43072
43073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43075 if (!SWIG_IsOK(res1)) {
43076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43077 }
43078 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43080 if (!SWIG_IsOK(res2)) {
43081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43082 }
43083 arg2 = reinterpret_cast< wxMenu * >(argp2);
43084 {
43085 PyThreadState* __tstate = wxPyBeginAllowThreads();
43086 (arg1)->SetMenu(arg2);
43087 wxPyEndAllowThreads(__tstate);
43088 if (PyErr_Occurred()) SWIG_fail;
43089 }
43090 resultobj = SWIG_Py_Void();
43091 return resultobj;
43092 fail:
43093 return NULL;
43094 }
43095
43096
43097 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43098 PyObject *resultobj = 0;
43099 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43100 int arg2 ;
43101 void *argp1 = 0 ;
43102 int res1 = 0 ;
43103 int val2 ;
43104 int ecode2 = 0 ;
43105 PyObject * obj0 = 0 ;
43106 PyObject * obj1 = 0 ;
43107 char * kwnames[] = {
43108 (char *) "self",(char *) "id", NULL
43109 };
43110
43111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43113 if (!SWIG_IsOK(res1)) {
43114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43115 }
43116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43117 ecode2 = SWIG_AsVal_int(obj1, &val2);
43118 if (!SWIG_IsOK(ecode2)) {
43119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43120 }
43121 arg2 = static_cast< int >(val2);
43122 {
43123 PyThreadState* __tstate = wxPyBeginAllowThreads();
43124 (arg1)->SetId(arg2);
43125 wxPyEndAllowThreads(__tstate);
43126 if (PyErr_Occurred()) SWIG_fail;
43127 }
43128 resultobj = SWIG_Py_Void();
43129 return resultobj;
43130 fail:
43131 return NULL;
43132 }
43133
43134
43135 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43136 PyObject *resultobj = 0;
43137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43138 int result;
43139 void *argp1 = 0 ;
43140 int res1 = 0 ;
43141 PyObject *swig_obj[1] ;
43142
43143 if (!args) SWIG_fail;
43144 swig_obj[0] = args;
43145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43146 if (!SWIG_IsOK(res1)) {
43147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43148 }
43149 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43150 {
43151 PyThreadState* __tstate = wxPyBeginAllowThreads();
43152 result = (int)((wxMenuItem const *)arg1)->GetId();
43153 wxPyEndAllowThreads(__tstate);
43154 if (PyErr_Occurred()) SWIG_fail;
43155 }
43156 resultobj = SWIG_From_int(static_cast< int >(result));
43157 return resultobj;
43158 fail:
43159 return NULL;
43160 }
43161
43162
43163 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43164 PyObject *resultobj = 0;
43165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43166 bool result;
43167 void *argp1 = 0 ;
43168 int res1 = 0 ;
43169 PyObject *swig_obj[1] ;
43170
43171 if (!args) SWIG_fail;
43172 swig_obj[0] = args;
43173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43174 if (!SWIG_IsOK(res1)) {
43175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43176 }
43177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43178 {
43179 PyThreadState* __tstate = wxPyBeginAllowThreads();
43180 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43181 wxPyEndAllowThreads(__tstate);
43182 if (PyErr_Occurred()) SWIG_fail;
43183 }
43184 {
43185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43186 }
43187 return resultobj;
43188 fail:
43189 return NULL;
43190 }
43191
43192
43193 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43194 PyObject *resultobj = 0;
43195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43196 wxString *arg2 = 0 ;
43197 void *argp1 = 0 ;
43198 int res1 = 0 ;
43199 bool temp2 = false ;
43200 PyObject * obj0 = 0 ;
43201 PyObject * obj1 = 0 ;
43202 char * kwnames[] = {
43203 (char *) "self",(char *) "str", NULL
43204 };
43205
43206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43208 if (!SWIG_IsOK(res1)) {
43209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43210 }
43211 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43212 {
43213 arg2 = wxString_in_helper(obj1);
43214 if (arg2 == NULL) SWIG_fail;
43215 temp2 = true;
43216 }
43217 {
43218 PyThreadState* __tstate = wxPyBeginAllowThreads();
43219 (arg1)->SetText((wxString const &)*arg2);
43220 wxPyEndAllowThreads(__tstate);
43221 if (PyErr_Occurred()) SWIG_fail;
43222 }
43223 resultobj = SWIG_Py_Void();
43224 {
43225 if (temp2)
43226 delete arg2;
43227 }
43228 return resultobj;
43229 fail:
43230 {
43231 if (temp2)
43232 delete arg2;
43233 }
43234 return NULL;
43235 }
43236
43237
43238 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43239 PyObject *resultobj = 0;
43240 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43241 wxString result;
43242 void *argp1 = 0 ;
43243 int res1 = 0 ;
43244 PyObject *swig_obj[1] ;
43245
43246 if (!args) SWIG_fail;
43247 swig_obj[0] = args;
43248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43249 if (!SWIG_IsOK(res1)) {
43250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43251 }
43252 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43253 {
43254 PyThreadState* __tstate = wxPyBeginAllowThreads();
43255 result = ((wxMenuItem const *)arg1)->GetLabel();
43256 wxPyEndAllowThreads(__tstate);
43257 if (PyErr_Occurred()) SWIG_fail;
43258 }
43259 {
43260 #if wxUSE_UNICODE
43261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43262 #else
43263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43264 #endif
43265 }
43266 return resultobj;
43267 fail:
43268 return NULL;
43269 }
43270
43271
43272 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43273 PyObject *resultobj = 0;
43274 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43275 wxString *result = 0 ;
43276 void *argp1 = 0 ;
43277 int res1 = 0 ;
43278 PyObject *swig_obj[1] ;
43279
43280 if (!args) SWIG_fail;
43281 swig_obj[0] = args;
43282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43283 if (!SWIG_IsOK(res1)) {
43284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43285 }
43286 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43287 {
43288 PyThreadState* __tstate = wxPyBeginAllowThreads();
43289 {
43290 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43291 result = (wxString *) &_result_ref;
43292 }
43293 wxPyEndAllowThreads(__tstate);
43294 if (PyErr_Occurred()) SWIG_fail;
43295 }
43296 {
43297 #if wxUSE_UNICODE
43298 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43299 #else
43300 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43301 #endif
43302 }
43303 return resultobj;
43304 fail:
43305 return NULL;
43306 }
43307
43308
43309 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43310 PyObject *resultobj = 0;
43311 wxString *arg1 = 0 ;
43312 wxString result;
43313 bool temp1 = false ;
43314 PyObject * obj0 = 0 ;
43315 char * kwnames[] = {
43316 (char *) "text", NULL
43317 };
43318
43319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43320 {
43321 arg1 = wxString_in_helper(obj0);
43322 if (arg1 == NULL) SWIG_fail;
43323 temp1 = true;
43324 }
43325 {
43326 PyThreadState* __tstate = wxPyBeginAllowThreads();
43327 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43328 wxPyEndAllowThreads(__tstate);
43329 if (PyErr_Occurred()) SWIG_fail;
43330 }
43331 {
43332 #if wxUSE_UNICODE
43333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43334 #else
43335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43336 #endif
43337 }
43338 {
43339 if (temp1)
43340 delete arg1;
43341 }
43342 return resultobj;
43343 fail:
43344 {
43345 if (temp1)
43346 delete arg1;
43347 }
43348 return NULL;
43349 }
43350
43351
43352 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43353 PyObject *resultobj = 0;
43354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43355 wxItemKind result;
43356 void *argp1 = 0 ;
43357 int res1 = 0 ;
43358 PyObject *swig_obj[1] ;
43359
43360 if (!args) SWIG_fail;
43361 swig_obj[0] = args;
43362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43363 if (!SWIG_IsOK(res1)) {
43364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43365 }
43366 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43367 {
43368 PyThreadState* __tstate = wxPyBeginAllowThreads();
43369 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 resultobj = SWIG_From_int(static_cast< int >(result));
43374 return resultobj;
43375 fail:
43376 return NULL;
43377 }
43378
43379
43380 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43381 PyObject *resultobj = 0;
43382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43383 wxItemKind arg2 ;
43384 void *argp1 = 0 ;
43385 int res1 = 0 ;
43386 int val2 ;
43387 int ecode2 = 0 ;
43388 PyObject * obj0 = 0 ;
43389 PyObject * obj1 = 0 ;
43390 char * kwnames[] = {
43391 (char *) "self",(char *) "kind", NULL
43392 };
43393
43394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43396 if (!SWIG_IsOK(res1)) {
43397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43398 }
43399 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43400 ecode2 = SWIG_AsVal_int(obj1, &val2);
43401 if (!SWIG_IsOK(ecode2)) {
43402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43403 }
43404 arg2 = static_cast< wxItemKind >(val2);
43405 {
43406 PyThreadState* __tstate = wxPyBeginAllowThreads();
43407 (arg1)->SetKind(arg2);
43408 wxPyEndAllowThreads(__tstate);
43409 if (PyErr_Occurred()) SWIG_fail;
43410 }
43411 resultobj = SWIG_Py_Void();
43412 return resultobj;
43413 fail:
43414 return NULL;
43415 }
43416
43417
43418 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43419 PyObject *resultobj = 0;
43420 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43421 bool arg2 ;
43422 void *argp1 = 0 ;
43423 int res1 = 0 ;
43424 bool val2 ;
43425 int ecode2 = 0 ;
43426 PyObject * obj0 = 0 ;
43427 PyObject * obj1 = 0 ;
43428 char * kwnames[] = {
43429 (char *) "self",(char *) "checkable", NULL
43430 };
43431
43432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43434 if (!SWIG_IsOK(res1)) {
43435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43436 }
43437 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43438 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43439 if (!SWIG_IsOK(ecode2)) {
43440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43441 }
43442 arg2 = static_cast< bool >(val2);
43443 {
43444 PyThreadState* __tstate = wxPyBeginAllowThreads();
43445 (arg1)->SetCheckable(arg2);
43446 wxPyEndAllowThreads(__tstate);
43447 if (PyErr_Occurred()) SWIG_fail;
43448 }
43449 resultobj = SWIG_Py_Void();
43450 return resultobj;
43451 fail:
43452 return NULL;
43453 }
43454
43455
43456 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43457 PyObject *resultobj = 0;
43458 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43459 bool result;
43460 void *argp1 = 0 ;
43461 int res1 = 0 ;
43462 PyObject *swig_obj[1] ;
43463
43464 if (!args) SWIG_fail;
43465 swig_obj[0] = args;
43466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43467 if (!SWIG_IsOK(res1)) {
43468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43469 }
43470 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43471 {
43472 PyThreadState* __tstate = wxPyBeginAllowThreads();
43473 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43474 wxPyEndAllowThreads(__tstate);
43475 if (PyErr_Occurred()) SWIG_fail;
43476 }
43477 {
43478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43479 }
43480 return resultobj;
43481 fail:
43482 return NULL;
43483 }
43484
43485
43486 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43487 PyObject *resultobj = 0;
43488 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43489 bool result;
43490 void *argp1 = 0 ;
43491 int res1 = 0 ;
43492 PyObject *swig_obj[1] ;
43493
43494 if (!args) SWIG_fail;
43495 swig_obj[0] = args;
43496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43497 if (!SWIG_IsOK(res1)) {
43498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43499 }
43500 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43501 {
43502 PyThreadState* __tstate = wxPyBeginAllowThreads();
43503 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 {
43508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43509 }
43510 return resultobj;
43511 fail:
43512 return NULL;
43513 }
43514
43515
43516 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43517 PyObject *resultobj = 0;
43518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43519 wxMenu *arg2 = (wxMenu *) 0 ;
43520 void *argp1 = 0 ;
43521 int res1 = 0 ;
43522 void *argp2 = 0 ;
43523 int res2 = 0 ;
43524 PyObject * obj0 = 0 ;
43525 PyObject * obj1 = 0 ;
43526 char * kwnames[] = {
43527 (char *) "self",(char *) "menu", NULL
43528 };
43529
43530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43532 if (!SWIG_IsOK(res1)) {
43533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43534 }
43535 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43537 if (!SWIG_IsOK(res2)) {
43538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43539 }
43540 arg2 = reinterpret_cast< wxMenu * >(argp2);
43541 {
43542 PyThreadState* __tstate = wxPyBeginAllowThreads();
43543 (arg1)->SetSubMenu(arg2);
43544 wxPyEndAllowThreads(__tstate);
43545 if (PyErr_Occurred()) SWIG_fail;
43546 }
43547 resultobj = SWIG_Py_Void();
43548 return resultobj;
43549 fail:
43550 return NULL;
43551 }
43552
43553
43554 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43555 PyObject *resultobj = 0;
43556 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43557 wxMenu *result = 0 ;
43558 void *argp1 = 0 ;
43559 int res1 = 0 ;
43560 PyObject *swig_obj[1] ;
43561
43562 if (!args) SWIG_fail;
43563 swig_obj[0] = args;
43564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43565 if (!SWIG_IsOK(res1)) {
43566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43567 }
43568 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43569 {
43570 PyThreadState* __tstate = wxPyBeginAllowThreads();
43571 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43572 wxPyEndAllowThreads(__tstate);
43573 if (PyErr_Occurred()) SWIG_fail;
43574 }
43575 {
43576 resultobj = wxPyMake_wxObject(result, 0);
43577 }
43578 return resultobj;
43579 fail:
43580 return NULL;
43581 }
43582
43583
43584 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43585 PyObject *resultobj = 0;
43586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43587 bool arg2 = (bool) true ;
43588 void *argp1 = 0 ;
43589 int res1 = 0 ;
43590 bool val2 ;
43591 int ecode2 = 0 ;
43592 PyObject * obj0 = 0 ;
43593 PyObject * obj1 = 0 ;
43594 char * kwnames[] = {
43595 (char *) "self",(char *) "enable", NULL
43596 };
43597
43598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43600 if (!SWIG_IsOK(res1)) {
43601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43602 }
43603 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43604 if (obj1) {
43605 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43606 if (!SWIG_IsOK(ecode2)) {
43607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43608 }
43609 arg2 = static_cast< bool >(val2);
43610 }
43611 {
43612 PyThreadState* __tstate = wxPyBeginAllowThreads();
43613 (arg1)->Enable(arg2);
43614 wxPyEndAllowThreads(__tstate);
43615 if (PyErr_Occurred()) SWIG_fail;
43616 }
43617 resultobj = SWIG_Py_Void();
43618 return resultobj;
43619 fail:
43620 return NULL;
43621 }
43622
43623
43624 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43625 PyObject *resultobj = 0;
43626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43627 bool result;
43628 void *argp1 = 0 ;
43629 int res1 = 0 ;
43630 PyObject *swig_obj[1] ;
43631
43632 if (!args) SWIG_fail;
43633 swig_obj[0] = args;
43634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43635 if (!SWIG_IsOK(res1)) {
43636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43637 }
43638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43639 {
43640 PyThreadState* __tstate = wxPyBeginAllowThreads();
43641 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43642 wxPyEndAllowThreads(__tstate);
43643 if (PyErr_Occurred()) SWIG_fail;
43644 }
43645 {
43646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43647 }
43648 return resultobj;
43649 fail:
43650 return NULL;
43651 }
43652
43653
43654 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43655 PyObject *resultobj = 0;
43656 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43657 bool arg2 = (bool) true ;
43658 void *argp1 = 0 ;
43659 int res1 = 0 ;
43660 bool val2 ;
43661 int ecode2 = 0 ;
43662 PyObject * obj0 = 0 ;
43663 PyObject * obj1 = 0 ;
43664 char * kwnames[] = {
43665 (char *) "self",(char *) "check", NULL
43666 };
43667
43668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43670 if (!SWIG_IsOK(res1)) {
43671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43672 }
43673 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43674 if (obj1) {
43675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43676 if (!SWIG_IsOK(ecode2)) {
43677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43678 }
43679 arg2 = static_cast< bool >(val2);
43680 }
43681 {
43682 PyThreadState* __tstate = wxPyBeginAllowThreads();
43683 (arg1)->Check(arg2);
43684 wxPyEndAllowThreads(__tstate);
43685 if (PyErr_Occurred()) SWIG_fail;
43686 }
43687 resultobj = SWIG_Py_Void();
43688 return resultobj;
43689 fail:
43690 return NULL;
43691 }
43692
43693
43694 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43695 PyObject *resultobj = 0;
43696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43697 bool result;
43698 void *argp1 = 0 ;
43699 int res1 = 0 ;
43700 PyObject *swig_obj[1] ;
43701
43702 if (!args) SWIG_fail;
43703 swig_obj[0] = args;
43704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43705 if (!SWIG_IsOK(res1)) {
43706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43707 }
43708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43709 {
43710 PyThreadState* __tstate = wxPyBeginAllowThreads();
43711 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43712 wxPyEndAllowThreads(__tstate);
43713 if (PyErr_Occurred()) SWIG_fail;
43714 }
43715 {
43716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43717 }
43718 return resultobj;
43719 fail:
43720 return NULL;
43721 }
43722
43723
43724 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43725 PyObject *resultobj = 0;
43726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43727 void *argp1 = 0 ;
43728 int res1 = 0 ;
43729 PyObject *swig_obj[1] ;
43730
43731 if (!args) SWIG_fail;
43732 swig_obj[0] = args;
43733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43734 if (!SWIG_IsOK(res1)) {
43735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43736 }
43737 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43738 {
43739 PyThreadState* __tstate = wxPyBeginAllowThreads();
43740 (arg1)->Toggle();
43741 wxPyEndAllowThreads(__tstate);
43742 if (PyErr_Occurred()) SWIG_fail;
43743 }
43744 resultobj = SWIG_Py_Void();
43745 return resultobj;
43746 fail:
43747 return NULL;
43748 }
43749
43750
43751 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43752 PyObject *resultobj = 0;
43753 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43754 wxString *arg2 = 0 ;
43755 void *argp1 = 0 ;
43756 int res1 = 0 ;
43757 bool temp2 = false ;
43758 PyObject * obj0 = 0 ;
43759 PyObject * obj1 = 0 ;
43760 char * kwnames[] = {
43761 (char *) "self",(char *) "str", NULL
43762 };
43763
43764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43766 if (!SWIG_IsOK(res1)) {
43767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43768 }
43769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43770 {
43771 arg2 = wxString_in_helper(obj1);
43772 if (arg2 == NULL) SWIG_fail;
43773 temp2 = true;
43774 }
43775 {
43776 PyThreadState* __tstate = wxPyBeginAllowThreads();
43777 (arg1)->SetHelp((wxString const &)*arg2);
43778 wxPyEndAllowThreads(__tstate);
43779 if (PyErr_Occurred()) SWIG_fail;
43780 }
43781 resultobj = SWIG_Py_Void();
43782 {
43783 if (temp2)
43784 delete arg2;
43785 }
43786 return resultobj;
43787 fail:
43788 {
43789 if (temp2)
43790 delete arg2;
43791 }
43792 return NULL;
43793 }
43794
43795
43796 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43797 PyObject *resultobj = 0;
43798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43799 wxString *result = 0 ;
43800 void *argp1 = 0 ;
43801 int res1 = 0 ;
43802 PyObject *swig_obj[1] ;
43803
43804 if (!args) SWIG_fail;
43805 swig_obj[0] = args;
43806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43807 if (!SWIG_IsOK(res1)) {
43808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43809 }
43810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43811 {
43812 PyThreadState* __tstate = wxPyBeginAllowThreads();
43813 {
43814 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43815 result = (wxString *) &_result_ref;
43816 }
43817 wxPyEndAllowThreads(__tstate);
43818 if (PyErr_Occurred()) SWIG_fail;
43819 }
43820 {
43821 #if wxUSE_UNICODE
43822 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43823 #else
43824 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43825 #endif
43826 }
43827 return resultobj;
43828 fail:
43829 return NULL;
43830 }
43831
43832
43833 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43834 PyObject *resultobj = 0;
43835 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43836 wxAcceleratorEntry *result = 0 ;
43837 void *argp1 = 0 ;
43838 int res1 = 0 ;
43839 PyObject *swig_obj[1] ;
43840
43841 if (!args) SWIG_fail;
43842 swig_obj[0] = args;
43843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43844 if (!SWIG_IsOK(res1)) {
43845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43846 }
43847 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43848 {
43849 PyThreadState* __tstate = wxPyBeginAllowThreads();
43850 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43851 wxPyEndAllowThreads(__tstate);
43852 if (PyErr_Occurred()) SWIG_fail;
43853 }
43854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43855 return resultobj;
43856 fail:
43857 return NULL;
43858 }
43859
43860
43861 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43862 PyObject *resultobj = 0;
43863 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43864 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43865 void *argp1 = 0 ;
43866 int res1 = 0 ;
43867 void *argp2 = 0 ;
43868 int res2 = 0 ;
43869 PyObject * obj0 = 0 ;
43870 PyObject * obj1 = 0 ;
43871 char * kwnames[] = {
43872 (char *) "self",(char *) "accel", NULL
43873 };
43874
43875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43877 if (!SWIG_IsOK(res1)) {
43878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43879 }
43880 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43882 if (!SWIG_IsOK(res2)) {
43883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43884 }
43885 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43886 {
43887 PyThreadState* __tstate = wxPyBeginAllowThreads();
43888 (arg1)->SetAccel(arg2);
43889 wxPyEndAllowThreads(__tstate);
43890 if (PyErr_Occurred()) SWIG_fail;
43891 }
43892 resultobj = SWIG_Py_Void();
43893 return resultobj;
43894 fail:
43895 return NULL;
43896 }
43897
43898
43899 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43900 PyObject *resultobj = 0;
43901 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43902 wxBitmap *arg2 = 0 ;
43903 void *argp1 = 0 ;
43904 int res1 = 0 ;
43905 void *argp2 = 0 ;
43906 int res2 = 0 ;
43907 PyObject * obj0 = 0 ;
43908 PyObject * obj1 = 0 ;
43909 char * kwnames[] = {
43910 (char *) "self",(char *) "bitmap", NULL
43911 };
43912
43913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43915 if (!SWIG_IsOK(res1)) {
43916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43917 }
43918 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43919 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43920 if (!SWIG_IsOK(res2)) {
43921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43922 }
43923 if (!argp2) {
43924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43925 }
43926 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43927 {
43928 PyThreadState* __tstate = wxPyBeginAllowThreads();
43929 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43930 wxPyEndAllowThreads(__tstate);
43931 if (PyErr_Occurred()) SWIG_fail;
43932 }
43933 resultobj = SWIG_Py_Void();
43934 return resultobj;
43935 fail:
43936 return NULL;
43937 }
43938
43939
43940 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43941 PyObject *resultobj = 0;
43942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43943 wxBitmap *result = 0 ;
43944 void *argp1 = 0 ;
43945 int res1 = 0 ;
43946 PyObject *swig_obj[1] ;
43947
43948 if (!args) SWIG_fail;
43949 swig_obj[0] = args;
43950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43951 if (!SWIG_IsOK(res1)) {
43952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43953 }
43954 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43955 {
43956 PyThreadState* __tstate = wxPyBeginAllowThreads();
43957 {
43958 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43959 result = (wxBitmap *) &_result_ref;
43960 }
43961 wxPyEndAllowThreads(__tstate);
43962 if (PyErr_Occurred()) SWIG_fail;
43963 }
43964 {
43965 wxBitmap* resultptr = new wxBitmap(*result);
43966 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43967 }
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj = 0;
43976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43977 wxFont *arg2 = 0 ;
43978 void *argp1 = 0 ;
43979 int res1 = 0 ;
43980 void *argp2 = 0 ;
43981 int res2 = 0 ;
43982 PyObject * obj0 = 0 ;
43983 PyObject * obj1 = 0 ;
43984 char * kwnames[] = {
43985 (char *) "self",(char *) "font", NULL
43986 };
43987
43988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43990 if (!SWIG_IsOK(res1)) {
43991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43992 }
43993 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43994 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43995 if (!SWIG_IsOK(res2)) {
43996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43997 }
43998 if (!argp2) {
43999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44000 }
44001 arg2 = reinterpret_cast< wxFont * >(argp2);
44002 {
44003 PyThreadState* __tstate = wxPyBeginAllowThreads();
44004 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44005 wxPyEndAllowThreads(__tstate);
44006 if (PyErr_Occurred()) SWIG_fail;
44007 }
44008 resultobj = SWIG_Py_Void();
44009 return resultobj;
44010 fail:
44011 return NULL;
44012 }
44013
44014
44015 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44016 PyObject *resultobj = 0;
44017 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44018 wxFont result;
44019 void *argp1 = 0 ;
44020 int res1 = 0 ;
44021 PyObject *swig_obj[1] ;
44022
44023 if (!args) SWIG_fail;
44024 swig_obj[0] = args;
44025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44026 if (!SWIG_IsOK(res1)) {
44027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44028 }
44029 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44030 {
44031 PyThreadState* __tstate = wxPyBeginAllowThreads();
44032 result = wxMenuItem_GetFont(arg1);
44033 wxPyEndAllowThreads(__tstate);
44034 if (PyErr_Occurred()) SWIG_fail;
44035 }
44036 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44037 return resultobj;
44038 fail:
44039 return NULL;
44040 }
44041
44042
44043 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44044 PyObject *resultobj = 0;
44045 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44046 wxColour *arg2 = 0 ;
44047 void *argp1 = 0 ;
44048 int res1 = 0 ;
44049 wxColour temp2 ;
44050 PyObject * obj0 = 0 ;
44051 PyObject * obj1 = 0 ;
44052 char * kwnames[] = {
44053 (char *) "self",(char *) "colText", NULL
44054 };
44055
44056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44058 if (!SWIG_IsOK(res1)) {
44059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44060 }
44061 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44062 {
44063 arg2 = &temp2;
44064 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44065 }
44066 {
44067 PyThreadState* __tstate = wxPyBeginAllowThreads();
44068 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44069 wxPyEndAllowThreads(__tstate);
44070 if (PyErr_Occurred()) SWIG_fail;
44071 }
44072 resultobj = SWIG_Py_Void();
44073 return resultobj;
44074 fail:
44075 return NULL;
44076 }
44077
44078
44079 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44080 PyObject *resultobj = 0;
44081 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44082 wxColour result;
44083 void *argp1 = 0 ;
44084 int res1 = 0 ;
44085 PyObject *swig_obj[1] ;
44086
44087 if (!args) SWIG_fail;
44088 swig_obj[0] = args;
44089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44090 if (!SWIG_IsOK(res1)) {
44091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44092 }
44093 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44094 {
44095 PyThreadState* __tstate = wxPyBeginAllowThreads();
44096 result = wxMenuItem_GetTextColour(arg1);
44097 wxPyEndAllowThreads(__tstate);
44098 if (PyErr_Occurred()) SWIG_fail;
44099 }
44100 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44101 return resultobj;
44102 fail:
44103 return NULL;
44104 }
44105
44106
44107 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44108 PyObject *resultobj = 0;
44109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44110 wxColour *arg2 = 0 ;
44111 void *argp1 = 0 ;
44112 int res1 = 0 ;
44113 wxColour temp2 ;
44114 PyObject * obj0 = 0 ;
44115 PyObject * obj1 = 0 ;
44116 char * kwnames[] = {
44117 (char *) "self",(char *) "colBack", NULL
44118 };
44119
44120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44122 if (!SWIG_IsOK(res1)) {
44123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44124 }
44125 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44126 {
44127 arg2 = &temp2;
44128 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44129 }
44130 {
44131 PyThreadState* __tstate = wxPyBeginAllowThreads();
44132 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 resultobj = SWIG_Py_Void();
44137 return resultobj;
44138 fail:
44139 return NULL;
44140 }
44141
44142
44143 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44144 PyObject *resultobj = 0;
44145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44146 wxColour result;
44147 void *argp1 = 0 ;
44148 int res1 = 0 ;
44149 PyObject *swig_obj[1] ;
44150
44151 if (!args) SWIG_fail;
44152 swig_obj[0] = args;
44153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44154 if (!SWIG_IsOK(res1)) {
44155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44156 }
44157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44158 {
44159 PyThreadState* __tstate = wxPyBeginAllowThreads();
44160 result = wxMenuItem_GetBackgroundColour(arg1);
44161 wxPyEndAllowThreads(__tstate);
44162 if (PyErr_Occurred()) SWIG_fail;
44163 }
44164 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44165 return resultobj;
44166 fail:
44167 return NULL;
44168 }
44169
44170
44171 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44172 PyObject *resultobj = 0;
44173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44174 wxBitmap *arg2 = 0 ;
44175 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44176 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44177 void *argp1 = 0 ;
44178 int res1 = 0 ;
44179 void *argp2 = 0 ;
44180 int res2 = 0 ;
44181 void *argp3 = 0 ;
44182 int res3 = 0 ;
44183 PyObject * obj0 = 0 ;
44184 PyObject * obj1 = 0 ;
44185 PyObject * obj2 = 0 ;
44186 char * kwnames[] = {
44187 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44188 };
44189
44190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44192 if (!SWIG_IsOK(res1)) {
44193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44194 }
44195 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44197 if (!SWIG_IsOK(res2)) {
44198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44199 }
44200 if (!argp2) {
44201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44202 }
44203 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44204 if (obj2) {
44205 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44206 if (!SWIG_IsOK(res3)) {
44207 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44208 }
44209 if (!argp3) {
44210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44211 }
44212 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44213 }
44214 {
44215 PyThreadState* __tstate = wxPyBeginAllowThreads();
44216 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44217 wxPyEndAllowThreads(__tstate);
44218 if (PyErr_Occurred()) SWIG_fail;
44219 }
44220 resultobj = SWIG_Py_Void();
44221 return resultobj;
44222 fail:
44223 return NULL;
44224 }
44225
44226
44227 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44228 PyObject *resultobj = 0;
44229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44230 wxBitmap *arg2 = 0 ;
44231 void *argp1 = 0 ;
44232 int res1 = 0 ;
44233 void *argp2 = 0 ;
44234 int res2 = 0 ;
44235 PyObject * obj0 = 0 ;
44236 PyObject * obj1 = 0 ;
44237 char * kwnames[] = {
44238 (char *) "self",(char *) "bmpDisabled", NULL
44239 };
44240
44241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44243 if (!SWIG_IsOK(res1)) {
44244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44245 }
44246 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44248 if (!SWIG_IsOK(res2)) {
44249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44250 }
44251 if (!argp2) {
44252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44253 }
44254 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44258 wxPyEndAllowThreads(__tstate);
44259 if (PyErr_Occurred()) SWIG_fail;
44260 }
44261 resultobj = SWIG_Py_Void();
44262 return resultobj;
44263 fail:
44264 return NULL;
44265 }
44266
44267
44268 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44269 PyObject *resultobj = 0;
44270 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44271 wxBitmap *result = 0 ;
44272 void *argp1 = 0 ;
44273 int res1 = 0 ;
44274 PyObject *swig_obj[1] ;
44275
44276 if (!args) SWIG_fail;
44277 swig_obj[0] = args;
44278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44279 if (!SWIG_IsOK(res1)) {
44280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44281 }
44282 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 {
44286 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44287 result = (wxBitmap *) &_result_ref;
44288 }
44289 wxPyEndAllowThreads(__tstate);
44290 if (PyErr_Occurred()) SWIG_fail;
44291 }
44292 {
44293 wxBitmap* resultptr = new wxBitmap(*result);
44294 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44295 }
44296 return resultobj;
44297 fail:
44298 return NULL;
44299 }
44300
44301
44302 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44303 PyObject *resultobj = 0;
44304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44305 int arg2 ;
44306 void *argp1 = 0 ;
44307 int res1 = 0 ;
44308 int val2 ;
44309 int ecode2 = 0 ;
44310 PyObject * obj0 = 0 ;
44311 PyObject * obj1 = 0 ;
44312 char * kwnames[] = {
44313 (char *) "self",(char *) "nWidth", NULL
44314 };
44315
44316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44318 if (!SWIG_IsOK(res1)) {
44319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44320 }
44321 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44322 ecode2 = SWIG_AsVal_int(obj1, &val2);
44323 if (!SWIG_IsOK(ecode2)) {
44324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44325 }
44326 arg2 = static_cast< int >(val2);
44327 {
44328 PyThreadState* __tstate = wxPyBeginAllowThreads();
44329 wxMenuItem_SetMarginWidth(arg1,arg2);
44330 wxPyEndAllowThreads(__tstate);
44331 if (PyErr_Occurred()) SWIG_fail;
44332 }
44333 resultobj = SWIG_Py_Void();
44334 return resultobj;
44335 fail:
44336 return NULL;
44337 }
44338
44339
44340 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44341 PyObject *resultobj = 0;
44342 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44343 int result;
44344 void *argp1 = 0 ;
44345 int res1 = 0 ;
44346 PyObject *swig_obj[1] ;
44347
44348 if (!args) SWIG_fail;
44349 swig_obj[0] = args;
44350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44351 if (!SWIG_IsOK(res1)) {
44352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44353 }
44354 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 result = (int)wxMenuItem_GetMarginWidth(arg1);
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 resultobj = SWIG_From_int(static_cast< int >(result));
44362 return resultobj;
44363 fail:
44364 return NULL;
44365 }
44366
44367
44368 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44369 PyObject *resultobj = 0;
44370 int result;
44371
44372 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44373 {
44374 PyThreadState* __tstate = wxPyBeginAllowThreads();
44375 result = (int)wxMenuItem_GetDefaultMarginWidth();
44376 wxPyEndAllowThreads(__tstate);
44377 if (PyErr_Occurred()) SWIG_fail;
44378 }
44379 resultobj = SWIG_From_int(static_cast< int >(result));
44380 return resultobj;
44381 fail:
44382 return NULL;
44383 }
44384
44385
44386 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44387 PyObject *resultobj = 0;
44388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44389 bool result;
44390 void *argp1 = 0 ;
44391 int res1 = 0 ;
44392 PyObject *swig_obj[1] ;
44393
44394 if (!args) SWIG_fail;
44395 swig_obj[0] = args;
44396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44397 if (!SWIG_IsOK(res1)) {
44398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44399 }
44400 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44401 {
44402 PyThreadState* __tstate = wxPyBeginAllowThreads();
44403 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44404 wxPyEndAllowThreads(__tstate);
44405 if (PyErr_Occurred()) SWIG_fail;
44406 }
44407 {
44408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44409 }
44410 return resultobj;
44411 fail:
44412 return NULL;
44413 }
44414
44415
44416 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44417 PyObject *resultobj = 0;
44418 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44419 bool arg2 = (bool) true ;
44420 void *argp1 = 0 ;
44421 int res1 = 0 ;
44422 bool val2 ;
44423 int ecode2 = 0 ;
44424 PyObject * obj0 = 0 ;
44425 PyObject * obj1 = 0 ;
44426 char * kwnames[] = {
44427 (char *) "self",(char *) "ownerDrawn", NULL
44428 };
44429
44430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44432 if (!SWIG_IsOK(res1)) {
44433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44434 }
44435 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44436 if (obj1) {
44437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44438 if (!SWIG_IsOK(ecode2)) {
44439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44440 }
44441 arg2 = static_cast< bool >(val2);
44442 }
44443 {
44444 PyThreadState* __tstate = wxPyBeginAllowThreads();
44445 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44446 wxPyEndAllowThreads(__tstate);
44447 if (PyErr_Occurred()) SWIG_fail;
44448 }
44449 resultobj = SWIG_Py_Void();
44450 return resultobj;
44451 fail:
44452 return NULL;
44453 }
44454
44455
44456 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44457 PyObject *resultobj = 0;
44458 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44459 void *argp1 = 0 ;
44460 int res1 = 0 ;
44461 PyObject *swig_obj[1] ;
44462
44463 if (!args) SWIG_fail;
44464 swig_obj[0] = args;
44465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44466 if (!SWIG_IsOK(res1)) {
44467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44468 }
44469 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44470 {
44471 PyThreadState* __tstate = wxPyBeginAllowThreads();
44472 wxMenuItem_ResetOwnerDrawn(arg1);
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 resultobj = SWIG_Py_Void();
44477 return resultobj;
44478 fail:
44479 return NULL;
44480 }
44481
44482
44483 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44484 PyObject *obj;
44485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44486 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44487 return SWIG_Py_Void();
44488 }
44489
44490 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44491 return SWIG_Python_InitShadowInstance(args);
44492 }
44493
44494 SWIGINTERN int ControlNameStr_set(PyObject *) {
44495 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44496 return 1;
44497 }
44498
44499
44500 SWIGINTERN PyObject *ControlNameStr_get(void) {
44501 PyObject *pyobj = 0;
44502
44503 {
44504 #if wxUSE_UNICODE
44505 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44506 #else
44507 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44508 #endif
44509 }
44510 return pyobj;
44511 }
44512
44513
44514 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44515 PyObject *resultobj = 0;
44516 wxWindow *arg1 = (wxWindow *) 0 ;
44517 int arg2 = (int) -1 ;
44518 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44519 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44520 wxSize const &arg4_defvalue = wxDefaultSize ;
44521 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44522 long arg5 = (long) 0 ;
44523 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44524 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44525 wxString const &arg7_defvalue = wxPyControlNameStr ;
44526 wxString *arg7 = (wxString *) &arg7_defvalue ;
44527 wxControl *result = 0 ;
44528 void *argp1 = 0 ;
44529 int res1 = 0 ;
44530 int val2 ;
44531 int ecode2 = 0 ;
44532 wxPoint temp3 ;
44533 wxSize temp4 ;
44534 long val5 ;
44535 int ecode5 = 0 ;
44536 void *argp6 = 0 ;
44537 int res6 = 0 ;
44538 bool temp7 = false ;
44539 PyObject * obj0 = 0 ;
44540 PyObject * obj1 = 0 ;
44541 PyObject * obj2 = 0 ;
44542 PyObject * obj3 = 0 ;
44543 PyObject * obj4 = 0 ;
44544 PyObject * obj5 = 0 ;
44545 PyObject * obj6 = 0 ;
44546 char * kwnames[] = {
44547 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44548 };
44549
44550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44552 if (!SWIG_IsOK(res1)) {
44553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44554 }
44555 arg1 = reinterpret_cast< wxWindow * >(argp1);
44556 if (obj1) {
44557 ecode2 = SWIG_AsVal_int(obj1, &val2);
44558 if (!SWIG_IsOK(ecode2)) {
44559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44560 }
44561 arg2 = static_cast< int >(val2);
44562 }
44563 if (obj2) {
44564 {
44565 arg3 = &temp3;
44566 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44567 }
44568 }
44569 if (obj3) {
44570 {
44571 arg4 = &temp4;
44572 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44573 }
44574 }
44575 if (obj4) {
44576 ecode5 = SWIG_AsVal_long(obj4, &val5);
44577 if (!SWIG_IsOK(ecode5)) {
44578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44579 }
44580 arg5 = static_cast< long >(val5);
44581 }
44582 if (obj5) {
44583 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44584 if (!SWIG_IsOK(res6)) {
44585 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44586 }
44587 if (!argp6) {
44588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44589 }
44590 arg6 = reinterpret_cast< wxValidator * >(argp6);
44591 }
44592 if (obj6) {
44593 {
44594 arg7 = wxString_in_helper(obj6);
44595 if (arg7 == NULL) SWIG_fail;
44596 temp7 = true;
44597 }
44598 }
44599 {
44600 if (!wxPyCheckForApp()) SWIG_fail;
44601 PyThreadState* __tstate = wxPyBeginAllowThreads();
44602 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44603 wxPyEndAllowThreads(__tstate);
44604 if (PyErr_Occurred()) SWIG_fail;
44605 }
44606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44607 {
44608 if (temp7)
44609 delete arg7;
44610 }
44611 return resultobj;
44612 fail:
44613 {
44614 if (temp7)
44615 delete arg7;
44616 }
44617 return NULL;
44618 }
44619
44620
44621 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44622 PyObject *resultobj = 0;
44623 wxControl *result = 0 ;
44624
44625 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44626 {
44627 if (!wxPyCheckForApp()) SWIG_fail;
44628 PyThreadState* __tstate = wxPyBeginAllowThreads();
44629 result = (wxControl *)new wxControl();
44630 wxPyEndAllowThreads(__tstate);
44631 if (PyErr_Occurred()) SWIG_fail;
44632 }
44633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44634 return resultobj;
44635 fail:
44636 return NULL;
44637 }
44638
44639
44640 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44641 PyObject *resultobj = 0;
44642 wxControl *arg1 = (wxControl *) 0 ;
44643 wxWindow *arg2 = (wxWindow *) 0 ;
44644 int arg3 = (int) -1 ;
44645 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44646 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44647 wxSize const &arg5_defvalue = wxDefaultSize ;
44648 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44649 long arg6 = (long) 0 ;
44650 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44651 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44652 wxString const &arg8_defvalue = wxPyControlNameStr ;
44653 wxString *arg8 = (wxString *) &arg8_defvalue ;
44654 bool result;
44655 void *argp1 = 0 ;
44656 int res1 = 0 ;
44657 void *argp2 = 0 ;
44658 int res2 = 0 ;
44659 int val3 ;
44660 int ecode3 = 0 ;
44661 wxPoint temp4 ;
44662 wxSize temp5 ;
44663 long val6 ;
44664 int ecode6 = 0 ;
44665 void *argp7 = 0 ;
44666 int res7 = 0 ;
44667 bool temp8 = false ;
44668 PyObject * obj0 = 0 ;
44669 PyObject * obj1 = 0 ;
44670 PyObject * obj2 = 0 ;
44671 PyObject * obj3 = 0 ;
44672 PyObject * obj4 = 0 ;
44673 PyObject * obj5 = 0 ;
44674 PyObject * obj6 = 0 ;
44675 PyObject * obj7 = 0 ;
44676 char * kwnames[] = {
44677 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44678 };
44679
44680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44682 if (!SWIG_IsOK(res1)) {
44683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44684 }
44685 arg1 = reinterpret_cast< wxControl * >(argp1);
44686 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44687 if (!SWIG_IsOK(res2)) {
44688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44689 }
44690 arg2 = reinterpret_cast< wxWindow * >(argp2);
44691 if (obj2) {
44692 ecode3 = SWIG_AsVal_int(obj2, &val3);
44693 if (!SWIG_IsOK(ecode3)) {
44694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44695 }
44696 arg3 = static_cast< int >(val3);
44697 }
44698 if (obj3) {
44699 {
44700 arg4 = &temp4;
44701 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44702 }
44703 }
44704 if (obj4) {
44705 {
44706 arg5 = &temp5;
44707 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44708 }
44709 }
44710 if (obj5) {
44711 ecode6 = SWIG_AsVal_long(obj5, &val6);
44712 if (!SWIG_IsOK(ecode6)) {
44713 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44714 }
44715 arg6 = static_cast< long >(val6);
44716 }
44717 if (obj6) {
44718 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44719 if (!SWIG_IsOK(res7)) {
44720 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44721 }
44722 if (!argp7) {
44723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44724 }
44725 arg7 = reinterpret_cast< wxValidator * >(argp7);
44726 }
44727 if (obj7) {
44728 {
44729 arg8 = wxString_in_helper(obj7);
44730 if (arg8 == NULL) SWIG_fail;
44731 temp8 = true;
44732 }
44733 }
44734 {
44735 PyThreadState* __tstate = wxPyBeginAllowThreads();
44736 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44737 wxPyEndAllowThreads(__tstate);
44738 if (PyErr_Occurred()) SWIG_fail;
44739 }
44740 {
44741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44742 }
44743 {
44744 if (temp8)
44745 delete arg8;
44746 }
44747 return resultobj;
44748 fail:
44749 {
44750 if (temp8)
44751 delete arg8;
44752 }
44753 return NULL;
44754 }
44755
44756
44757 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44758 PyObject *resultobj = 0;
44759 wxControl *arg1 = (wxControl *) 0 ;
44760 int result;
44761 void *argp1 = 0 ;
44762 int res1 = 0 ;
44763 PyObject *swig_obj[1] ;
44764
44765 if (!args) SWIG_fail;
44766 swig_obj[0] = args;
44767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44768 if (!SWIG_IsOK(res1)) {
44769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44770 }
44771 arg1 = reinterpret_cast< wxControl * >(argp1);
44772 {
44773 PyThreadState* __tstate = wxPyBeginAllowThreads();
44774 result = (int)((wxControl const *)arg1)->GetAlignment();
44775 wxPyEndAllowThreads(__tstate);
44776 if (PyErr_Occurred()) SWIG_fail;
44777 }
44778 resultobj = SWIG_From_int(static_cast< int >(result));
44779 return resultobj;
44780 fail:
44781 return NULL;
44782 }
44783
44784
44785 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44786 PyObject *resultobj = 0;
44787 wxControl *arg1 = (wxControl *) 0 ;
44788 wxString result;
44789 void *argp1 = 0 ;
44790 int res1 = 0 ;
44791 PyObject *swig_obj[1] ;
44792
44793 if (!args) SWIG_fail;
44794 swig_obj[0] = args;
44795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44796 if (!SWIG_IsOK(res1)) {
44797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44798 }
44799 arg1 = reinterpret_cast< wxControl * >(argp1);
44800 {
44801 PyThreadState* __tstate = wxPyBeginAllowThreads();
44802 result = ((wxControl const *)arg1)->GetLabelText();
44803 wxPyEndAllowThreads(__tstate);
44804 if (PyErr_Occurred()) SWIG_fail;
44805 }
44806 {
44807 #if wxUSE_UNICODE
44808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44809 #else
44810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44811 #endif
44812 }
44813 return resultobj;
44814 fail:
44815 return NULL;
44816 }
44817
44818
44819 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44820 PyObject *resultobj = 0;
44821 wxControl *arg1 = (wxControl *) 0 ;
44822 wxCommandEvent *arg2 = 0 ;
44823 void *argp1 = 0 ;
44824 int res1 = 0 ;
44825 void *argp2 = 0 ;
44826 int res2 = 0 ;
44827 PyObject * obj0 = 0 ;
44828 PyObject * obj1 = 0 ;
44829 char * kwnames[] = {
44830 (char *) "self",(char *) "event", NULL
44831 };
44832
44833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44835 if (!SWIG_IsOK(res1)) {
44836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44837 }
44838 arg1 = reinterpret_cast< wxControl * >(argp1);
44839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44840 if (!SWIG_IsOK(res2)) {
44841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44842 }
44843 if (!argp2) {
44844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44845 }
44846 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44847 {
44848 PyThreadState* __tstate = wxPyBeginAllowThreads();
44849 (arg1)->Command(*arg2);
44850 wxPyEndAllowThreads(__tstate);
44851 if (PyErr_Occurred()) SWIG_fail;
44852 }
44853 resultobj = SWIG_Py_Void();
44854 return resultobj;
44855 fail:
44856 return NULL;
44857 }
44858
44859
44860 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44861 PyObject *resultobj = 0;
44862 wxControl *arg1 = (wxControl *) 0 ;
44863 wxString result;
44864 void *argp1 = 0 ;
44865 int res1 = 0 ;
44866 PyObject *swig_obj[1] ;
44867
44868 if (!args) SWIG_fail;
44869 swig_obj[0] = args;
44870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44871 if (!SWIG_IsOK(res1)) {
44872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44873 }
44874 arg1 = reinterpret_cast< wxControl * >(argp1);
44875 {
44876 PyThreadState* __tstate = wxPyBeginAllowThreads();
44877 result = (arg1)->GetLabel();
44878 wxPyEndAllowThreads(__tstate);
44879 if (PyErr_Occurred()) SWIG_fail;
44880 }
44881 {
44882 #if wxUSE_UNICODE
44883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44884 #else
44885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44886 #endif
44887 }
44888 return resultobj;
44889 fail:
44890 return NULL;
44891 }
44892
44893
44894 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44895 PyObject *resultobj = 0;
44896 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44897 SwigValueWrapper<wxVisualAttributes > result;
44898 int val1 ;
44899 int ecode1 = 0 ;
44900 PyObject * obj0 = 0 ;
44901 char * kwnames[] = {
44902 (char *) "variant", NULL
44903 };
44904
44905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44906 if (obj0) {
44907 ecode1 = SWIG_AsVal_int(obj0, &val1);
44908 if (!SWIG_IsOK(ecode1)) {
44909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44910 }
44911 arg1 = static_cast< wxWindowVariant >(val1);
44912 }
44913 {
44914 if (!wxPyCheckForApp()) SWIG_fail;
44915 PyThreadState* __tstate = wxPyBeginAllowThreads();
44916 result = wxControl::GetClassDefaultAttributes(arg1);
44917 wxPyEndAllowThreads(__tstate);
44918 if (PyErr_Occurred()) SWIG_fail;
44919 }
44920 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44921 return resultobj;
44922 fail:
44923 return NULL;
44924 }
44925
44926
44927 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44928 PyObject *obj;
44929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44930 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44931 return SWIG_Py_Void();
44932 }
44933
44934 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44935 return SWIG_Python_InitShadowInstance(args);
44936 }
44937
44938 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44939 PyObject *resultobj = 0;
44940 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44941 wxString *arg2 = 0 ;
44942 PyObject *arg3 = (PyObject *) NULL ;
44943 int result;
44944 void *argp1 = 0 ;
44945 int res1 = 0 ;
44946 bool temp2 = false ;
44947 PyObject * obj0 = 0 ;
44948 PyObject * obj1 = 0 ;
44949 PyObject * obj2 = 0 ;
44950 char * kwnames[] = {
44951 (char *) "self",(char *) "item",(char *) "clientData", NULL
44952 };
44953
44954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44956 if (!SWIG_IsOK(res1)) {
44957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44958 }
44959 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44960 {
44961 arg2 = wxString_in_helper(obj1);
44962 if (arg2 == NULL) SWIG_fail;
44963 temp2 = true;
44964 }
44965 if (obj2) {
44966 arg3 = obj2;
44967 }
44968 {
44969 PyThreadState* __tstate = wxPyBeginAllowThreads();
44970 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44971 wxPyEndAllowThreads(__tstate);
44972 if (PyErr_Occurred()) SWIG_fail;
44973 }
44974 resultobj = SWIG_From_int(static_cast< int >(result));
44975 {
44976 if (temp2)
44977 delete arg2;
44978 }
44979 return resultobj;
44980 fail:
44981 {
44982 if (temp2)
44983 delete arg2;
44984 }
44985 return NULL;
44986 }
44987
44988
44989 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44990 PyObject *resultobj = 0;
44991 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44992 wxArrayString *arg2 = 0 ;
44993 void *argp1 = 0 ;
44994 int res1 = 0 ;
44995 bool temp2 = false ;
44996 PyObject * obj0 = 0 ;
44997 PyObject * obj1 = 0 ;
44998 char * kwnames[] = {
44999 (char *) "self",(char *) "strings", NULL
45000 };
45001
45002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45004 if (!SWIG_IsOK(res1)) {
45005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45006 }
45007 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45008 {
45009 if (! PySequence_Check(obj1)) {
45010 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45011 SWIG_fail;
45012 }
45013 arg2 = new wxArrayString;
45014 temp2 = true;
45015 int i, len=PySequence_Length(obj1);
45016 for (i=0; i<len; i++) {
45017 PyObject* item = PySequence_GetItem(obj1, i);
45018 wxString* s = wxString_in_helper(item);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 arg2->Add(*s);
45021 delete s;
45022 Py_DECREF(item);
45023 }
45024 }
45025 {
45026 PyThreadState* __tstate = wxPyBeginAllowThreads();
45027 (arg1)->Append((wxArrayString const &)*arg2);
45028 wxPyEndAllowThreads(__tstate);
45029 if (PyErr_Occurred()) SWIG_fail;
45030 }
45031 resultobj = SWIG_Py_Void();
45032 {
45033 if (temp2) delete arg2;
45034 }
45035 return resultobj;
45036 fail:
45037 {
45038 if (temp2) delete arg2;
45039 }
45040 return NULL;
45041 }
45042
45043
45044 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45045 PyObject *resultobj = 0;
45046 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45047 wxString *arg2 = 0 ;
45048 unsigned int arg3 ;
45049 PyObject *arg4 = (PyObject *) NULL ;
45050 int result;
45051 void *argp1 = 0 ;
45052 int res1 = 0 ;
45053 bool temp2 = false ;
45054 unsigned int val3 ;
45055 int ecode3 = 0 ;
45056 PyObject * obj0 = 0 ;
45057 PyObject * obj1 = 0 ;
45058 PyObject * obj2 = 0 ;
45059 PyObject * obj3 = 0 ;
45060 char * kwnames[] = {
45061 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45062 };
45063
45064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45066 if (!SWIG_IsOK(res1)) {
45067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45068 }
45069 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45070 {
45071 arg2 = wxString_in_helper(obj1);
45072 if (arg2 == NULL) SWIG_fail;
45073 temp2 = true;
45074 }
45075 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45076 if (!SWIG_IsOK(ecode3)) {
45077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45078 }
45079 arg3 = static_cast< unsigned int >(val3);
45080 if (obj3) {
45081 arg4 = obj3;
45082 }
45083 {
45084 PyThreadState* __tstate = wxPyBeginAllowThreads();
45085 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45086 wxPyEndAllowThreads(__tstate);
45087 if (PyErr_Occurred()) SWIG_fail;
45088 }
45089 resultobj = SWIG_From_int(static_cast< int >(result));
45090 {
45091 if (temp2)
45092 delete arg2;
45093 }
45094 return resultobj;
45095 fail:
45096 {
45097 if (temp2)
45098 delete arg2;
45099 }
45100 return NULL;
45101 }
45102
45103
45104 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45105 PyObject *resultobj = 0;
45106 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45107 void *argp1 = 0 ;
45108 int res1 = 0 ;
45109 PyObject *swig_obj[1] ;
45110
45111 if (!args) SWIG_fail;
45112 swig_obj[0] = args;
45113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45114 if (!SWIG_IsOK(res1)) {
45115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45116 }
45117 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45118 {
45119 PyThreadState* __tstate = wxPyBeginAllowThreads();
45120 (arg1)->Clear();
45121 wxPyEndAllowThreads(__tstate);
45122 if (PyErr_Occurred()) SWIG_fail;
45123 }
45124 resultobj = SWIG_Py_Void();
45125 return resultobj;
45126 fail:
45127 return NULL;
45128 }
45129
45130
45131 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45132 PyObject *resultobj = 0;
45133 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45134 unsigned int arg2 ;
45135 void *argp1 = 0 ;
45136 int res1 = 0 ;
45137 unsigned int val2 ;
45138 int ecode2 = 0 ;
45139 PyObject * obj0 = 0 ;
45140 PyObject * obj1 = 0 ;
45141 char * kwnames[] = {
45142 (char *) "self",(char *) "n", NULL
45143 };
45144
45145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45147 if (!SWIG_IsOK(res1)) {
45148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45149 }
45150 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45151 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45152 if (!SWIG_IsOK(ecode2)) {
45153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45154 }
45155 arg2 = static_cast< unsigned int >(val2);
45156 {
45157 PyThreadState* __tstate = wxPyBeginAllowThreads();
45158 (arg1)->Delete(arg2);
45159 wxPyEndAllowThreads(__tstate);
45160 if (PyErr_Occurred()) SWIG_fail;
45161 }
45162 resultobj = SWIG_Py_Void();
45163 return resultobj;
45164 fail:
45165 return NULL;
45166 }
45167
45168
45169 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45170 PyObject *resultobj = 0;
45171 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45172 unsigned int arg2 ;
45173 PyObject *result = 0 ;
45174 void *argp1 = 0 ;
45175 int res1 = 0 ;
45176 unsigned int val2 ;
45177 int ecode2 = 0 ;
45178 PyObject * obj0 = 0 ;
45179 PyObject * obj1 = 0 ;
45180 char * kwnames[] = {
45181 (char *) "self",(char *) "n", NULL
45182 };
45183
45184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45186 if (!SWIG_IsOK(res1)) {
45187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45188 }
45189 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45190 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45191 if (!SWIG_IsOK(ecode2)) {
45192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45193 }
45194 arg2 = static_cast< unsigned int >(val2);
45195 {
45196 PyThreadState* __tstate = wxPyBeginAllowThreads();
45197 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45198 wxPyEndAllowThreads(__tstate);
45199 if (PyErr_Occurred()) SWIG_fail;
45200 }
45201 resultobj = result;
45202 return resultobj;
45203 fail:
45204 return NULL;
45205 }
45206
45207
45208 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45209 PyObject *resultobj = 0;
45210 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45211 unsigned int arg2 ;
45212 PyObject *arg3 = (PyObject *) 0 ;
45213 void *argp1 = 0 ;
45214 int res1 = 0 ;
45215 unsigned int val2 ;
45216 int ecode2 = 0 ;
45217 PyObject * obj0 = 0 ;
45218 PyObject * obj1 = 0 ;
45219 PyObject * obj2 = 0 ;
45220 char * kwnames[] = {
45221 (char *) "self",(char *) "n",(char *) "clientData", NULL
45222 };
45223
45224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45226 if (!SWIG_IsOK(res1)) {
45227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45228 }
45229 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45230 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45231 if (!SWIG_IsOK(ecode2)) {
45232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45233 }
45234 arg2 = static_cast< unsigned int >(val2);
45235 arg3 = obj2;
45236 {
45237 PyThreadState* __tstate = wxPyBeginAllowThreads();
45238 wxItemContainer_SetClientData(arg1,arg2,arg3);
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 resultobj = SWIG_Py_Void();
45243 return resultobj;
45244 fail:
45245 return NULL;
45246 }
45247
45248
45249 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45250 PyObject *resultobj = 0;
45251 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45252 unsigned int result;
45253 void *argp1 = 0 ;
45254 int res1 = 0 ;
45255 PyObject *swig_obj[1] ;
45256
45257 if (!args) SWIG_fail;
45258 swig_obj[0] = args;
45259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45260 if (!SWIG_IsOK(res1)) {
45261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45262 }
45263 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45264 {
45265 PyThreadState* __tstate = wxPyBeginAllowThreads();
45266 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45267 wxPyEndAllowThreads(__tstate);
45268 if (PyErr_Occurred()) SWIG_fail;
45269 }
45270 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45271 return resultobj;
45272 fail:
45273 return NULL;
45274 }
45275
45276
45277 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45278 PyObject *resultobj = 0;
45279 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45280 bool result;
45281 void *argp1 = 0 ;
45282 int res1 = 0 ;
45283 PyObject *swig_obj[1] ;
45284
45285 if (!args) SWIG_fail;
45286 swig_obj[0] = args;
45287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45288 if (!SWIG_IsOK(res1)) {
45289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45290 }
45291 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45292 {
45293 PyThreadState* __tstate = wxPyBeginAllowThreads();
45294 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45295 wxPyEndAllowThreads(__tstate);
45296 if (PyErr_Occurred()) SWIG_fail;
45297 }
45298 {
45299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45300 }
45301 return resultobj;
45302 fail:
45303 return NULL;
45304 }
45305
45306
45307 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45308 PyObject *resultobj = 0;
45309 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45310 unsigned int arg2 ;
45311 wxString result;
45312 void *argp1 = 0 ;
45313 int res1 = 0 ;
45314 unsigned int val2 ;
45315 int ecode2 = 0 ;
45316 PyObject * obj0 = 0 ;
45317 PyObject * obj1 = 0 ;
45318 char * kwnames[] = {
45319 (char *) "self",(char *) "n", NULL
45320 };
45321
45322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45326 }
45327 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45328 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45329 if (!SWIG_IsOK(ecode2)) {
45330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45331 }
45332 arg2 = static_cast< unsigned int >(val2);
45333 {
45334 PyThreadState* __tstate = wxPyBeginAllowThreads();
45335 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 {
45340 #if wxUSE_UNICODE
45341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45342 #else
45343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45344 #endif
45345 }
45346 return resultobj;
45347 fail:
45348 return NULL;
45349 }
45350
45351
45352 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45353 PyObject *resultobj = 0;
45354 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45355 wxArrayString result;
45356 void *argp1 = 0 ;
45357 int res1 = 0 ;
45358 PyObject *swig_obj[1] ;
45359
45360 if (!args) SWIG_fail;
45361 swig_obj[0] = args;
45362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45363 if (!SWIG_IsOK(res1)) {
45364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45365 }
45366 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45367 {
45368 PyThreadState* __tstate = wxPyBeginAllowThreads();
45369 result = ((wxItemContainer const *)arg1)->GetStrings();
45370 wxPyEndAllowThreads(__tstate);
45371 if (PyErr_Occurred()) SWIG_fail;
45372 }
45373 {
45374 resultobj = wxArrayString2PyList_helper(result);
45375 }
45376 return resultobj;
45377 fail:
45378 return NULL;
45379 }
45380
45381
45382 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45383 PyObject *resultobj = 0;
45384 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45385 unsigned int arg2 ;
45386 wxString *arg3 = 0 ;
45387 void *argp1 = 0 ;
45388 int res1 = 0 ;
45389 unsigned int val2 ;
45390 int ecode2 = 0 ;
45391 bool temp3 = false ;
45392 PyObject * obj0 = 0 ;
45393 PyObject * obj1 = 0 ;
45394 PyObject * obj2 = 0 ;
45395 char * kwnames[] = {
45396 (char *) "self",(char *) "n",(char *) "s", NULL
45397 };
45398
45399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45401 if (!SWIG_IsOK(res1)) {
45402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45403 }
45404 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45405 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45406 if (!SWIG_IsOK(ecode2)) {
45407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45408 }
45409 arg2 = static_cast< unsigned int >(val2);
45410 {
45411 arg3 = wxString_in_helper(obj2);
45412 if (arg3 == NULL) SWIG_fail;
45413 temp3 = true;
45414 }
45415 {
45416 PyThreadState* __tstate = wxPyBeginAllowThreads();
45417 (arg1)->SetString(arg2,(wxString const &)*arg3);
45418 wxPyEndAllowThreads(__tstate);
45419 if (PyErr_Occurred()) SWIG_fail;
45420 }
45421 resultobj = SWIG_Py_Void();
45422 {
45423 if (temp3)
45424 delete arg3;
45425 }
45426 return resultobj;
45427 fail:
45428 {
45429 if (temp3)
45430 delete arg3;
45431 }
45432 return NULL;
45433 }
45434
45435
45436 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45437 PyObject *resultobj = 0;
45438 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45439 wxString *arg2 = 0 ;
45440 int result;
45441 void *argp1 = 0 ;
45442 int res1 = 0 ;
45443 bool temp2 = false ;
45444 PyObject * obj0 = 0 ;
45445 PyObject * obj1 = 0 ;
45446 char * kwnames[] = {
45447 (char *) "self",(char *) "s", NULL
45448 };
45449
45450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45452 if (!SWIG_IsOK(res1)) {
45453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45454 }
45455 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45456 {
45457 arg2 = wxString_in_helper(obj1);
45458 if (arg2 == NULL) SWIG_fail;
45459 temp2 = true;
45460 }
45461 {
45462 PyThreadState* __tstate = wxPyBeginAllowThreads();
45463 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45464 wxPyEndAllowThreads(__tstate);
45465 if (PyErr_Occurred()) SWIG_fail;
45466 }
45467 resultobj = SWIG_From_int(static_cast< int >(result));
45468 {
45469 if (temp2)
45470 delete arg2;
45471 }
45472 return resultobj;
45473 fail:
45474 {
45475 if (temp2)
45476 delete arg2;
45477 }
45478 return NULL;
45479 }
45480
45481
45482 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45483 PyObject *resultobj = 0;
45484 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45485 int arg2 ;
45486 void *argp1 = 0 ;
45487 int res1 = 0 ;
45488 int val2 ;
45489 int ecode2 = 0 ;
45490 PyObject * obj0 = 0 ;
45491 PyObject * obj1 = 0 ;
45492 char * kwnames[] = {
45493 (char *) "self",(char *) "n", NULL
45494 };
45495
45496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45498 if (!SWIG_IsOK(res1)) {
45499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45500 }
45501 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45502 ecode2 = SWIG_AsVal_int(obj1, &val2);
45503 if (!SWIG_IsOK(ecode2)) {
45504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45505 }
45506 arg2 = static_cast< int >(val2);
45507 {
45508 PyThreadState* __tstate = wxPyBeginAllowThreads();
45509 (arg1)->SetSelection(arg2);
45510 wxPyEndAllowThreads(__tstate);
45511 if (PyErr_Occurred()) SWIG_fail;
45512 }
45513 resultobj = SWIG_Py_Void();
45514 return resultobj;
45515 fail:
45516 return NULL;
45517 }
45518
45519
45520 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45521 PyObject *resultobj = 0;
45522 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45523 int result;
45524 void *argp1 = 0 ;
45525 int res1 = 0 ;
45526 PyObject *swig_obj[1] ;
45527
45528 if (!args) SWIG_fail;
45529 swig_obj[0] = args;
45530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45531 if (!SWIG_IsOK(res1)) {
45532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45533 }
45534 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45535 {
45536 PyThreadState* __tstate = wxPyBeginAllowThreads();
45537 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45538 wxPyEndAllowThreads(__tstate);
45539 if (PyErr_Occurred()) SWIG_fail;
45540 }
45541 resultobj = SWIG_From_int(static_cast< int >(result));
45542 return resultobj;
45543 fail:
45544 return NULL;
45545 }
45546
45547
45548 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45549 PyObject *resultobj = 0;
45550 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45551 wxString *arg2 = 0 ;
45552 bool result;
45553 void *argp1 = 0 ;
45554 int res1 = 0 ;
45555 bool temp2 = false ;
45556 PyObject * obj0 = 0 ;
45557 PyObject * obj1 = 0 ;
45558 char * kwnames[] = {
45559 (char *) "self",(char *) "s", NULL
45560 };
45561
45562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45564 if (!SWIG_IsOK(res1)) {
45565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45566 }
45567 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45568 {
45569 arg2 = wxString_in_helper(obj1);
45570 if (arg2 == NULL) SWIG_fail;
45571 temp2 = true;
45572 }
45573 {
45574 PyThreadState* __tstate = wxPyBeginAllowThreads();
45575 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45576 wxPyEndAllowThreads(__tstate);
45577 if (PyErr_Occurred()) SWIG_fail;
45578 }
45579 {
45580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45581 }
45582 {
45583 if (temp2)
45584 delete arg2;
45585 }
45586 return resultobj;
45587 fail:
45588 {
45589 if (temp2)
45590 delete arg2;
45591 }
45592 return NULL;
45593 }
45594
45595
45596 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45597 PyObject *resultobj = 0;
45598 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45599 wxString result;
45600 void *argp1 = 0 ;
45601 int res1 = 0 ;
45602 PyObject *swig_obj[1] ;
45603
45604 if (!args) SWIG_fail;
45605 swig_obj[0] = args;
45606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45607 if (!SWIG_IsOK(res1)) {
45608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45609 }
45610 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45611 {
45612 PyThreadState* __tstate = wxPyBeginAllowThreads();
45613 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45614 wxPyEndAllowThreads(__tstate);
45615 if (PyErr_Occurred()) SWIG_fail;
45616 }
45617 {
45618 #if wxUSE_UNICODE
45619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45620 #else
45621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45622 #endif
45623 }
45624 return resultobj;
45625 fail:
45626 return NULL;
45627 }
45628
45629
45630 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45631 PyObject *resultobj = 0;
45632 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45633 int arg2 ;
45634 void *argp1 = 0 ;
45635 int res1 = 0 ;
45636 int val2 ;
45637 int ecode2 = 0 ;
45638 PyObject * obj0 = 0 ;
45639 PyObject * obj1 = 0 ;
45640 char * kwnames[] = {
45641 (char *) "self",(char *) "n", NULL
45642 };
45643
45644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45646 if (!SWIG_IsOK(res1)) {
45647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45648 }
45649 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45650 ecode2 = SWIG_AsVal_int(obj1, &val2);
45651 if (!SWIG_IsOK(ecode2)) {
45652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45653 }
45654 arg2 = static_cast< int >(val2);
45655 {
45656 PyThreadState* __tstate = wxPyBeginAllowThreads();
45657 (arg1)->Select(arg2);
45658 wxPyEndAllowThreads(__tstate);
45659 if (PyErr_Occurred()) SWIG_fail;
45660 }
45661 resultobj = SWIG_Py_Void();
45662 return resultobj;
45663 fail:
45664 return NULL;
45665 }
45666
45667
45668 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45669 PyObject *obj;
45670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45671 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45672 return SWIG_Py_Void();
45673 }
45674
45675 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45676 PyObject *obj;
45677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45678 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45679 return SWIG_Py_Void();
45680 }
45681
45682 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45683 PyObject *resultobj = 0;
45684 wxSizerItem *result = 0 ;
45685
45686 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45687 {
45688 PyThreadState* __tstate = wxPyBeginAllowThreads();
45689 result = (wxSizerItem *)new wxSizerItem();
45690 wxPyEndAllowThreads(__tstate);
45691 if (PyErr_Occurred()) SWIG_fail;
45692 }
45693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45694 return resultobj;
45695 fail:
45696 return NULL;
45697 }
45698
45699
45700 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45701 PyObject *resultobj = 0;
45702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45703 void *argp1 = 0 ;
45704 int res1 = 0 ;
45705 PyObject *swig_obj[1] ;
45706
45707 if (!args) SWIG_fail;
45708 swig_obj[0] = args;
45709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45710 if (!SWIG_IsOK(res1)) {
45711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45712 }
45713 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45714 {
45715 PyThreadState* __tstate = wxPyBeginAllowThreads();
45716 delete arg1;
45717
45718 wxPyEndAllowThreads(__tstate);
45719 if (PyErr_Occurred()) SWIG_fail;
45720 }
45721 resultobj = SWIG_Py_Void();
45722 return resultobj;
45723 fail:
45724 return NULL;
45725 }
45726
45727
45728 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45729 PyObject *resultobj = 0;
45730 wxWindow *arg1 = (wxWindow *) 0 ;
45731 int arg2 ;
45732 int arg3 ;
45733 int arg4 ;
45734 PyObject *arg5 = (PyObject *) NULL ;
45735 wxSizerItem *result = 0 ;
45736 void *argp1 = 0 ;
45737 int res1 = 0 ;
45738 int val2 ;
45739 int ecode2 = 0 ;
45740 int val3 ;
45741 int ecode3 = 0 ;
45742 int val4 ;
45743 int ecode4 = 0 ;
45744 PyObject * obj0 = 0 ;
45745 PyObject * obj1 = 0 ;
45746 PyObject * obj2 = 0 ;
45747 PyObject * obj3 = 0 ;
45748 PyObject * obj4 = 0 ;
45749 char * kwnames[] = {
45750 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45751 };
45752
45753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45755 if (!SWIG_IsOK(res1)) {
45756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45757 }
45758 arg1 = reinterpret_cast< wxWindow * >(argp1);
45759 ecode2 = SWIG_AsVal_int(obj1, &val2);
45760 if (!SWIG_IsOK(ecode2)) {
45761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45762 }
45763 arg2 = static_cast< int >(val2);
45764 ecode3 = SWIG_AsVal_int(obj2, &val3);
45765 if (!SWIG_IsOK(ecode3)) {
45766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45767 }
45768 arg3 = static_cast< int >(val3);
45769 ecode4 = SWIG_AsVal_int(obj3, &val4);
45770 if (!SWIG_IsOK(ecode4)) {
45771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45772 }
45773 arg4 = static_cast< int >(val4);
45774 if (obj4) {
45775 arg5 = obj4;
45776 }
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45784 return resultobj;
45785 fail:
45786 return NULL;
45787 }
45788
45789
45790 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45791 PyObject *resultobj = 0;
45792 int arg1 ;
45793 int arg2 ;
45794 int arg3 ;
45795 int arg4 ;
45796 int arg5 ;
45797 PyObject *arg6 = (PyObject *) NULL ;
45798 wxSizerItem *result = 0 ;
45799 int val1 ;
45800 int ecode1 = 0 ;
45801 int val2 ;
45802 int ecode2 = 0 ;
45803 int val3 ;
45804 int ecode3 = 0 ;
45805 int val4 ;
45806 int ecode4 = 0 ;
45807 int val5 ;
45808 int ecode5 = 0 ;
45809 PyObject * obj0 = 0 ;
45810 PyObject * obj1 = 0 ;
45811 PyObject * obj2 = 0 ;
45812 PyObject * obj3 = 0 ;
45813 PyObject * obj4 = 0 ;
45814 PyObject * obj5 = 0 ;
45815 char * kwnames[] = {
45816 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45817 };
45818
45819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45820 ecode1 = SWIG_AsVal_int(obj0, &val1);
45821 if (!SWIG_IsOK(ecode1)) {
45822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45823 }
45824 arg1 = static_cast< int >(val1);
45825 ecode2 = SWIG_AsVal_int(obj1, &val2);
45826 if (!SWIG_IsOK(ecode2)) {
45827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45828 }
45829 arg2 = static_cast< int >(val2);
45830 ecode3 = SWIG_AsVal_int(obj2, &val3);
45831 if (!SWIG_IsOK(ecode3)) {
45832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45833 }
45834 arg3 = static_cast< int >(val3);
45835 ecode4 = SWIG_AsVal_int(obj3, &val4);
45836 if (!SWIG_IsOK(ecode4)) {
45837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45838 }
45839 arg4 = static_cast< int >(val4);
45840 ecode5 = SWIG_AsVal_int(obj4, &val5);
45841 if (!SWIG_IsOK(ecode5)) {
45842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45843 }
45844 arg5 = static_cast< int >(val5);
45845 if (obj5) {
45846 arg6 = obj5;
45847 }
45848 {
45849 PyThreadState* __tstate = wxPyBeginAllowThreads();
45850 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45851 wxPyEndAllowThreads(__tstate);
45852 if (PyErr_Occurred()) SWIG_fail;
45853 }
45854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45855 return resultobj;
45856 fail:
45857 return NULL;
45858 }
45859
45860
45861 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45862 PyObject *resultobj = 0;
45863 wxSizer *arg1 = (wxSizer *) 0 ;
45864 int arg2 ;
45865 int arg3 ;
45866 int arg4 ;
45867 PyObject *arg5 = (PyObject *) NULL ;
45868 wxSizerItem *result = 0 ;
45869 int res1 = 0 ;
45870 int val2 ;
45871 int ecode2 = 0 ;
45872 int val3 ;
45873 int ecode3 = 0 ;
45874 int val4 ;
45875 int ecode4 = 0 ;
45876 PyObject * obj0 = 0 ;
45877 PyObject * obj1 = 0 ;
45878 PyObject * obj2 = 0 ;
45879 PyObject * obj3 = 0 ;
45880 PyObject * obj4 = 0 ;
45881 char * kwnames[] = {
45882 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45883 };
45884
45885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45886 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45887 if (!SWIG_IsOK(res1)) {
45888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45889 }
45890 ecode2 = SWIG_AsVal_int(obj1, &val2);
45891 if (!SWIG_IsOK(ecode2)) {
45892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45893 }
45894 arg2 = static_cast< int >(val2);
45895 ecode3 = SWIG_AsVal_int(obj2, &val3);
45896 if (!SWIG_IsOK(ecode3)) {
45897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45898 }
45899 arg3 = static_cast< int >(val3);
45900 ecode4 = SWIG_AsVal_int(obj3, &val4);
45901 if (!SWIG_IsOK(ecode4)) {
45902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45903 }
45904 arg4 = static_cast< int >(val4);
45905 if (obj4) {
45906 arg5 = obj4;
45907 }
45908 {
45909 PyThreadState* __tstate = wxPyBeginAllowThreads();
45910 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45915 return resultobj;
45916 fail:
45917 return NULL;
45918 }
45919
45920
45921 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45922 PyObject *resultobj = 0;
45923 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45924 void *argp1 = 0 ;
45925 int res1 = 0 ;
45926 PyObject *swig_obj[1] ;
45927
45928 if (!args) SWIG_fail;
45929 swig_obj[0] = args;
45930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45931 if (!SWIG_IsOK(res1)) {
45932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45933 }
45934 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45935 {
45936 PyThreadState* __tstate = wxPyBeginAllowThreads();
45937 (arg1)->DeleteWindows();
45938 wxPyEndAllowThreads(__tstate);
45939 if (PyErr_Occurred()) SWIG_fail;
45940 }
45941 resultobj = SWIG_Py_Void();
45942 return resultobj;
45943 fail:
45944 return NULL;
45945 }
45946
45947
45948 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45949 PyObject *resultobj = 0;
45950 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45951 void *argp1 = 0 ;
45952 int res1 = 0 ;
45953 PyObject *swig_obj[1] ;
45954
45955 if (!args) SWIG_fail;
45956 swig_obj[0] = args;
45957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45958 if (!SWIG_IsOK(res1)) {
45959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45960 }
45961 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45962 {
45963 PyThreadState* __tstate = wxPyBeginAllowThreads();
45964 (arg1)->DetachSizer();
45965 wxPyEndAllowThreads(__tstate);
45966 if (PyErr_Occurred()) SWIG_fail;
45967 }
45968 resultobj = SWIG_Py_Void();
45969 return resultobj;
45970 fail:
45971 return NULL;
45972 }
45973
45974
45975 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45976 PyObject *resultobj = 0;
45977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45978 wxSize result;
45979 void *argp1 = 0 ;
45980 int res1 = 0 ;
45981 PyObject *swig_obj[1] ;
45982
45983 if (!args) SWIG_fail;
45984 swig_obj[0] = args;
45985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45986 if (!SWIG_IsOK(res1)) {
45987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45988 }
45989 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45990 {
45991 PyThreadState* __tstate = wxPyBeginAllowThreads();
45992 result = (arg1)->GetSize();
45993 wxPyEndAllowThreads(__tstate);
45994 if (PyErr_Occurred()) SWIG_fail;
45995 }
45996 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45997 return resultobj;
45998 fail:
45999 return NULL;
46000 }
46001
46002
46003 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46004 PyObject *resultobj = 0;
46005 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46006 wxSize result;
46007 void *argp1 = 0 ;
46008 int res1 = 0 ;
46009 PyObject *swig_obj[1] ;
46010
46011 if (!args) SWIG_fail;
46012 swig_obj[0] = args;
46013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46014 if (!SWIG_IsOK(res1)) {
46015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46016 }
46017 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46018 {
46019 PyThreadState* __tstate = wxPyBeginAllowThreads();
46020 result = (arg1)->CalcMin();
46021 wxPyEndAllowThreads(__tstate);
46022 if (PyErr_Occurred()) SWIG_fail;
46023 }
46024 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46025 return resultobj;
46026 fail:
46027 return NULL;
46028 }
46029
46030
46031 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46032 PyObject *resultobj = 0;
46033 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46034 wxPoint *arg2 = 0 ;
46035 wxSize *arg3 = 0 ;
46036 void *argp1 = 0 ;
46037 int res1 = 0 ;
46038 wxPoint temp2 ;
46039 wxSize temp3 ;
46040 PyObject * obj0 = 0 ;
46041 PyObject * obj1 = 0 ;
46042 PyObject * obj2 = 0 ;
46043 char * kwnames[] = {
46044 (char *) "self",(char *) "pos",(char *) "size", NULL
46045 };
46046
46047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46049 if (!SWIG_IsOK(res1)) {
46050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46051 }
46052 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46053 {
46054 arg2 = &temp2;
46055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46056 }
46057 {
46058 arg3 = &temp3;
46059 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46060 }
46061 {
46062 PyThreadState* __tstate = wxPyBeginAllowThreads();
46063 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46064 wxPyEndAllowThreads(__tstate);
46065 if (PyErr_Occurred()) SWIG_fail;
46066 }
46067 resultobj = SWIG_Py_Void();
46068 return resultobj;
46069 fail:
46070 return NULL;
46071 }
46072
46073
46074 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46075 PyObject *resultobj = 0;
46076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46077 wxSize result;
46078 void *argp1 = 0 ;
46079 int res1 = 0 ;
46080 PyObject *swig_obj[1] ;
46081
46082 if (!args) SWIG_fail;
46083 swig_obj[0] = args;
46084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46085 if (!SWIG_IsOK(res1)) {
46086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46087 }
46088 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46089 {
46090 PyThreadState* __tstate = wxPyBeginAllowThreads();
46091 result = (arg1)->GetMinSize();
46092 wxPyEndAllowThreads(__tstate);
46093 if (PyErr_Occurred()) SWIG_fail;
46094 }
46095 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46096 return resultobj;
46097 fail:
46098 return NULL;
46099 }
46100
46101
46102 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46103 PyObject *resultobj = 0;
46104 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46105 wxSize result;
46106 void *argp1 = 0 ;
46107 int res1 = 0 ;
46108 PyObject *swig_obj[1] ;
46109
46110 if (!args) SWIG_fail;
46111 swig_obj[0] = args;
46112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46113 if (!SWIG_IsOK(res1)) {
46114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46115 }
46116 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46117 {
46118 PyThreadState* __tstate = wxPyBeginAllowThreads();
46119 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46120 wxPyEndAllowThreads(__tstate);
46121 if (PyErr_Occurred()) SWIG_fail;
46122 }
46123 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46124 return resultobj;
46125 fail:
46126 return NULL;
46127 }
46128
46129
46130 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46131 PyObject *resultobj = 0;
46132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46133 int arg2 ;
46134 int arg3 ;
46135 void *argp1 = 0 ;
46136 int res1 = 0 ;
46137 int val2 ;
46138 int ecode2 = 0 ;
46139 int val3 ;
46140 int ecode3 = 0 ;
46141 PyObject * obj0 = 0 ;
46142 PyObject * obj1 = 0 ;
46143 PyObject * obj2 = 0 ;
46144 char * kwnames[] = {
46145 (char *) "self",(char *) "x",(char *) "y", NULL
46146 };
46147
46148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46150 if (!SWIG_IsOK(res1)) {
46151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46152 }
46153 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46154 ecode2 = SWIG_AsVal_int(obj1, &val2);
46155 if (!SWIG_IsOK(ecode2)) {
46156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46157 }
46158 arg2 = static_cast< int >(val2);
46159 ecode3 = SWIG_AsVal_int(obj2, &val3);
46160 if (!SWIG_IsOK(ecode3)) {
46161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46162 }
46163 arg3 = static_cast< int >(val3);
46164 {
46165 PyThreadState* __tstate = wxPyBeginAllowThreads();
46166 (arg1)->SetInitSize(arg2,arg3);
46167 wxPyEndAllowThreads(__tstate);
46168 if (PyErr_Occurred()) SWIG_fail;
46169 }
46170 resultobj = SWIG_Py_Void();
46171 return resultobj;
46172 fail:
46173 return NULL;
46174 }
46175
46176
46177 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46178 PyObject *resultobj = 0;
46179 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46180 int arg2 ;
46181 int arg3 ;
46182 void *argp1 = 0 ;
46183 int res1 = 0 ;
46184 int val2 ;
46185 int ecode2 = 0 ;
46186 int val3 ;
46187 int ecode3 = 0 ;
46188 PyObject * obj0 = 0 ;
46189 PyObject * obj1 = 0 ;
46190 PyObject * obj2 = 0 ;
46191 char * kwnames[] = {
46192 (char *) "self",(char *) "width",(char *) "height", NULL
46193 };
46194
46195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46197 if (!SWIG_IsOK(res1)) {
46198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46199 }
46200 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46201 ecode2 = SWIG_AsVal_int(obj1, &val2);
46202 if (!SWIG_IsOK(ecode2)) {
46203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46204 }
46205 arg2 = static_cast< int >(val2);
46206 ecode3 = SWIG_AsVal_int(obj2, &val3);
46207 if (!SWIG_IsOK(ecode3)) {
46208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46209 }
46210 arg3 = static_cast< int >(val3);
46211 {
46212 PyThreadState* __tstate = wxPyBeginAllowThreads();
46213 (arg1)->SetRatio(arg2,arg3);
46214 wxPyEndAllowThreads(__tstate);
46215 if (PyErr_Occurred()) SWIG_fail;
46216 }
46217 resultobj = SWIG_Py_Void();
46218 return resultobj;
46219 fail:
46220 return NULL;
46221 }
46222
46223
46224 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46225 PyObject *resultobj = 0;
46226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46227 wxSize *arg2 = 0 ;
46228 void *argp1 = 0 ;
46229 int res1 = 0 ;
46230 wxSize temp2 ;
46231 PyObject * obj0 = 0 ;
46232 PyObject * obj1 = 0 ;
46233 char * kwnames[] = {
46234 (char *) "self",(char *) "size", NULL
46235 };
46236
46237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46239 if (!SWIG_IsOK(res1)) {
46240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46241 }
46242 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46243 {
46244 arg2 = &temp2;
46245 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46246 }
46247 {
46248 PyThreadState* __tstate = wxPyBeginAllowThreads();
46249 (arg1)->SetRatio((wxSize const &)*arg2);
46250 wxPyEndAllowThreads(__tstate);
46251 if (PyErr_Occurred()) SWIG_fail;
46252 }
46253 resultobj = SWIG_Py_Void();
46254 return resultobj;
46255 fail:
46256 return NULL;
46257 }
46258
46259
46260 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46261 PyObject *resultobj = 0;
46262 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46263 float arg2 ;
46264 void *argp1 = 0 ;
46265 int res1 = 0 ;
46266 float val2 ;
46267 int ecode2 = 0 ;
46268 PyObject * obj0 = 0 ;
46269 PyObject * obj1 = 0 ;
46270 char * kwnames[] = {
46271 (char *) "self",(char *) "ratio", NULL
46272 };
46273
46274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46276 if (!SWIG_IsOK(res1)) {
46277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46278 }
46279 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46280 ecode2 = SWIG_AsVal_float(obj1, &val2);
46281 if (!SWIG_IsOK(ecode2)) {
46282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46283 }
46284 arg2 = static_cast< float >(val2);
46285 {
46286 PyThreadState* __tstate = wxPyBeginAllowThreads();
46287 (arg1)->SetRatio(arg2);
46288 wxPyEndAllowThreads(__tstate);
46289 if (PyErr_Occurred()) SWIG_fail;
46290 }
46291 resultobj = SWIG_Py_Void();
46292 return resultobj;
46293 fail:
46294 return NULL;
46295 }
46296
46297
46298 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46299 PyObject *resultobj = 0;
46300 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46301 float result;
46302 void *argp1 = 0 ;
46303 int res1 = 0 ;
46304 PyObject *swig_obj[1] ;
46305
46306 if (!args) SWIG_fail;
46307 swig_obj[0] = args;
46308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46309 if (!SWIG_IsOK(res1)) {
46310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46311 }
46312 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46313 {
46314 PyThreadState* __tstate = wxPyBeginAllowThreads();
46315 result = (float)(arg1)->GetRatio();
46316 wxPyEndAllowThreads(__tstate);
46317 if (PyErr_Occurred()) SWIG_fail;
46318 }
46319 resultobj = SWIG_From_float(static_cast< float >(result));
46320 return resultobj;
46321 fail:
46322 return NULL;
46323 }
46324
46325
46326 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46327 PyObject *resultobj = 0;
46328 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46329 wxRect result;
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_wxSizerItem, 0 | 0 );
46337 if (!SWIG_IsOK(res1)) {
46338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46339 }
46340 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46341 {
46342 PyThreadState* __tstate = wxPyBeginAllowThreads();
46343 result = (arg1)->GetRect();
46344 wxPyEndAllowThreads(__tstate);
46345 if (PyErr_Occurred()) SWIG_fail;
46346 }
46347 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46348 return resultobj;
46349 fail:
46350 return NULL;
46351 }
46352
46353
46354 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46355 PyObject *resultobj = 0;
46356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46357 bool result;
46358 void *argp1 = 0 ;
46359 int res1 = 0 ;
46360 PyObject *swig_obj[1] ;
46361
46362 if (!args) SWIG_fail;
46363 swig_obj[0] = args;
46364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46365 if (!SWIG_IsOK(res1)) {
46366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46367 }
46368 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46369 {
46370 PyThreadState* __tstate = wxPyBeginAllowThreads();
46371 result = (bool)(arg1)->IsWindow();
46372 wxPyEndAllowThreads(__tstate);
46373 if (PyErr_Occurred()) SWIG_fail;
46374 }
46375 {
46376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46377 }
46378 return resultobj;
46379 fail:
46380 return NULL;
46381 }
46382
46383
46384 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46385 PyObject *resultobj = 0;
46386 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46387 bool result;
46388 void *argp1 = 0 ;
46389 int res1 = 0 ;
46390 PyObject *swig_obj[1] ;
46391
46392 if (!args) SWIG_fail;
46393 swig_obj[0] = args;
46394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46395 if (!SWIG_IsOK(res1)) {
46396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46397 }
46398 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46399 {
46400 PyThreadState* __tstate = wxPyBeginAllowThreads();
46401 result = (bool)(arg1)->IsSizer();
46402 wxPyEndAllowThreads(__tstate);
46403 if (PyErr_Occurred()) SWIG_fail;
46404 }
46405 {
46406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46407 }
46408 return resultobj;
46409 fail:
46410 return NULL;
46411 }
46412
46413
46414 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46415 PyObject *resultobj = 0;
46416 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46417 bool result;
46418 void *argp1 = 0 ;
46419 int res1 = 0 ;
46420 PyObject *swig_obj[1] ;
46421
46422 if (!args) SWIG_fail;
46423 swig_obj[0] = args;
46424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46425 if (!SWIG_IsOK(res1)) {
46426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46427 }
46428 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46429 {
46430 PyThreadState* __tstate = wxPyBeginAllowThreads();
46431 result = (bool)(arg1)->IsSpacer();
46432 wxPyEndAllowThreads(__tstate);
46433 if (PyErr_Occurred()) SWIG_fail;
46434 }
46435 {
46436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46437 }
46438 return resultobj;
46439 fail:
46440 return NULL;
46441 }
46442
46443
46444 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46445 PyObject *resultobj = 0;
46446 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46447 int arg2 ;
46448 void *argp1 = 0 ;
46449 int res1 = 0 ;
46450 int val2 ;
46451 int ecode2 = 0 ;
46452 PyObject * obj0 = 0 ;
46453 PyObject * obj1 = 0 ;
46454 char * kwnames[] = {
46455 (char *) "self",(char *) "proportion", NULL
46456 };
46457
46458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46460 if (!SWIG_IsOK(res1)) {
46461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46462 }
46463 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46464 ecode2 = SWIG_AsVal_int(obj1, &val2);
46465 if (!SWIG_IsOK(ecode2)) {
46466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46467 }
46468 arg2 = static_cast< int >(val2);
46469 {
46470 PyThreadState* __tstate = wxPyBeginAllowThreads();
46471 (arg1)->SetProportion(arg2);
46472 wxPyEndAllowThreads(__tstate);
46473 if (PyErr_Occurred()) SWIG_fail;
46474 }
46475 resultobj = SWIG_Py_Void();
46476 return resultobj;
46477 fail:
46478 return NULL;
46479 }
46480
46481
46482 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46483 PyObject *resultobj = 0;
46484 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46485 int result;
46486 void *argp1 = 0 ;
46487 int res1 = 0 ;
46488 PyObject *swig_obj[1] ;
46489
46490 if (!args) SWIG_fail;
46491 swig_obj[0] = args;
46492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46495 }
46496 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46497 {
46498 PyThreadState* __tstate = wxPyBeginAllowThreads();
46499 result = (int)(arg1)->GetProportion();
46500 wxPyEndAllowThreads(__tstate);
46501 if (PyErr_Occurred()) SWIG_fail;
46502 }
46503 resultobj = SWIG_From_int(static_cast< int >(result));
46504 return resultobj;
46505 fail:
46506 return NULL;
46507 }
46508
46509
46510 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46511 PyObject *resultobj = 0;
46512 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46513 int arg2 ;
46514 void *argp1 = 0 ;
46515 int res1 = 0 ;
46516 int val2 ;
46517 int ecode2 = 0 ;
46518 PyObject * obj0 = 0 ;
46519 PyObject * obj1 = 0 ;
46520 char * kwnames[] = {
46521 (char *) "self",(char *) "flag", NULL
46522 };
46523
46524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46526 if (!SWIG_IsOK(res1)) {
46527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46528 }
46529 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46530 ecode2 = SWIG_AsVal_int(obj1, &val2);
46531 if (!SWIG_IsOK(ecode2)) {
46532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46533 }
46534 arg2 = static_cast< int >(val2);
46535 {
46536 PyThreadState* __tstate = wxPyBeginAllowThreads();
46537 (arg1)->SetFlag(arg2);
46538 wxPyEndAllowThreads(__tstate);
46539 if (PyErr_Occurred()) SWIG_fail;
46540 }
46541 resultobj = SWIG_Py_Void();
46542 return resultobj;
46543 fail:
46544 return NULL;
46545 }
46546
46547
46548 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46549 PyObject *resultobj = 0;
46550 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46551 int result;
46552 void *argp1 = 0 ;
46553 int res1 = 0 ;
46554 PyObject *swig_obj[1] ;
46555
46556 if (!args) SWIG_fail;
46557 swig_obj[0] = args;
46558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46559 if (!SWIG_IsOK(res1)) {
46560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46561 }
46562 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46563 {
46564 PyThreadState* __tstate = wxPyBeginAllowThreads();
46565 result = (int)(arg1)->GetFlag();
46566 wxPyEndAllowThreads(__tstate);
46567 if (PyErr_Occurred()) SWIG_fail;
46568 }
46569 resultobj = SWIG_From_int(static_cast< int >(result));
46570 return resultobj;
46571 fail:
46572 return NULL;
46573 }
46574
46575
46576 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46577 PyObject *resultobj = 0;
46578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46579 int arg2 ;
46580 void *argp1 = 0 ;
46581 int res1 = 0 ;
46582 int val2 ;
46583 int ecode2 = 0 ;
46584 PyObject * obj0 = 0 ;
46585 PyObject * obj1 = 0 ;
46586 char * kwnames[] = {
46587 (char *) "self",(char *) "border", NULL
46588 };
46589
46590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46592 if (!SWIG_IsOK(res1)) {
46593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46594 }
46595 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46596 ecode2 = SWIG_AsVal_int(obj1, &val2);
46597 if (!SWIG_IsOK(ecode2)) {
46598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46599 }
46600 arg2 = static_cast< int >(val2);
46601 {
46602 PyThreadState* __tstate = wxPyBeginAllowThreads();
46603 (arg1)->SetBorder(arg2);
46604 wxPyEndAllowThreads(__tstate);
46605 if (PyErr_Occurred()) SWIG_fail;
46606 }
46607 resultobj = SWIG_Py_Void();
46608 return resultobj;
46609 fail:
46610 return NULL;
46611 }
46612
46613
46614 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46615 PyObject *resultobj = 0;
46616 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46617 int result;
46618 void *argp1 = 0 ;
46619 int res1 = 0 ;
46620 PyObject *swig_obj[1] ;
46621
46622 if (!args) SWIG_fail;
46623 swig_obj[0] = args;
46624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46625 if (!SWIG_IsOK(res1)) {
46626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46627 }
46628 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46629 {
46630 PyThreadState* __tstate = wxPyBeginAllowThreads();
46631 result = (int)(arg1)->GetBorder();
46632 wxPyEndAllowThreads(__tstate);
46633 if (PyErr_Occurred()) SWIG_fail;
46634 }
46635 resultobj = SWIG_From_int(static_cast< int >(result));
46636 return resultobj;
46637 fail:
46638 return NULL;
46639 }
46640
46641
46642 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46643 PyObject *resultobj = 0;
46644 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46645 wxWindow *result = 0 ;
46646 void *argp1 = 0 ;
46647 int res1 = 0 ;
46648 PyObject *swig_obj[1] ;
46649
46650 if (!args) SWIG_fail;
46651 swig_obj[0] = args;
46652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46653 if (!SWIG_IsOK(res1)) {
46654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46655 }
46656 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46657 {
46658 PyThreadState* __tstate = wxPyBeginAllowThreads();
46659 result = (wxWindow *)(arg1)->GetWindow();
46660 wxPyEndAllowThreads(__tstate);
46661 if (PyErr_Occurred()) SWIG_fail;
46662 }
46663 {
46664 resultobj = wxPyMake_wxObject(result, 0);
46665 }
46666 return resultobj;
46667 fail:
46668 return NULL;
46669 }
46670
46671
46672 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46673 PyObject *resultobj = 0;
46674 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46675 wxWindow *arg2 = (wxWindow *) 0 ;
46676 void *argp1 = 0 ;
46677 int res1 = 0 ;
46678 void *argp2 = 0 ;
46679 int res2 = 0 ;
46680 PyObject * obj0 = 0 ;
46681 PyObject * obj1 = 0 ;
46682 char * kwnames[] = {
46683 (char *) "self",(char *) "window", NULL
46684 };
46685
46686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46688 if (!SWIG_IsOK(res1)) {
46689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46690 }
46691 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46692 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46693 if (!SWIG_IsOK(res2)) {
46694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46695 }
46696 arg2 = reinterpret_cast< wxWindow * >(argp2);
46697 {
46698 PyThreadState* __tstate = wxPyBeginAllowThreads();
46699 (arg1)->SetWindow(arg2);
46700 wxPyEndAllowThreads(__tstate);
46701 if (PyErr_Occurred()) SWIG_fail;
46702 }
46703 resultobj = SWIG_Py_Void();
46704 return resultobj;
46705 fail:
46706 return NULL;
46707 }
46708
46709
46710 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46711 PyObject *resultobj = 0;
46712 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46713 wxSizer *result = 0 ;
46714 void *argp1 = 0 ;
46715 int res1 = 0 ;
46716 PyObject *swig_obj[1] ;
46717
46718 if (!args) SWIG_fail;
46719 swig_obj[0] = args;
46720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46721 if (!SWIG_IsOK(res1)) {
46722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46723 }
46724 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46725 {
46726 PyThreadState* __tstate = wxPyBeginAllowThreads();
46727 result = (wxSizer *)(arg1)->GetSizer();
46728 wxPyEndAllowThreads(__tstate);
46729 if (PyErr_Occurred()) SWIG_fail;
46730 }
46731 {
46732 resultobj = wxPyMake_wxObject(result, (bool)0);
46733 }
46734 return resultobj;
46735 fail:
46736 return NULL;
46737 }
46738
46739
46740 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46741 PyObject *resultobj = 0;
46742 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46743 wxSizer *arg2 = (wxSizer *) 0 ;
46744 void *argp1 = 0 ;
46745 int res1 = 0 ;
46746 int res2 = 0 ;
46747 PyObject * obj0 = 0 ;
46748 PyObject * obj1 = 0 ;
46749 char * kwnames[] = {
46750 (char *) "self",(char *) "sizer", NULL
46751 };
46752
46753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46755 if (!SWIG_IsOK(res1)) {
46756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46757 }
46758 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46759 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46760 if (!SWIG_IsOK(res2)) {
46761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46762 }
46763 {
46764 PyThreadState* __tstate = wxPyBeginAllowThreads();
46765 (arg1)->SetSizer(arg2);
46766 wxPyEndAllowThreads(__tstate);
46767 if (PyErr_Occurred()) SWIG_fail;
46768 }
46769 resultobj = SWIG_Py_Void();
46770 return resultobj;
46771 fail:
46772 return NULL;
46773 }
46774
46775
46776 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46777 PyObject *resultobj = 0;
46778 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46779 wxSize *result = 0 ;
46780 void *argp1 = 0 ;
46781 int res1 = 0 ;
46782 PyObject *swig_obj[1] ;
46783
46784 if (!args) SWIG_fail;
46785 swig_obj[0] = args;
46786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46787 if (!SWIG_IsOK(res1)) {
46788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46789 }
46790 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46791 {
46792 PyThreadState* __tstate = wxPyBeginAllowThreads();
46793 {
46794 wxSize const &_result_ref = (arg1)->GetSpacer();
46795 result = (wxSize *) &_result_ref;
46796 }
46797 wxPyEndAllowThreads(__tstate);
46798 if (PyErr_Occurred()) SWIG_fail;
46799 }
46800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46801 return resultobj;
46802 fail:
46803 return NULL;
46804 }
46805
46806
46807 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46808 PyObject *resultobj = 0;
46809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46810 wxSize *arg2 = 0 ;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 wxSize temp2 ;
46814 PyObject * obj0 = 0 ;
46815 PyObject * obj1 = 0 ;
46816 char * kwnames[] = {
46817 (char *) "self",(char *) "size", NULL
46818 };
46819
46820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46822 if (!SWIG_IsOK(res1)) {
46823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46824 }
46825 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46826 {
46827 arg2 = &temp2;
46828 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46829 }
46830 {
46831 PyThreadState* __tstate = wxPyBeginAllowThreads();
46832 (arg1)->SetSpacer((wxSize const &)*arg2);
46833 wxPyEndAllowThreads(__tstate);
46834 if (PyErr_Occurred()) SWIG_fail;
46835 }
46836 resultobj = SWIG_Py_Void();
46837 return resultobj;
46838 fail:
46839 return NULL;
46840 }
46841
46842
46843 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46844 PyObject *resultobj = 0;
46845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46846 bool arg2 ;
46847 void *argp1 = 0 ;
46848 int res1 = 0 ;
46849 bool val2 ;
46850 int ecode2 = 0 ;
46851 PyObject * obj0 = 0 ;
46852 PyObject * obj1 = 0 ;
46853 char * kwnames[] = {
46854 (char *) "self",(char *) "show", NULL
46855 };
46856
46857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46859 if (!SWIG_IsOK(res1)) {
46860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46861 }
46862 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46864 if (!SWIG_IsOK(ecode2)) {
46865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46866 }
46867 arg2 = static_cast< bool >(val2);
46868 {
46869 PyThreadState* __tstate = wxPyBeginAllowThreads();
46870 (arg1)->Show(arg2);
46871 wxPyEndAllowThreads(__tstate);
46872 if (PyErr_Occurred()) SWIG_fail;
46873 }
46874 resultobj = SWIG_Py_Void();
46875 return resultobj;
46876 fail:
46877 return NULL;
46878 }
46879
46880
46881 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46882 PyObject *resultobj = 0;
46883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46884 bool result;
46885 void *argp1 = 0 ;
46886 int res1 = 0 ;
46887 PyObject *swig_obj[1] ;
46888
46889 if (!args) SWIG_fail;
46890 swig_obj[0] = args;
46891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46892 if (!SWIG_IsOK(res1)) {
46893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46894 }
46895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46896 {
46897 PyThreadState* __tstate = wxPyBeginAllowThreads();
46898 result = (bool)(arg1)->IsShown();
46899 wxPyEndAllowThreads(__tstate);
46900 if (PyErr_Occurred()) SWIG_fail;
46901 }
46902 {
46903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46904 }
46905 return resultobj;
46906 fail:
46907 return NULL;
46908 }
46909
46910
46911 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46912 PyObject *resultobj = 0;
46913 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46914 wxPoint result;
46915 void *argp1 = 0 ;
46916 int res1 = 0 ;
46917 PyObject *swig_obj[1] ;
46918
46919 if (!args) SWIG_fail;
46920 swig_obj[0] = args;
46921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46922 if (!SWIG_IsOK(res1)) {
46923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46924 }
46925 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46926 {
46927 PyThreadState* __tstate = wxPyBeginAllowThreads();
46928 result = (arg1)->GetPosition();
46929 wxPyEndAllowThreads(__tstate);
46930 if (PyErr_Occurred()) SWIG_fail;
46931 }
46932 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46933 return resultobj;
46934 fail:
46935 return NULL;
46936 }
46937
46938
46939 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46940 PyObject *resultobj = 0;
46941 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46942 PyObject *result = 0 ;
46943 void *argp1 = 0 ;
46944 int res1 = 0 ;
46945 PyObject *swig_obj[1] ;
46946
46947 if (!args) SWIG_fail;
46948 swig_obj[0] = args;
46949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46950 if (!SWIG_IsOK(res1)) {
46951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46952 }
46953 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46954 {
46955 PyThreadState* __tstate = wxPyBeginAllowThreads();
46956 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46957 wxPyEndAllowThreads(__tstate);
46958 if (PyErr_Occurred()) SWIG_fail;
46959 }
46960 resultobj = result;
46961 return resultobj;
46962 fail:
46963 return NULL;
46964 }
46965
46966
46967 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46968 PyObject *resultobj = 0;
46969 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46970 PyObject *arg2 = (PyObject *) 0 ;
46971 void *argp1 = 0 ;
46972 int res1 = 0 ;
46973 PyObject * obj0 = 0 ;
46974 PyObject * obj1 = 0 ;
46975 char * kwnames[] = {
46976 (char *) "self",(char *) "userData", NULL
46977 };
46978
46979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46981 if (!SWIG_IsOK(res1)) {
46982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46983 }
46984 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46985 arg2 = obj1;
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 wxSizerItem_SetUserData(arg1,arg2);
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_Py_Void();
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47000 PyObject *obj;
47001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47002 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47003 return SWIG_Py_Void();
47004 }
47005
47006 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47007 return SWIG_Python_InitShadowInstance(args);
47008 }
47009
47010 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47011 PyObject *resultobj = 0;
47012 wxSizer *arg1 = (wxSizer *) 0 ;
47013 void *argp1 = 0 ;
47014 int res1 = 0 ;
47015 PyObject *swig_obj[1] ;
47016
47017 if (!args) SWIG_fail;
47018 swig_obj[0] = args;
47019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizer * >(argp1);
47024 {
47025 PyThreadState* __tstate = wxPyBeginAllowThreads();
47026 delete arg1;
47027
47028 wxPyEndAllowThreads(__tstate);
47029 if (PyErr_Occurred()) SWIG_fail;
47030 }
47031 resultobj = SWIG_Py_Void();
47032 return resultobj;
47033 fail:
47034 return NULL;
47035 }
47036
47037
47038 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47039 PyObject *resultobj = 0;
47040 wxSizer *arg1 = (wxSizer *) 0 ;
47041 PyObject *arg2 = (PyObject *) 0 ;
47042 void *argp1 = 0 ;
47043 int res1 = 0 ;
47044 PyObject * obj0 = 0 ;
47045 PyObject * obj1 = 0 ;
47046 char * kwnames[] = {
47047 (char *) "self",(char *) "_self", NULL
47048 };
47049
47050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47052 if (!SWIG_IsOK(res1)) {
47053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47054 }
47055 arg1 = reinterpret_cast< wxSizer * >(argp1);
47056 arg2 = obj1;
47057 {
47058 PyThreadState* __tstate = wxPyBeginAllowThreads();
47059 wxSizer__setOORInfo(arg1,arg2);
47060 wxPyEndAllowThreads(__tstate);
47061 if (PyErr_Occurred()) SWIG_fail;
47062 }
47063 resultobj = SWIG_Py_Void();
47064 return resultobj;
47065 fail:
47066 return NULL;
47067 }
47068
47069
47070 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47071 PyObject *resultobj = 0;
47072 wxSizer *arg1 = (wxSizer *) 0 ;
47073 PyObject *arg2 = (PyObject *) 0 ;
47074 int arg3 = (int) 0 ;
47075 int arg4 = (int) 0 ;
47076 int arg5 = (int) 0 ;
47077 PyObject *arg6 = (PyObject *) NULL ;
47078 wxSizerItem *result = 0 ;
47079 void *argp1 = 0 ;
47080 int res1 = 0 ;
47081 int val3 ;
47082 int ecode3 = 0 ;
47083 int val4 ;
47084 int ecode4 = 0 ;
47085 int val5 ;
47086 int ecode5 = 0 ;
47087 PyObject * obj0 = 0 ;
47088 PyObject * obj1 = 0 ;
47089 PyObject * obj2 = 0 ;
47090 PyObject * obj3 = 0 ;
47091 PyObject * obj4 = 0 ;
47092 PyObject * obj5 = 0 ;
47093 char * kwnames[] = {
47094 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47095 };
47096
47097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47099 if (!SWIG_IsOK(res1)) {
47100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47101 }
47102 arg1 = reinterpret_cast< wxSizer * >(argp1);
47103 arg2 = obj1;
47104 if (obj2) {
47105 ecode3 = SWIG_AsVal_int(obj2, &val3);
47106 if (!SWIG_IsOK(ecode3)) {
47107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47108 }
47109 arg3 = static_cast< int >(val3);
47110 }
47111 if (obj3) {
47112 ecode4 = SWIG_AsVal_int(obj3, &val4);
47113 if (!SWIG_IsOK(ecode4)) {
47114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47115 }
47116 arg4 = static_cast< int >(val4);
47117 }
47118 if (obj4) {
47119 ecode5 = SWIG_AsVal_int(obj4, &val5);
47120 if (!SWIG_IsOK(ecode5)) {
47121 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47122 }
47123 arg5 = static_cast< int >(val5);
47124 }
47125 if (obj5) {
47126 arg6 = obj5;
47127 }
47128 {
47129 PyThreadState* __tstate = wxPyBeginAllowThreads();
47130 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47131 wxPyEndAllowThreads(__tstate);
47132 if (PyErr_Occurred()) SWIG_fail;
47133 }
47134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47135 return resultobj;
47136 fail:
47137 return NULL;
47138 }
47139
47140
47141 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47142 PyObject *resultobj = 0;
47143 wxSizer *arg1 = (wxSizer *) 0 ;
47144 int arg2 ;
47145 PyObject *arg3 = (PyObject *) 0 ;
47146 int arg4 = (int) 0 ;
47147 int arg5 = (int) 0 ;
47148 int arg6 = (int) 0 ;
47149 PyObject *arg7 = (PyObject *) NULL ;
47150 wxSizerItem *result = 0 ;
47151 void *argp1 = 0 ;
47152 int res1 = 0 ;
47153 int val2 ;
47154 int ecode2 = 0 ;
47155 int val4 ;
47156 int ecode4 = 0 ;
47157 int val5 ;
47158 int ecode5 = 0 ;
47159 int val6 ;
47160 int ecode6 = 0 ;
47161 PyObject * obj0 = 0 ;
47162 PyObject * obj1 = 0 ;
47163 PyObject * obj2 = 0 ;
47164 PyObject * obj3 = 0 ;
47165 PyObject * obj4 = 0 ;
47166 PyObject * obj5 = 0 ;
47167 PyObject * obj6 = 0 ;
47168 char * kwnames[] = {
47169 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47170 };
47171
47172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47174 if (!SWIG_IsOK(res1)) {
47175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47176 }
47177 arg1 = reinterpret_cast< wxSizer * >(argp1);
47178 ecode2 = SWIG_AsVal_int(obj1, &val2);
47179 if (!SWIG_IsOK(ecode2)) {
47180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47181 }
47182 arg2 = static_cast< int >(val2);
47183 arg3 = obj2;
47184 if (obj3) {
47185 ecode4 = SWIG_AsVal_int(obj3, &val4);
47186 if (!SWIG_IsOK(ecode4)) {
47187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47188 }
47189 arg4 = static_cast< int >(val4);
47190 }
47191 if (obj4) {
47192 ecode5 = SWIG_AsVal_int(obj4, &val5);
47193 if (!SWIG_IsOK(ecode5)) {
47194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47195 }
47196 arg5 = static_cast< int >(val5);
47197 }
47198 if (obj5) {
47199 ecode6 = SWIG_AsVal_int(obj5, &val6);
47200 if (!SWIG_IsOK(ecode6)) {
47201 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47202 }
47203 arg6 = static_cast< int >(val6);
47204 }
47205 if (obj6) {
47206 arg7 = obj6;
47207 }
47208 {
47209 PyThreadState* __tstate = wxPyBeginAllowThreads();
47210 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47211 wxPyEndAllowThreads(__tstate);
47212 if (PyErr_Occurred()) SWIG_fail;
47213 }
47214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47215 return resultobj;
47216 fail:
47217 return NULL;
47218 }
47219
47220
47221 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47222 PyObject *resultobj = 0;
47223 wxSizer *arg1 = (wxSizer *) 0 ;
47224 PyObject *arg2 = (PyObject *) 0 ;
47225 int arg3 = (int) 0 ;
47226 int arg4 = (int) 0 ;
47227 int arg5 = (int) 0 ;
47228 PyObject *arg6 = (PyObject *) NULL ;
47229 wxSizerItem *result = 0 ;
47230 void *argp1 = 0 ;
47231 int res1 = 0 ;
47232 int val3 ;
47233 int ecode3 = 0 ;
47234 int val4 ;
47235 int ecode4 = 0 ;
47236 int val5 ;
47237 int ecode5 = 0 ;
47238 PyObject * obj0 = 0 ;
47239 PyObject * obj1 = 0 ;
47240 PyObject * obj2 = 0 ;
47241 PyObject * obj3 = 0 ;
47242 PyObject * obj4 = 0 ;
47243 PyObject * obj5 = 0 ;
47244 char * kwnames[] = {
47245 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47246 };
47247
47248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47250 if (!SWIG_IsOK(res1)) {
47251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47252 }
47253 arg1 = reinterpret_cast< wxSizer * >(argp1);
47254 arg2 = obj1;
47255 if (obj2) {
47256 ecode3 = SWIG_AsVal_int(obj2, &val3);
47257 if (!SWIG_IsOK(ecode3)) {
47258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47259 }
47260 arg3 = static_cast< int >(val3);
47261 }
47262 if (obj3) {
47263 ecode4 = SWIG_AsVal_int(obj3, &val4);
47264 if (!SWIG_IsOK(ecode4)) {
47265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47266 }
47267 arg4 = static_cast< int >(val4);
47268 }
47269 if (obj4) {
47270 ecode5 = SWIG_AsVal_int(obj4, &val5);
47271 if (!SWIG_IsOK(ecode5)) {
47272 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47273 }
47274 arg5 = static_cast< int >(val5);
47275 }
47276 if (obj5) {
47277 arg6 = obj5;
47278 }
47279 {
47280 PyThreadState* __tstate = wxPyBeginAllowThreads();
47281 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47282 wxPyEndAllowThreads(__tstate);
47283 if (PyErr_Occurred()) SWIG_fail;
47284 }
47285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47286 return resultobj;
47287 fail:
47288 return NULL;
47289 }
47290
47291
47292 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47293 PyObject *resultobj = 0;
47294 wxSizer *arg1 = (wxSizer *) 0 ;
47295 PyObject *arg2 = (PyObject *) 0 ;
47296 bool result;
47297 void *argp1 = 0 ;
47298 int res1 = 0 ;
47299 PyObject * obj0 = 0 ;
47300 PyObject * obj1 = 0 ;
47301 char * kwnames[] = {
47302 (char *) "self",(char *) "item", NULL
47303 };
47304
47305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",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_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47309 }
47310 arg1 = reinterpret_cast< wxSizer * >(argp1);
47311 arg2 = obj1;
47312 {
47313 PyThreadState* __tstate = wxPyBeginAllowThreads();
47314 result = (bool)wxSizer_Remove(arg1,arg2);
47315 wxPyEndAllowThreads(__tstate);
47316 if (PyErr_Occurred()) SWIG_fail;
47317 }
47318 {
47319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47320 }
47321 return resultobj;
47322 fail:
47323 return NULL;
47324 }
47325
47326
47327 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47328 PyObject *resultobj = 0;
47329 wxSizer *arg1 = (wxSizer *) 0 ;
47330 PyObject *arg2 = (PyObject *) 0 ;
47331 bool result;
47332 void *argp1 = 0 ;
47333 int res1 = 0 ;
47334 PyObject * obj0 = 0 ;
47335 PyObject * obj1 = 0 ;
47336 char * kwnames[] = {
47337 (char *) "self",(char *) "item", NULL
47338 };
47339
47340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47342 if (!SWIG_IsOK(res1)) {
47343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47344 }
47345 arg1 = reinterpret_cast< wxSizer * >(argp1);
47346 arg2 = obj1;
47347 {
47348 PyThreadState* __tstate = wxPyBeginAllowThreads();
47349 result = (bool)wxSizer_Detach(arg1,arg2);
47350 wxPyEndAllowThreads(__tstate);
47351 if (PyErr_Occurred()) SWIG_fail;
47352 }
47353 {
47354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47355 }
47356 return resultobj;
47357 fail:
47358 return NULL;
47359 }
47360
47361
47362 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47363 PyObject *resultobj = 0;
47364 wxSizer *arg1 = (wxSizer *) 0 ;
47365 PyObject *arg2 = (PyObject *) 0 ;
47366 wxSizerItem *result = 0 ;
47367 void *argp1 = 0 ;
47368 int res1 = 0 ;
47369 PyObject * obj0 = 0 ;
47370 PyObject * obj1 = 0 ;
47371 char * kwnames[] = {
47372 (char *) "self",(char *) "item", NULL
47373 };
47374
47375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47377 if (!SWIG_IsOK(res1)) {
47378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47379 }
47380 arg1 = reinterpret_cast< wxSizer * >(argp1);
47381 arg2 = obj1;
47382 {
47383 PyThreadState* __tstate = wxPyBeginAllowThreads();
47384 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47385 wxPyEndAllowThreads(__tstate);
47386 if (PyErr_Occurred()) SWIG_fail;
47387 }
47388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47389 return resultobj;
47390 fail:
47391 return NULL;
47392 }
47393
47394
47395 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47396 PyObject *resultobj = 0;
47397 wxSizer *arg1 = (wxSizer *) 0 ;
47398 PyObject *arg2 = (PyObject *) 0 ;
47399 wxSize *arg3 = 0 ;
47400 void *argp1 = 0 ;
47401 int res1 = 0 ;
47402 wxSize temp3 ;
47403 PyObject * obj0 = 0 ;
47404 PyObject * obj1 = 0 ;
47405 PyObject * obj2 = 0 ;
47406 char * kwnames[] = {
47407 (char *) "self",(char *) "item",(char *) "size", NULL
47408 };
47409
47410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47412 if (!SWIG_IsOK(res1)) {
47413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47414 }
47415 arg1 = reinterpret_cast< wxSizer * >(argp1);
47416 arg2 = obj1;
47417 {
47418 arg3 = &temp3;
47419 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47420 }
47421 {
47422 PyThreadState* __tstate = wxPyBeginAllowThreads();
47423 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47424 wxPyEndAllowThreads(__tstate);
47425 if (PyErr_Occurred()) SWIG_fail;
47426 }
47427 resultobj = SWIG_Py_Void();
47428 return resultobj;
47429 fail:
47430 return NULL;
47431 }
47432
47433
47434 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47435 PyObject *resultobj = 0;
47436 wxSizer *arg1 = (wxSizer *) 0 ;
47437 wxWindow *arg2 = (wxWindow *) 0 ;
47438 wxWindow *arg3 = (wxWindow *) 0 ;
47439 bool arg4 = (bool) false ;
47440 bool result;
47441 void *argp1 = 0 ;
47442 int res1 = 0 ;
47443 void *argp2 = 0 ;
47444 int res2 = 0 ;
47445 void *argp3 = 0 ;
47446 int res3 = 0 ;
47447 bool val4 ;
47448 int ecode4 = 0 ;
47449 PyObject * obj0 = 0 ;
47450 PyObject * obj1 = 0 ;
47451 PyObject * obj2 = 0 ;
47452 PyObject * obj3 = 0 ;
47453 char * kwnames[] = {
47454 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47455 };
47456
47457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47459 if (!SWIG_IsOK(res1)) {
47460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47461 }
47462 arg1 = reinterpret_cast< wxSizer * >(argp1);
47463 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47464 if (!SWIG_IsOK(res2)) {
47465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47466 }
47467 arg2 = reinterpret_cast< wxWindow * >(argp2);
47468 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47469 if (!SWIG_IsOK(res3)) {
47470 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47471 }
47472 arg3 = reinterpret_cast< wxWindow * >(argp3);
47473 if (obj3) {
47474 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47475 if (!SWIG_IsOK(ecode4)) {
47476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47477 }
47478 arg4 = static_cast< bool >(val4);
47479 }
47480 {
47481 PyThreadState* __tstate = wxPyBeginAllowThreads();
47482 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47483 wxPyEndAllowThreads(__tstate);
47484 if (PyErr_Occurred()) SWIG_fail;
47485 }
47486 {
47487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47488 }
47489 return resultobj;
47490 fail:
47491 return NULL;
47492 }
47493
47494
47495 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47496 PyObject *resultobj = 0;
47497 wxSizer *arg1 = (wxSizer *) 0 ;
47498 wxSizer *arg2 = (wxSizer *) 0 ;
47499 wxSizer *arg3 = (wxSizer *) 0 ;
47500 bool arg4 = (bool) false ;
47501 bool result;
47502 void *argp1 = 0 ;
47503 int res1 = 0 ;
47504 void *argp2 = 0 ;
47505 int res2 = 0 ;
47506 void *argp3 = 0 ;
47507 int res3 = 0 ;
47508 bool val4 ;
47509 int ecode4 = 0 ;
47510 PyObject * obj0 = 0 ;
47511 PyObject * obj1 = 0 ;
47512 PyObject * obj2 = 0 ;
47513 PyObject * obj3 = 0 ;
47514 char * kwnames[] = {
47515 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47516 };
47517
47518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47520 if (!SWIG_IsOK(res1)) {
47521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47522 }
47523 arg1 = reinterpret_cast< wxSizer * >(argp1);
47524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47525 if (!SWIG_IsOK(res2)) {
47526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47527 }
47528 arg2 = reinterpret_cast< wxSizer * >(argp2);
47529 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47530 if (!SWIG_IsOK(res3)) {
47531 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47532 }
47533 arg3 = reinterpret_cast< wxSizer * >(argp3);
47534 if (obj3) {
47535 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47536 if (!SWIG_IsOK(ecode4)) {
47537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47538 }
47539 arg4 = static_cast< bool >(val4);
47540 }
47541 {
47542 PyThreadState* __tstate = wxPyBeginAllowThreads();
47543 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47544 wxPyEndAllowThreads(__tstate);
47545 if (PyErr_Occurred()) SWIG_fail;
47546 }
47547 {
47548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47549 }
47550 return resultobj;
47551 fail:
47552 return NULL;
47553 }
47554
47555
47556 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47557 PyObject *resultobj = 0;
47558 wxSizer *arg1 = (wxSizer *) 0 ;
47559 size_t arg2 ;
47560 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47561 bool result;
47562 void *argp1 = 0 ;
47563 int res1 = 0 ;
47564 size_t val2 ;
47565 int ecode2 = 0 ;
47566 void *argp3 = 0 ;
47567 int res3 = 0 ;
47568 PyObject * obj0 = 0 ;
47569 PyObject * obj1 = 0 ;
47570 PyObject * obj2 = 0 ;
47571 char * kwnames[] = {
47572 (char *) "self",(char *) "index",(char *) "newitem", NULL
47573 };
47574
47575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47577 if (!SWIG_IsOK(res1)) {
47578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47579 }
47580 arg1 = reinterpret_cast< wxSizer * >(argp1);
47581 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47582 if (!SWIG_IsOK(ecode2)) {
47583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47584 }
47585 arg2 = static_cast< size_t >(val2);
47586 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47587 if (!SWIG_IsOK(res3)) {
47588 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47589 }
47590 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47591 {
47592 PyThreadState* __tstate = wxPyBeginAllowThreads();
47593 result = (bool)(arg1)->Replace(arg2,arg3);
47594 wxPyEndAllowThreads(__tstate);
47595 if (PyErr_Occurred()) SWIG_fail;
47596 }
47597 {
47598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47599 }
47600 return resultobj;
47601 fail:
47602 return NULL;
47603 }
47604
47605
47606 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47607 PyObject *resultobj = 0;
47608 wxSizer *arg1 = (wxSizer *) 0 ;
47609 wxWindow *arg2 = (wxWindow *) 0 ;
47610 void *argp1 = 0 ;
47611 int res1 = 0 ;
47612 void *argp2 = 0 ;
47613 int res2 = 0 ;
47614 PyObject * obj0 = 0 ;
47615 PyObject * obj1 = 0 ;
47616 char * kwnames[] = {
47617 (char *) "self",(char *) "window", NULL
47618 };
47619
47620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47622 if (!SWIG_IsOK(res1)) {
47623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47624 }
47625 arg1 = reinterpret_cast< wxSizer * >(argp1);
47626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47627 if (!SWIG_IsOK(res2)) {
47628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47629 }
47630 arg2 = reinterpret_cast< wxWindow * >(argp2);
47631 {
47632 PyThreadState* __tstate = wxPyBeginAllowThreads();
47633 (arg1)->SetContainingWindow(arg2);
47634 wxPyEndAllowThreads(__tstate);
47635 if (PyErr_Occurred()) SWIG_fail;
47636 }
47637 resultobj = SWIG_Py_Void();
47638 return resultobj;
47639 fail:
47640 return NULL;
47641 }
47642
47643
47644 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47645 PyObject *resultobj = 0;
47646 wxSizer *arg1 = (wxSizer *) 0 ;
47647 wxWindow *result = 0 ;
47648 void *argp1 = 0 ;
47649 int res1 = 0 ;
47650 PyObject *swig_obj[1] ;
47651
47652 if (!args) SWIG_fail;
47653 swig_obj[0] = args;
47654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47655 if (!SWIG_IsOK(res1)) {
47656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47657 }
47658 arg1 = reinterpret_cast< wxSizer * >(argp1);
47659 {
47660 PyThreadState* __tstate = wxPyBeginAllowThreads();
47661 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47662 wxPyEndAllowThreads(__tstate);
47663 if (PyErr_Occurred()) SWIG_fail;
47664 }
47665 {
47666 resultobj = wxPyMake_wxObject(result, 0);
47667 }
47668 return resultobj;
47669 fail:
47670 return NULL;
47671 }
47672
47673
47674 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47675 PyObject *resultobj = 0;
47676 wxSizer *arg1 = (wxSizer *) 0 ;
47677 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47678 wxSizerItem *result = 0 ;
47679 void *argp1 = 0 ;
47680 int res1 = 0 ;
47681 int res2 = 0 ;
47682 PyObject * obj0 = 0 ;
47683 PyObject * obj1 = 0 ;
47684 char * kwnames[] = {
47685 (char *) "self",(char *) "item", NULL
47686 };
47687
47688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47690 if (!SWIG_IsOK(res1)) {
47691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47692 }
47693 arg1 = reinterpret_cast< wxSizer * >(argp1);
47694 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47695 if (!SWIG_IsOK(res2)) {
47696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47697 }
47698 {
47699 PyThreadState* __tstate = wxPyBeginAllowThreads();
47700 result = (wxSizerItem *)(arg1)->Add(arg2);
47701 wxPyEndAllowThreads(__tstate);
47702 if (PyErr_Occurred()) SWIG_fail;
47703 }
47704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47705 return resultobj;
47706 fail:
47707 return NULL;
47708 }
47709
47710
47711 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47712 PyObject *resultobj = 0;
47713 wxSizer *arg1 = (wxSizer *) 0 ;
47714 size_t arg2 ;
47715 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47716 wxSizerItem *result = 0 ;
47717 void *argp1 = 0 ;
47718 int res1 = 0 ;
47719 size_t val2 ;
47720 int ecode2 = 0 ;
47721 int res3 = 0 ;
47722 PyObject * obj0 = 0 ;
47723 PyObject * obj1 = 0 ;
47724 PyObject * obj2 = 0 ;
47725 char * kwnames[] = {
47726 (char *) "self",(char *) "index",(char *) "item", NULL
47727 };
47728
47729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47731 if (!SWIG_IsOK(res1)) {
47732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47733 }
47734 arg1 = reinterpret_cast< wxSizer * >(argp1);
47735 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47736 if (!SWIG_IsOK(ecode2)) {
47737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47738 }
47739 arg2 = static_cast< size_t >(val2);
47740 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47741 if (!SWIG_IsOK(res3)) {
47742 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47743 }
47744 {
47745 PyThreadState* __tstate = wxPyBeginAllowThreads();
47746 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47747 wxPyEndAllowThreads(__tstate);
47748 if (PyErr_Occurred()) SWIG_fail;
47749 }
47750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47751 return resultobj;
47752 fail:
47753 return NULL;
47754 }
47755
47756
47757 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47758 PyObject *resultobj = 0;
47759 wxSizer *arg1 = (wxSizer *) 0 ;
47760 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47761 wxSizerItem *result = 0 ;
47762 void *argp1 = 0 ;
47763 int res1 = 0 ;
47764 int res2 = 0 ;
47765 PyObject * obj0 = 0 ;
47766 PyObject * obj1 = 0 ;
47767 char * kwnames[] = {
47768 (char *) "self",(char *) "item", NULL
47769 };
47770
47771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47773 if (!SWIG_IsOK(res1)) {
47774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47775 }
47776 arg1 = reinterpret_cast< wxSizer * >(argp1);
47777 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47778 if (!SWIG_IsOK(res2)) {
47779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47780 }
47781 {
47782 PyThreadState* __tstate = wxPyBeginAllowThreads();
47783 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47784 wxPyEndAllowThreads(__tstate);
47785 if (PyErr_Occurred()) SWIG_fail;
47786 }
47787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47788 return resultobj;
47789 fail:
47790 return NULL;
47791 }
47792
47793
47794 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47795 PyObject *resultobj = 0;
47796 wxSizer *arg1 = (wxSizer *) 0 ;
47797 int arg2 ;
47798 int arg3 ;
47799 int arg4 ;
47800 int arg5 ;
47801 void *argp1 = 0 ;
47802 int res1 = 0 ;
47803 int val2 ;
47804 int ecode2 = 0 ;
47805 int val3 ;
47806 int ecode3 = 0 ;
47807 int val4 ;
47808 int ecode4 = 0 ;
47809 int val5 ;
47810 int ecode5 = 0 ;
47811 PyObject * obj0 = 0 ;
47812 PyObject * obj1 = 0 ;
47813 PyObject * obj2 = 0 ;
47814 PyObject * obj3 = 0 ;
47815 PyObject * obj4 = 0 ;
47816 char * kwnames[] = {
47817 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47818 };
47819
47820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47822 if (!SWIG_IsOK(res1)) {
47823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47824 }
47825 arg1 = reinterpret_cast< wxSizer * >(argp1);
47826 ecode2 = SWIG_AsVal_int(obj1, &val2);
47827 if (!SWIG_IsOK(ecode2)) {
47828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47829 }
47830 arg2 = static_cast< int >(val2);
47831 ecode3 = SWIG_AsVal_int(obj2, &val3);
47832 if (!SWIG_IsOK(ecode3)) {
47833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47834 }
47835 arg3 = static_cast< int >(val3);
47836 ecode4 = SWIG_AsVal_int(obj3, &val4);
47837 if (!SWIG_IsOK(ecode4)) {
47838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47839 }
47840 arg4 = static_cast< int >(val4);
47841 ecode5 = SWIG_AsVal_int(obj4, &val5);
47842 if (!SWIG_IsOK(ecode5)) {
47843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47844 }
47845 arg5 = static_cast< int >(val5);
47846 {
47847 PyThreadState* __tstate = wxPyBeginAllowThreads();
47848 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47849 wxPyEndAllowThreads(__tstate);
47850 if (PyErr_Occurred()) SWIG_fail;
47851 }
47852 resultobj = SWIG_Py_Void();
47853 return resultobj;
47854 fail:
47855 return NULL;
47856 }
47857
47858
47859 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47860 PyObject *resultobj = 0;
47861 wxSizer *arg1 = (wxSizer *) 0 ;
47862 wxSize *arg2 = 0 ;
47863 void *argp1 = 0 ;
47864 int res1 = 0 ;
47865 wxSize temp2 ;
47866 PyObject * obj0 = 0 ;
47867 PyObject * obj1 = 0 ;
47868 char * kwnames[] = {
47869 (char *) "self",(char *) "size", NULL
47870 };
47871
47872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47874 if (!SWIG_IsOK(res1)) {
47875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47876 }
47877 arg1 = reinterpret_cast< wxSizer * >(argp1);
47878 {
47879 arg2 = &temp2;
47880 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47881 }
47882 {
47883 PyThreadState* __tstate = wxPyBeginAllowThreads();
47884 (arg1)->SetMinSize((wxSize const &)*arg2);
47885 wxPyEndAllowThreads(__tstate);
47886 if (PyErr_Occurred()) SWIG_fail;
47887 }
47888 resultobj = SWIG_Py_Void();
47889 return resultobj;
47890 fail:
47891 return NULL;
47892 }
47893
47894
47895 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47896 PyObject *resultobj = 0;
47897 wxSizer *arg1 = (wxSizer *) 0 ;
47898 wxSize result;
47899 void *argp1 = 0 ;
47900 int res1 = 0 ;
47901 PyObject *swig_obj[1] ;
47902
47903 if (!args) SWIG_fail;
47904 swig_obj[0] = args;
47905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47906 if (!SWIG_IsOK(res1)) {
47907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47908 }
47909 arg1 = reinterpret_cast< wxSizer * >(argp1);
47910 {
47911 PyThreadState* __tstate = wxPyBeginAllowThreads();
47912 result = (arg1)->GetSize();
47913 wxPyEndAllowThreads(__tstate);
47914 if (PyErr_Occurred()) SWIG_fail;
47915 }
47916 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47917 return resultobj;
47918 fail:
47919 return NULL;
47920 }
47921
47922
47923 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47924 PyObject *resultobj = 0;
47925 wxSizer *arg1 = (wxSizer *) 0 ;
47926 wxPoint result;
47927 void *argp1 = 0 ;
47928 int res1 = 0 ;
47929 PyObject *swig_obj[1] ;
47930
47931 if (!args) SWIG_fail;
47932 swig_obj[0] = args;
47933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47934 if (!SWIG_IsOK(res1)) {
47935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47936 }
47937 arg1 = reinterpret_cast< wxSizer * >(argp1);
47938 {
47939 PyThreadState* __tstate = wxPyBeginAllowThreads();
47940 result = (arg1)->GetPosition();
47941 wxPyEndAllowThreads(__tstate);
47942 if (PyErr_Occurred()) SWIG_fail;
47943 }
47944 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47945 return resultobj;
47946 fail:
47947 return NULL;
47948 }
47949
47950
47951 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47952 PyObject *resultobj = 0;
47953 wxSizer *arg1 = (wxSizer *) 0 ;
47954 wxSize result;
47955 void *argp1 = 0 ;
47956 int res1 = 0 ;
47957 PyObject *swig_obj[1] ;
47958
47959 if (!args) SWIG_fail;
47960 swig_obj[0] = args;
47961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47962 if (!SWIG_IsOK(res1)) {
47963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47964 }
47965 arg1 = reinterpret_cast< wxSizer * >(argp1);
47966 {
47967 PyThreadState* __tstate = wxPyBeginAllowThreads();
47968 result = (arg1)->GetMinSize();
47969 wxPyEndAllowThreads(__tstate);
47970 if (PyErr_Occurred()) SWIG_fail;
47971 }
47972 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47973 return resultobj;
47974 fail:
47975 return NULL;
47976 }
47977
47978
47979 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47980 PyObject *resultobj = 0;
47981 wxSizer *arg1 = (wxSizer *) 0 ;
47982 void *argp1 = 0 ;
47983 int res1 = 0 ;
47984 PyObject *swig_obj[1] ;
47985
47986 if (!args) SWIG_fail;
47987 swig_obj[0] = args;
47988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47989 if (!SWIG_IsOK(res1)) {
47990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47991 }
47992 arg1 = reinterpret_cast< wxSizer * >(argp1);
47993 {
47994 PyThreadState* __tstate = wxPyBeginAllowThreads();
47995 (arg1)->RecalcSizes();
47996 wxPyEndAllowThreads(__tstate);
47997 if (PyErr_Occurred()) SWIG_fail;
47998 }
47999 resultobj = SWIG_Py_Void();
48000 return resultobj;
48001 fail:
48002 return NULL;
48003 }
48004
48005
48006 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48007 PyObject *resultobj = 0;
48008 wxSizer *arg1 = (wxSizer *) 0 ;
48009 wxSize result;
48010 void *argp1 = 0 ;
48011 int res1 = 0 ;
48012 PyObject *swig_obj[1] ;
48013
48014 if (!args) SWIG_fail;
48015 swig_obj[0] = args;
48016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48017 if (!SWIG_IsOK(res1)) {
48018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48019 }
48020 arg1 = reinterpret_cast< wxSizer * >(argp1);
48021 {
48022 PyThreadState* __tstate = wxPyBeginAllowThreads();
48023 result = (arg1)->CalcMin();
48024 wxPyEndAllowThreads(__tstate);
48025 if (PyErr_Occurred()) SWIG_fail;
48026 }
48027 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48028 return resultobj;
48029 fail:
48030 return NULL;
48031 }
48032
48033
48034 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48035 PyObject *resultobj = 0;
48036 wxSizer *arg1 = (wxSizer *) 0 ;
48037 void *argp1 = 0 ;
48038 int res1 = 0 ;
48039 PyObject *swig_obj[1] ;
48040
48041 if (!args) SWIG_fail;
48042 swig_obj[0] = args;
48043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48044 if (!SWIG_IsOK(res1)) {
48045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48046 }
48047 arg1 = reinterpret_cast< wxSizer * >(argp1);
48048 {
48049 PyThreadState* __tstate = wxPyBeginAllowThreads();
48050 (arg1)->Layout();
48051 wxPyEndAllowThreads(__tstate);
48052 if (PyErr_Occurred()) SWIG_fail;
48053 }
48054 resultobj = SWIG_Py_Void();
48055 return resultobj;
48056 fail:
48057 return NULL;
48058 }
48059
48060
48061 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48062 PyObject *resultobj = 0;
48063 wxSizer *arg1 = (wxSizer *) 0 ;
48064 wxWindow *arg2 = (wxWindow *) 0 ;
48065 wxSize result;
48066 void *argp1 = 0 ;
48067 int res1 = 0 ;
48068 void *argp2 = 0 ;
48069 int res2 = 0 ;
48070 PyObject * obj0 = 0 ;
48071 PyObject * obj1 = 0 ;
48072 char * kwnames[] = {
48073 (char *) "self",(char *) "window", NULL
48074 };
48075
48076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48078 if (!SWIG_IsOK(res1)) {
48079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48080 }
48081 arg1 = reinterpret_cast< wxSizer * >(argp1);
48082 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48083 if (!SWIG_IsOK(res2)) {
48084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48085 }
48086 arg2 = reinterpret_cast< wxWindow * >(argp2);
48087 {
48088 PyThreadState* __tstate = wxPyBeginAllowThreads();
48089 result = (arg1)->Fit(arg2);
48090 wxPyEndAllowThreads(__tstate);
48091 if (PyErr_Occurred()) SWIG_fail;
48092 }
48093 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48094 return resultobj;
48095 fail:
48096 return NULL;
48097 }
48098
48099
48100 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48101 PyObject *resultobj = 0;
48102 wxSizer *arg1 = (wxSizer *) 0 ;
48103 wxWindow *arg2 = (wxWindow *) 0 ;
48104 void *argp1 = 0 ;
48105 int res1 = 0 ;
48106 void *argp2 = 0 ;
48107 int res2 = 0 ;
48108 PyObject * obj0 = 0 ;
48109 PyObject * obj1 = 0 ;
48110 char * kwnames[] = {
48111 (char *) "self",(char *) "window", NULL
48112 };
48113
48114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48116 if (!SWIG_IsOK(res1)) {
48117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48118 }
48119 arg1 = reinterpret_cast< wxSizer * >(argp1);
48120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48121 if (!SWIG_IsOK(res2)) {
48122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48123 }
48124 arg2 = reinterpret_cast< wxWindow * >(argp2);
48125 {
48126 PyThreadState* __tstate = wxPyBeginAllowThreads();
48127 (arg1)->FitInside(arg2);
48128 wxPyEndAllowThreads(__tstate);
48129 if (PyErr_Occurred()) SWIG_fail;
48130 }
48131 resultobj = SWIG_Py_Void();
48132 return resultobj;
48133 fail:
48134 return NULL;
48135 }
48136
48137
48138 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48139 PyObject *resultobj = 0;
48140 wxSizer *arg1 = (wxSizer *) 0 ;
48141 wxWindow *arg2 = (wxWindow *) 0 ;
48142 void *argp1 = 0 ;
48143 int res1 = 0 ;
48144 void *argp2 = 0 ;
48145 int res2 = 0 ;
48146 PyObject * obj0 = 0 ;
48147 PyObject * obj1 = 0 ;
48148 char * kwnames[] = {
48149 (char *) "self",(char *) "window", NULL
48150 };
48151
48152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48154 if (!SWIG_IsOK(res1)) {
48155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48156 }
48157 arg1 = reinterpret_cast< wxSizer * >(argp1);
48158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48159 if (!SWIG_IsOK(res2)) {
48160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48161 }
48162 arg2 = reinterpret_cast< wxWindow * >(argp2);
48163 {
48164 PyThreadState* __tstate = wxPyBeginAllowThreads();
48165 (arg1)->SetSizeHints(arg2);
48166 wxPyEndAllowThreads(__tstate);
48167 if (PyErr_Occurred()) SWIG_fail;
48168 }
48169 resultobj = SWIG_Py_Void();
48170 return resultobj;
48171 fail:
48172 return NULL;
48173 }
48174
48175
48176 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48177 PyObject *resultobj = 0;
48178 wxSizer *arg1 = (wxSizer *) 0 ;
48179 wxWindow *arg2 = (wxWindow *) 0 ;
48180 void *argp1 = 0 ;
48181 int res1 = 0 ;
48182 void *argp2 = 0 ;
48183 int res2 = 0 ;
48184 PyObject * obj0 = 0 ;
48185 PyObject * obj1 = 0 ;
48186 char * kwnames[] = {
48187 (char *) "self",(char *) "window", NULL
48188 };
48189
48190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48192 if (!SWIG_IsOK(res1)) {
48193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48194 }
48195 arg1 = reinterpret_cast< wxSizer * >(argp1);
48196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48197 if (!SWIG_IsOK(res2)) {
48198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48199 }
48200 arg2 = reinterpret_cast< wxWindow * >(argp2);
48201 {
48202 PyThreadState* __tstate = wxPyBeginAllowThreads();
48203 (arg1)->SetVirtualSizeHints(arg2);
48204 wxPyEndAllowThreads(__tstate);
48205 if (PyErr_Occurred()) SWIG_fail;
48206 }
48207 resultobj = SWIG_Py_Void();
48208 return resultobj;
48209 fail:
48210 return NULL;
48211 }
48212
48213
48214 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48215 PyObject *resultobj = 0;
48216 wxSizer *arg1 = (wxSizer *) 0 ;
48217 bool arg2 = (bool) false ;
48218 void *argp1 = 0 ;
48219 int res1 = 0 ;
48220 bool val2 ;
48221 int ecode2 = 0 ;
48222 PyObject * obj0 = 0 ;
48223 PyObject * obj1 = 0 ;
48224 char * kwnames[] = {
48225 (char *) "self",(char *) "deleteWindows", NULL
48226 };
48227
48228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48232 }
48233 arg1 = reinterpret_cast< wxSizer * >(argp1);
48234 if (obj1) {
48235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48236 if (!SWIG_IsOK(ecode2)) {
48237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48238 }
48239 arg2 = static_cast< bool >(val2);
48240 }
48241 {
48242 PyThreadState* __tstate = wxPyBeginAllowThreads();
48243 (arg1)->Clear(arg2);
48244 wxPyEndAllowThreads(__tstate);
48245 if (PyErr_Occurred()) SWIG_fail;
48246 }
48247 resultobj = SWIG_Py_Void();
48248 return resultobj;
48249 fail:
48250 return NULL;
48251 }
48252
48253
48254 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48255 PyObject *resultobj = 0;
48256 wxSizer *arg1 = (wxSizer *) 0 ;
48257 void *argp1 = 0 ;
48258 int res1 = 0 ;
48259 PyObject *swig_obj[1] ;
48260
48261 if (!args) SWIG_fail;
48262 swig_obj[0] = args;
48263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48264 if (!SWIG_IsOK(res1)) {
48265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48266 }
48267 arg1 = reinterpret_cast< wxSizer * >(argp1);
48268 {
48269 PyThreadState* __tstate = wxPyBeginAllowThreads();
48270 (arg1)->DeleteWindows();
48271 wxPyEndAllowThreads(__tstate);
48272 if (PyErr_Occurred()) SWIG_fail;
48273 }
48274 resultobj = SWIG_Py_Void();
48275 return resultobj;
48276 fail:
48277 return NULL;
48278 }
48279
48280
48281 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48282 PyObject *resultobj = 0;
48283 wxSizer *arg1 = (wxSizer *) 0 ;
48284 PyObject *result = 0 ;
48285 void *argp1 = 0 ;
48286 int res1 = 0 ;
48287 PyObject *swig_obj[1] ;
48288
48289 if (!args) SWIG_fail;
48290 swig_obj[0] = args;
48291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48292 if (!SWIG_IsOK(res1)) {
48293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48294 }
48295 arg1 = reinterpret_cast< wxSizer * >(argp1);
48296 {
48297 PyThreadState* __tstate = wxPyBeginAllowThreads();
48298 result = (PyObject *)wxSizer_GetChildren(arg1);
48299 wxPyEndAllowThreads(__tstate);
48300 if (PyErr_Occurred()) SWIG_fail;
48301 }
48302 resultobj = result;
48303 return resultobj;
48304 fail:
48305 return NULL;
48306 }
48307
48308
48309 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48310 PyObject *resultobj = 0;
48311 wxSizer *arg1 = (wxSizer *) 0 ;
48312 PyObject *arg2 = (PyObject *) 0 ;
48313 bool arg3 = (bool) true ;
48314 bool arg4 = (bool) false ;
48315 bool result;
48316 void *argp1 = 0 ;
48317 int res1 = 0 ;
48318 bool val3 ;
48319 int ecode3 = 0 ;
48320 bool val4 ;
48321 int ecode4 = 0 ;
48322 PyObject * obj0 = 0 ;
48323 PyObject * obj1 = 0 ;
48324 PyObject * obj2 = 0 ;
48325 PyObject * obj3 = 0 ;
48326 char * kwnames[] = {
48327 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48328 };
48329
48330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48332 if (!SWIG_IsOK(res1)) {
48333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48334 }
48335 arg1 = reinterpret_cast< wxSizer * >(argp1);
48336 arg2 = obj1;
48337 if (obj2) {
48338 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48339 if (!SWIG_IsOK(ecode3)) {
48340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48341 }
48342 arg3 = static_cast< bool >(val3);
48343 }
48344 if (obj3) {
48345 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48346 if (!SWIG_IsOK(ecode4)) {
48347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48348 }
48349 arg4 = static_cast< bool >(val4);
48350 }
48351 {
48352 PyThreadState* __tstate = wxPyBeginAllowThreads();
48353 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48354 wxPyEndAllowThreads(__tstate);
48355 if (PyErr_Occurred()) SWIG_fail;
48356 }
48357 {
48358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48359 }
48360 return resultobj;
48361 fail:
48362 return NULL;
48363 }
48364
48365
48366 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48367 PyObject *resultobj = 0;
48368 wxSizer *arg1 = (wxSizer *) 0 ;
48369 PyObject *arg2 = (PyObject *) 0 ;
48370 bool result;
48371 void *argp1 = 0 ;
48372 int res1 = 0 ;
48373 PyObject * obj0 = 0 ;
48374 PyObject * obj1 = 0 ;
48375 char * kwnames[] = {
48376 (char *) "self",(char *) "item", NULL
48377 };
48378
48379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48381 if (!SWIG_IsOK(res1)) {
48382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48383 }
48384 arg1 = reinterpret_cast< wxSizer * >(argp1);
48385 arg2 = obj1;
48386 {
48387 PyThreadState* __tstate = wxPyBeginAllowThreads();
48388 result = (bool)wxSizer_IsShown(arg1,arg2);
48389 wxPyEndAllowThreads(__tstate);
48390 if (PyErr_Occurred()) SWIG_fail;
48391 }
48392 {
48393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48394 }
48395 return resultobj;
48396 fail:
48397 return NULL;
48398 }
48399
48400
48401 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48402 PyObject *resultobj = 0;
48403 wxSizer *arg1 = (wxSizer *) 0 ;
48404 bool arg2 ;
48405 void *argp1 = 0 ;
48406 int res1 = 0 ;
48407 bool val2 ;
48408 int ecode2 = 0 ;
48409 PyObject * obj0 = 0 ;
48410 PyObject * obj1 = 0 ;
48411 char * kwnames[] = {
48412 (char *) "self",(char *) "show", NULL
48413 };
48414
48415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48417 if (!SWIG_IsOK(res1)) {
48418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48419 }
48420 arg1 = reinterpret_cast< wxSizer * >(argp1);
48421 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48422 if (!SWIG_IsOK(ecode2)) {
48423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48424 }
48425 arg2 = static_cast< bool >(val2);
48426 {
48427 PyThreadState* __tstate = wxPyBeginAllowThreads();
48428 (arg1)->ShowItems(arg2);
48429 wxPyEndAllowThreads(__tstate);
48430 if (PyErr_Occurred()) SWIG_fail;
48431 }
48432 resultobj = SWIG_Py_Void();
48433 return resultobj;
48434 fail:
48435 return NULL;
48436 }
48437
48438
48439 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48440 PyObject *obj;
48441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48442 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48443 return SWIG_Py_Void();
48444 }
48445
48446 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48447 PyObject *resultobj = 0;
48448 wxPySizer *result = 0 ;
48449
48450 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48451 {
48452 PyThreadState* __tstate = wxPyBeginAllowThreads();
48453 result = (wxPySizer *)new wxPySizer();
48454 wxPyEndAllowThreads(__tstate);
48455 if (PyErr_Occurred()) SWIG_fail;
48456 }
48457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48458 return resultobj;
48459 fail:
48460 return NULL;
48461 }
48462
48463
48464 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48465 PyObject *resultobj = 0;
48466 wxPySizer *arg1 = (wxPySizer *) 0 ;
48467 PyObject *arg2 = (PyObject *) 0 ;
48468 PyObject *arg3 = (PyObject *) 0 ;
48469 void *argp1 = 0 ;
48470 int res1 = 0 ;
48471 PyObject * obj0 = 0 ;
48472 PyObject * obj1 = 0 ;
48473 PyObject * obj2 = 0 ;
48474 char * kwnames[] = {
48475 (char *) "self",(char *) "self",(char *) "_class", NULL
48476 };
48477
48478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48480 if (!SWIG_IsOK(res1)) {
48481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48482 }
48483 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48484 arg2 = obj1;
48485 arg3 = obj2;
48486 {
48487 PyThreadState* __tstate = wxPyBeginAllowThreads();
48488 (arg1)->_setCallbackInfo(arg2,arg3);
48489 wxPyEndAllowThreads(__tstate);
48490 if (PyErr_Occurred()) SWIG_fail;
48491 }
48492 resultobj = SWIG_Py_Void();
48493 return resultobj;
48494 fail:
48495 return NULL;
48496 }
48497
48498
48499 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48500 PyObject *obj;
48501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48502 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48503 return SWIG_Py_Void();
48504 }
48505
48506 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48507 return SWIG_Python_InitShadowInstance(args);
48508 }
48509
48510 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48511 PyObject *resultobj = 0;
48512 int arg1 = (int) wxHORIZONTAL ;
48513 wxBoxSizer *result = 0 ;
48514 int val1 ;
48515 int ecode1 = 0 ;
48516 PyObject * obj0 = 0 ;
48517 char * kwnames[] = {
48518 (char *) "orient", NULL
48519 };
48520
48521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48522 if (obj0) {
48523 ecode1 = SWIG_AsVal_int(obj0, &val1);
48524 if (!SWIG_IsOK(ecode1)) {
48525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48526 }
48527 arg1 = static_cast< int >(val1);
48528 }
48529 {
48530 PyThreadState* __tstate = wxPyBeginAllowThreads();
48531 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48532 wxPyEndAllowThreads(__tstate);
48533 if (PyErr_Occurred()) SWIG_fail;
48534 }
48535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48536 return resultobj;
48537 fail:
48538 return NULL;
48539 }
48540
48541
48542 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48543 PyObject *resultobj = 0;
48544 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48545 int result;
48546 void *argp1 = 0 ;
48547 int res1 = 0 ;
48548 PyObject *swig_obj[1] ;
48549
48550 if (!args) SWIG_fail;
48551 swig_obj[0] = args;
48552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48553 if (!SWIG_IsOK(res1)) {
48554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48555 }
48556 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48557 {
48558 PyThreadState* __tstate = wxPyBeginAllowThreads();
48559 result = (int)(arg1)->GetOrientation();
48560 wxPyEndAllowThreads(__tstate);
48561 if (PyErr_Occurred()) SWIG_fail;
48562 }
48563 resultobj = SWIG_From_int(static_cast< int >(result));
48564 return resultobj;
48565 fail:
48566 return NULL;
48567 }
48568
48569
48570 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48571 PyObject *resultobj = 0;
48572 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48573 int arg2 ;
48574 void *argp1 = 0 ;
48575 int res1 = 0 ;
48576 int val2 ;
48577 int ecode2 = 0 ;
48578 PyObject * obj0 = 0 ;
48579 PyObject * obj1 = 0 ;
48580 char * kwnames[] = {
48581 (char *) "self",(char *) "orient", NULL
48582 };
48583
48584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48586 if (!SWIG_IsOK(res1)) {
48587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48588 }
48589 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48590 ecode2 = SWIG_AsVal_int(obj1, &val2);
48591 if (!SWIG_IsOK(ecode2)) {
48592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48593 }
48594 arg2 = static_cast< int >(val2);
48595 {
48596 PyThreadState* __tstate = wxPyBeginAllowThreads();
48597 (arg1)->SetOrientation(arg2);
48598 wxPyEndAllowThreads(__tstate);
48599 if (PyErr_Occurred()) SWIG_fail;
48600 }
48601 resultobj = SWIG_Py_Void();
48602 return resultobj;
48603 fail:
48604 return NULL;
48605 }
48606
48607
48608 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48609 PyObject *obj;
48610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48611 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48612 return SWIG_Py_Void();
48613 }
48614
48615 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48616 return SWIG_Python_InitShadowInstance(args);
48617 }
48618
48619 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48620 PyObject *resultobj = 0;
48621 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48622 int arg2 = (int) wxHORIZONTAL ;
48623 wxStaticBoxSizer *result = 0 ;
48624 void *argp1 = 0 ;
48625 int res1 = 0 ;
48626 int val2 ;
48627 int ecode2 = 0 ;
48628 PyObject * obj0 = 0 ;
48629 PyObject * obj1 = 0 ;
48630 char * kwnames[] = {
48631 (char *) "box",(char *) "orient", NULL
48632 };
48633
48634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48636 if (!SWIG_IsOK(res1)) {
48637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48638 }
48639 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48640 if (obj1) {
48641 ecode2 = SWIG_AsVal_int(obj1, &val2);
48642 if (!SWIG_IsOK(ecode2)) {
48643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48644 }
48645 arg2 = static_cast< int >(val2);
48646 }
48647 {
48648 PyThreadState* __tstate = wxPyBeginAllowThreads();
48649 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48650 wxPyEndAllowThreads(__tstate);
48651 if (PyErr_Occurred()) SWIG_fail;
48652 }
48653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48654 return resultobj;
48655 fail:
48656 return NULL;
48657 }
48658
48659
48660 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48661 PyObject *resultobj = 0;
48662 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48663 wxStaticBox *result = 0 ;
48664 void *argp1 = 0 ;
48665 int res1 = 0 ;
48666 PyObject *swig_obj[1] ;
48667
48668 if (!args) SWIG_fail;
48669 swig_obj[0] = args;
48670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48671 if (!SWIG_IsOK(res1)) {
48672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48673 }
48674 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48675 {
48676 PyThreadState* __tstate = wxPyBeginAllowThreads();
48677 result = (wxStaticBox *)(arg1)->GetStaticBox();
48678 wxPyEndAllowThreads(__tstate);
48679 if (PyErr_Occurred()) SWIG_fail;
48680 }
48681 {
48682 resultobj = wxPyMake_wxObject(result, (bool)0);
48683 }
48684 return resultobj;
48685 fail:
48686 return NULL;
48687 }
48688
48689
48690 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48691 PyObject *obj;
48692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48693 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48694 return SWIG_Py_Void();
48695 }
48696
48697 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48698 return SWIG_Python_InitShadowInstance(args);
48699 }
48700
48701 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48702 PyObject *resultobj = 0;
48703 int arg1 = (int) 1 ;
48704 int arg2 = (int) 0 ;
48705 int arg3 = (int) 0 ;
48706 int arg4 = (int) 0 ;
48707 wxGridSizer *result = 0 ;
48708 int val1 ;
48709 int ecode1 = 0 ;
48710 int val2 ;
48711 int ecode2 = 0 ;
48712 int val3 ;
48713 int ecode3 = 0 ;
48714 int val4 ;
48715 int ecode4 = 0 ;
48716 PyObject * obj0 = 0 ;
48717 PyObject * obj1 = 0 ;
48718 PyObject * obj2 = 0 ;
48719 PyObject * obj3 = 0 ;
48720 char * kwnames[] = {
48721 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48722 };
48723
48724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48725 if (obj0) {
48726 ecode1 = SWIG_AsVal_int(obj0, &val1);
48727 if (!SWIG_IsOK(ecode1)) {
48728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48729 }
48730 arg1 = static_cast< int >(val1);
48731 }
48732 if (obj1) {
48733 ecode2 = SWIG_AsVal_int(obj1, &val2);
48734 if (!SWIG_IsOK(ecode2)) {
48735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48736 }
48737 arg2 = static_cast< int >(val2);
48738 }
48739 if (obj2) {
48740 ecode3 = SWIG_AsVal_int(obj2, &val3);
48741 if (!SWIG_IsOK(ecode3)) {
48742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48743 }
48744 arg3 = static_cast< int >(val3);
48745 }
48746 if (obj3) {
48747 ecode4 = SWIG_AsVal_int(obj3, &val4);
48748 if (!SWIG_IsOK(ecode4)) {
48749 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48750 }
48751 arg4 = static_cast< int >(val4);
48752 }
48753 {
48754 PyThreadState* __tstate = wxPyBeginAllowThreads();
48755 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48756 wxPyEndAllowThreads(__tstate);
48757 if (PyErr_Occurred()) SWIG_fail;
48758 }
48759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48760 return resultobj;
48761 fail:
48762 return NULL;
48763 }
48764
48765
48766 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48767 PyObject *resultobj = 0;
48768 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48769 int arg2 ;
48770 void *argp1 = 0 ;
48771 int res1 = 0 ;
48772 int val2 ;
48773 int ecode2 = 0 ;
48774 PyObject * obj0 = 0 ;
48775 PyObject * obj1 = 0 ;
48776 char * kwnames[] = {
48777 (char *) "self",(char *) "cols", NULL
48778 };
48779
48780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48782 if (!SWIG_IsOK(res1)) {
48783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48784 }
48785 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48786 ecode2 = SWIG_AsVal_int(obj1, &val2);
48787 if (!SWIG_IsOK(ecode2)) {
48788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48789 }
48790 arg2 = static_cast< int >(val2);
48791 {
48792 PyThreadState* __tstate = wxPyBeginAllowThreads();
48793 (arg1)->SetCols(arg2);
48794 wxPyEndAllowThreads(__tstate);
48795 if (PyErr_Occurred()) SWIG_fail;
48796 }
48797 resultobj = SWIG_Py_Void();
48798 return resultobj;
48799 fail:
48800 return NULL;
48801 }
48802
48803
48804 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48805 PyObject *resultobj = 0;
48806 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48807 int arg2 ;
48808 void *argp1 = 0 ;
48809 int res1 = 0 ;
48810 int val2 ;
48811 int ecode2 = 0 ;
48812 PyObject * obj0 = 0 ;
48813 PyObject * obj1 = 0 ;
48814 char * kwnames[] = {
48815 (char *) "self",(char *) "rows", NULL
48816 };
48817
48818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48820 if (!SWIG_IsOK(res1)) {
48821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48822 }
48823 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48824 ecode2 = SWIG_AsVal_int(obj1, &val2);
48825 if (!SWIG_IsOK(ecode2)) {
48826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48827 }
48828 arg2 = static_cast< int >(val2);
48829 {
48830 PyThreadState* __tstate = wxPyBeginAllowThreads();
48831 (arg1)->SetRows(arg2);
48832 wxPyEndAllowThreads(__tstate);
48833 if (PyErr_Occurred()) SWIG_fail;
48834 }
48835 resultobj = SWIG_Py_Void();
48836 return resultobj;
48837 fail:
48838 return NULL;
48839 }
48840
48841
48842 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48843 PyObject *resultobj = 0;
48844 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48845 int arg2 ;
48846 void *argp1 = 0 ;
48847 int res1 = 0 ;
48848 int val2 ;
48849 int ecode2 = 0 ;
48850 PyObject * obj0 = 0 ;
48851 PyObject * obj1 = 0 ;
48852 char * kwnames[] = {
48853 (char *) "self",(char *) "gap", NULL
48854 };
48855
48856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48858 if (!SWIG_IsOK(res1)) {
48859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48860 }
48861 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48862 ecode2 = SWIG_AsVal_int(obj1, &val2);
48863 if (!SWIG_IsOK(ecode2)) {
48864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48865 }
48866 arg2 = static_cast< int >(val2);
48867 {
48868 PyThreadState* __tstate = wxPyBeginAllowThreads();
48869 (arg1)->SetVGap(arg2);
48870 wxPyEndAllowThreads(__tstate);
48871 if (PyErr_Occurred()) SWIG_fail;
48872 }
48873 resultobj = SWIG_Py_Void();
48874 return resultobj;
48875 fail:
48876 return NULL;
48877 }
48878
48879
48880 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48881 PyObject *resultobj = 0;
48882 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48883 int arg2 ;
48884 void *argp1 = 0 ;
48885 int res1 = 0 ;
48886 int val2 ;
48887 int ecode2 = 0 ;
48888 PyObject * obj0 = 0 ;
48889 PyObject * obj1 = 0 ;
48890 char * kwnames[] = {
48891 (char *) "self",(char *) "gap", NULL
48892 };
48893
48894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48896 if (!SWIG_IsOK(res1)) {
48897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48898 }
48899 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48900 ecode2 = SWIG_AsVal_int(obj1, &val2);
48901 if (!SWIG_IsOK(ecode2)) {
48902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48903 }
48904 arg2 = static_cast< int >(val2);
48905 {
48906 PyThreadState* __tstate = wxPyBeginAllowThreads();
48907 (arg1)->SetHGap(arg2);
48908 wxPyEndAllowThreads(__tstate);
48909 if (PyErr_Occurred()) SWIG_fail;
48910 }
48911 resultobj = SWIG_Py_Void();
48912 return resultobj;
48913 fail:
48914 return NULL;
48915 }
48916
48917
48918 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48919 PyObject *resultobj = 0;
48920 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48921 int result;
48922 void *argp1 = 0 ;
48923 int res1 = 0 ;
48924 PyObject *swig_obj[1] ;
48925
48926 if (!args) SWIG_fail;
48927 swig_obj[0] = args;
48928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48929 if (!SWIG_IsOK(res1)) {
48930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48931 }
48932 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48933 {
48934 PyThreadState* __tstate = wxPyBeginAllowThreads();
48935 result = (int)(arg1)->GetCols();
48936 wxPyEndAllowThreads(__tstate);
48937 if (PyErr_Occurred()) SWIG_fail;
48938 }
48939 resultobj = SWIG_From_int(static_cast< int >(result));
48940 return resultobj;
48941 fail:
48942 return NULL;
48943 }
48944
48945
48946 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48947 PyObject *resultobj = 0;
48948 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48949 int result;
48950 void *argp1 = 0 ;
48951 int res1 = 0 ;
48952 PyObject *swig_obj[1] ;
48953
48954 if (!args) SWIG_fail;
48955 swig_obj[0] = args;
48956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48957 if (!SWIG_IsOK(res1)) {
48958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48959 }
48960 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48961 {
48962 PyThreadState* __tstate = wxPyBeginAllowThreads();
48963 result = (int)(arg1)->GetRows();
48964 wxPyEndAllowThreads(__tstate);
48965 if (PyErr_Occurred()) SWIG_fail;
48966 }
48967 resultobj = SWIG_From_int(static_cast< int >(result));
48968 return resultobj;
48969 fail:
48970 return NULL;
48971 }
48972
48973
48974 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48975 PyObject *resultobj = 0;
48976 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48977 int result;
48978 void *argp1 = 0 ;
48979 int res1 = 0 ;
48980 PyObject *swig_obj[1] ;
48981
48982 if (!args) SWIG_fail;
48983 swig_obj[0] = args;
48984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48985 if (!SWIG_IsOK(res1)) {
48986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48987 }
48988 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48989 {
48990 PyThreadState* __tstate = wxPyBeginAllowThreads();
48991 result = (int)(arg1)->GetVGap();
48992 wxPyEndAllowThreads(__tstate);
48993 if (PyErr_Occurred()) SWIG_fail;
48994 }
48995 resultobj = SWIG_From_int(static_cast< int >(result));
48996 return resultobj;
48997 fail:
48998 return NULL;
48999 }
49000
49001
49002 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49003 PyObject *resultobj = 0;
49004 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49005 int result;
49006 void *argp1 = 0 ;
49007 int res1 = 0 ;
49008 PyObject *swig_obj[1] ;
49009
49010 if (!args) SWIG_fail;
49011 swig_obj[0] = args;
49012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49013 if (!SWIG_IsOK(res1)) {
49014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49015 }
49016 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49017 {
49018 PyThreadState* __tstate = wxPyBeginAllowThreads();
49019 result = (int)(arg1)->GetHGap();
49020 wxPyEndAllowThreads(__tstate);
49021 if (PyErr_Occurred()) SWIG_fail;
49022 }
49023 resultobj = SWIG_From_int(static_cast< int >(result));
49024 return resultobj;
49025 fail:
49026 return NULL;
49027 }
49028
49029
49030 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49031 PyObject *obj;
49032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49033 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49034 return SWIG_Py_Void();
49035 }
49036
49037 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49038 return SWIG_Python_InitShadowInstance(args);
49039 }
49040
49041 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49042 PyObject *resultobj = 0;
49043 int arg1 = (int) 1 ;
49044 int arg2 = (int) 0 ;
49045 int arg3 = (int) 0 ;
49046 int arg4 = (int) 0 ;
49047 wxFlexGridSizer *result = 0 ;
49048 int val1 ;
49049 int ecode1 = 0 ;
49050 int val2 ;
49051 int ecode2 = 0 ;
49052 int val3 ;
49053 int ecode3 = 0 ;
49054 int val4 ;
49055 int ecode4 = 0 ;
49056 PyObject * obj0 = 0 ;
49057 PyObject * obj1 = 0 ;
49058 PyObject * obj2 = 0 ;
49059 PyObject * obj3 = 0 ;
49060 char * kwnames[] = {
49061 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49062 };
49063
49064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49065 if (obj0) {
49066 ecode1 = SWIG_AsVal_int(obj0, &val1);
49067 if (!SWIG_IsOK(ecode1)) {
49068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49069 }
49070 arg1 = static_cast< int >(val1);
49071 }
49072 if (obj1) {
49073 ecode2 = SWIG_AsVal_int(obj1, &val2);
49074 if (!SWIG_IsOK(ecode2)) {
49075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49076 }
49077 arg2 = static_cast< int >(val2);
49078 }
49079 if (obj2) {
49080 ecode3 = SWIG_AsVal_int(obj2, &val3);
49081 if (!SWIG_IsOK(ecode3)) {
49082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49083 }
49084 arg3 = static_cast< int >(val3);
49085 }
49086 if (obj3) {
49087 ecode4 = SWIG_AsVal_int(obj3, &val4);
49088 if (!SWIG_IsOK(ecode4)) {
49089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49090 }
49091 arg4 = static_cast< int >(val4);
49092 }
49093 {
49094 PyThreadState* __tstate = wxPyBeginAllowThreads();
49095 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49096 wxPyEndAllowThreads(__tstate);
49097 if (PyErr_Occurred()) SWIG_fail;
49098 }
49099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49100 return resultobj;
49101 fail:
49102 return NULL;
49103 }
49104
49105
49106 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49107 PyObject *resultobj = 0;
49108 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49109 size_t arg2 ;
49110 int arg3 = (int) 0 ;
49111 void *argp1 = 0 ;
49112 int res1 = 0 ;
49113 size_t val2 ;
49114 int ecode2 = 0 ;
49115 int val3 ;
49116 int ecode3 = 0 ;
49117 PyObject * obj0 = 0 ;
49118 PyObject * obj1 = 0 ;
49119 PyObject * obj2 = 0 ;
49120 char * kwnames[] = {
49121 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49122 };
49123
49124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49126 if (!SWIG_IsOK(res1)) {
49127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49128 }
49129 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49130 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49131 if (!SWIG_IsOK(ecode2)) {
49132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49133 }
49134 arg2 = static_cast< size_t >(val2);
49135 if (obj2) {
49136 ecode3 = SWIG_AsVal_int(obj2, &val3);
49137 if (!SWIG_IsOK(ecode3)) {
49138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49139 }
49140 arg3 = static_cast< int >(val3);
49141 }
49142 {
49143 PyThreadState* __tstate = wxPyBeginAllowThreads();
49144 (arg1)->AddGrowableRow(arg2,arg3);
49145 wxPyEndAllowThreads(__tstate);
49146 if (PyErr_Occurred()) SWIG_fail;
49147 }
49148 resultobj = SWIG_Py_Void();
49149 return resultobj;
49150 fail:
49151 return NULL;
49152 }
49153
49154
49155 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49156 PyObject *resultobj = 0;
49157 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49158 size_t arg2 ;
49159 void *argp1 = 0 ;
49160 int res1 = 0 ;
49161 size_t val2 ;
49162 int ecode2 = 0 ;
49163 PyObject * obj0 = 0 ;
49164 PyObject * obj1 = 0 ;
49165 char * kwnames[] = {
49166 (char *) "self",(char *) "idx", NULL
49167 };
49168
49169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49171 if (!SWIG_IsOK(res1)) {
49172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49173 }
49174 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49175 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49176 if (!SWIG_IsOK(ecode2)) {
49177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49178 }
49179 arg2 = static_cast< size_t >(val2);
49180 {
49181 PyThreadState* __tstate = wxPyBeginAllowThreads();
49182 (arg1)->RemoveGrowableRow(arg2);
49183 wxPyEndAllowThreads(__tstate);
49184 if (PyErr_Occurred()) SWIG_fail;
49185 }
49186 resultobj = SWIG_Py_Void();
49187 return resultobj;
49188 fail:
49189 return NULL;
49190 }
49191
49192
49193 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49194 PyObject *resultobj = 0;
49195 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49196 size_t arg2 ;
49197 int arg3 = (int) 0 ;
49198 void *argp1 = 0 ;
49199 int res1 = 0 ;
49200 size_t val2 ;
49201 int ecode2 = 0 ;
49202 int val3 ;
49203 int ecode3 = 0 ;
49204 PyObject * obj0 = 0 ;
49205 PyObject * obj1 = 0 ;
49206 PyObject * obj2 = 0 ;
49207 char * kwnames[] = {
49208 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49209 };
49210
49211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49213 if (!SWIG_IsOK(res1)) {
49214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49215 }
49216 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49218 if (!SWIG_IsOK(ecode2)) {
49219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49220 }
49221 arg2 = static_cast< size_t >(val2);
49222 if (obj2) {
49223 ecode3 = SWIG_AsVal_int(obj2, &val3);
49224 if (!SWIG_IsOK(ecode3)) {
49225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49226 }
49227 arg3 = static_cast< int >(val3);
49228 }
49229 {
49230 PyThreadState* __tstate = wxPyBeginAllowThreads();
49231 (arg1)->AddGrowableCol(arg2,arg3);
49232 wxPyEndAllowThreads(__tstate);
49233 if (PyErr_Occurred()) SWIG_fail;
49234 }
49235 resultobj = SWIG_Py_Void();
49236 return resultobj;
49237 fail:
49238 return NULL;
49239 }
49240
49241
49242 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49243 PyObject *resultobj = 0;
49244 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49245 size_t arg2 ;
49246 void *argp1 = 0 ;
49247 int res1 = 0 ;
49248 size_t val2 ;
49249 int ecode2 = 0 ;
49250 PyObject * obj0 = 0 ;
49251 PyObject * obj1 = 0 ;
49252 char * kwnames[] = {
49253 (char *) "self",(char *) "idx", NULL
49254 };
49255
49256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49258 if (!SWIG_IsOK(res1)) {
49259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49260 }
49261 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49262 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49263 if (!SWIG_IsOK(ecode2)) {
49264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49265 }
49266 arg2 = static_cast< size_t >(val2);
49267 {
49268 PyThreadState* __tstate = wxPyBeginAllowThreads();
49269 (arg1)->RemoveGrowableCol(arg2);
49270 wxPyEndAllowThreads(__tstate);
49271 if (PyErr_Occurred()) SWIG_fail;
49272 }
49273 resultobj = SWIG_Py_Void();
49274 return resultobj;
49275 fail:
49276 return NULL;
49277 }
49278
49279
49280 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49281 PyObject *resultobj = 0;
49282 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49283 int arg2 ;
49284 void *argp1 = 0 ;
49285 int res1 = 0 ;
49286 int val2 ;
49287 int ecode2 = 0 ;
49288 PyObject * obj0 = 0 ;
49289 PyObject * obj1 = 0 ;
49290 char * kwnames[] = {
49291 (char *) "self",(char *) "direction", NULL
49292 };
49293
49294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49296 if (!SWIG_IsOK(res1)) {
49297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49298 }
49299 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49300 ecode2 = SWIG_AsVal_int(obj1, &val2);
49301 if (!SWIG_IsOK(ecode2)) {
49302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49303 }
49304 arg2 = static_cast< int >(val2);
49305 {
49306 PyThreadState* __tstate = wxPyBeginAllowThreads();
49307 (arg1)->SetFlexibleDirection(arg2);
49308 wxPyEndAllowThreads(__tstate);
49309 if (PyErr_Occurred()) SWIG_fail;
49310 }
49311 resultobj = SWIG_Py_Void();
49312 return resultobj;
49313 fail:
49314 return NULL;
49315 }
49316
49317
49318 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49319 PyObject *resultobj = 0;
49320 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49321 int result;
49322 void *argp1 = 0 ;
49323 int res1 = 0 ;
49324 PyObject *swig_obj[1] ;
49325
49326 if (!args) SWIG_fail;
49327 swig_obj[0] = args;
49328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49329 if (!SWIG_IsOK(res1)) {
49330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49331 }
49332 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49333 {
49334 PyThreadState* __tstate = wxPyBeginAllowThreads();
49335 result = (int)(arg1)->GetFlexibleDirection();
49336 wxPyEndAllowThreads(__tstate);
49337 if (PyErr_Occurred()) SWIG_fail;
49338 }
49339 resultobj = SWIG_From_int(static_cast< int >(result));
49340 return resultobj;
49341 fail:
49342 return NULL;
49343 }
49344
49345
49346 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49347 PyObject *resultobj = 0;
49348 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49349 wxFlexSizerGrowMode arg2 ;
49350 void *argp1 = 0 ;
49351 int res1 = 0 ;
49352 int val2 ;
49353 int ecode2 = 0 ;
49354 PyObject * obj0 = 0 ;
49355 PyObject * obj1 = 0 ;
49356 char * kwnames[] = {
49357 (char *) "self",(char *) "mode", NULL
49358 };
49359
49360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49362 if (!SWIG_IsOK(res1)) {
49363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49364 }
49365 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49366 ecode2 = SWIG_AsVal_int(obj1, &val2);
49367 if (!SWIG_IsOK(ecode2)) {
49368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49369 }
49370 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49371 {
49372 PyThreadState* __tstate = wxPyBeginAllowThreads();
49373 (arg1)->SetNonFlexibleGrowMode(arg2);
49374 wxPyEndAllowThreads(__tstate);
49375 if (PyErr_Occurred()) SWIG_fail;
49376 }
49377 resultobj = SWIG_Py_Void();
49378 return resultobj;
49379 fail:
49380 return NULL;
49381 }
49382
49383
49384 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49385 PyObject *resultobj = 0;
49386 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49387 wxFlexSizerGrowMode result;
49388 void *argp1 = 0 ;
49389 int res1 = 0 ;
49390 PyObject *swig_obj[1] ;
49391
49392 if (!args) SWIG_fail;
49393 swig_obj[0] = args;
49394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49395 if (!SWIG_IsOK(res1)) {
49396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49397 }
49398 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49399 {
49400 PyThreadState* __tstate = wxPyBeginAllowThreads();
49401 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49402 wxPyEndAllowThreads(__tstate);
49403 if (PyErr_Occurred()) SWIG_fail;
49404 }
49405 resultobj = SWIG_From_int(static_cast< int >(result));
49406 return resultobj;
49407 fail:
49408 return NULL;
49409 }
49410
49411
49412 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49413 PyObject *resultobj = 0;
49414 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49415 wxArrayInt *result = 0 ;
49416 void *argp1 = 0 ;
49417 int res1 = 0 ;
49418 PyObject *swig_obj[1] ;
49419
49420 if (!args) SWIG_fail;
49421 swig_obj[0] = args;
49422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49423 if (!SWIG_IsOK(res1)) {
49424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49425 }
49426 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49427 {
49428 PyThreadState* __tstate = wxPyBeginAllowThreads();
49429 {
49430 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49431 result = (wxArrayInt *) &_result_ref;
49432 }
49433 wxPyEndAllowThreads(__tstate);
49434 if (PyErr_Occurred()) SWIG_fail;
49435 }
49436 {
49437 resultobj = PyList_New(0);
49438 size_t idx;
49439 for (idx = 0; idx < result->GetCount(); idx += 1) {
49440 PyObject* val = PyInt_FromLong( result->Item(idx) );
49441 PyList_Append(resultobj, val);
49442 Py_DECREF(val);
49443 }
49444 }
49445 return resultobj;
49446 fail:
49447 return NULL;
49448 }
49449
49450
49451 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49452 PyObject *resultobj = 0;
49453 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49454 wxArrayInt *result = 0 ;
49455 void *argp1 = 0 ;
49456 int res1 = 0 ;
49457 PyObject *swig_obj[1] ;
49458
49459 if (!args) SWIG_fail;
49460 swig_obj[0] = args;
49461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49462 if (!SWIG_IsOK(res1)) {
49463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49464 }
49465 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49466 {
49467 PyThreadState* __tstate = wxPyBeginAllowThreads();
49468 {
49469 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49470 result = (wxArrayInt *) &_result_ref;
49471 }
49472 wxPyEndAllowThreads(__tstate);
49473 if (PyErr_Occurred()) SWIG_fail;
49474 }
49475 {
49476 resultobj = PyList_New(0);
49477 size_t idx;
49478 for (idx = 0; idx < result->GetCount(); idx += 1) {
49479 PyObject* val = PyInt_FromLong( result->Item(idx) );
49480 PyList_Append(resultobj, val);
49481 Py_DECREF(val);
49482 }
49483 }
49484 return resultobj;
49485 fail:
49486 return NULL;
49487 }
49488
49489
49490 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49491 PyObject *obj;
49492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49493 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49494 return SWIG_Py_Void();
49495 }
49496
49497 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49498 return SWIG_Python_InitShadowInstance(args);
49499 }
49500
49501 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49502 PyObject *resultobj = 0;
49503 wxStdDialogButtonSizer *result = 0 ;
49504
49505 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49506 {
49507 PyThreadState* __tstate = wxPyBeginAllowThreads();
49508 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49509 wxPyEndAllowThreads(__tstate);
49510 if (PyErr_Occurred()) SWIG_fail;
49511 }
49512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49513 return resultobj;
49514 fail:
49515 return NULL;
49516 }
49517
49518
49519 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49520 PyObject *resultobj = 0;
49521 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49522 wxButton *arg2 = (wxButton *) 0 ;
49523 void *argp1 = 0 ;
49524 int res1 = 0 ;
49525 void *argp2 = 0 ;
49526 int res2 = 0 ;
49527 PyObject * obj0 = 0 ;
49528 PyObject * obj1 = 0 ;
49529 char * kwnames[] = {
49530 (char *) "self",(char *) "button", NULL
49531 };
49532
49533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49535 if (!SWIG_IsOK(res1)) {
49536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49537 }
49538 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49540 if (!SWIG_IsOK(res2)) {
49541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49542 }
49543 arg2 = reinterpret_cast< wxButton * >(argp2);
49544 {
49545 PyThreadState* __tstate = wxPyBeginAllowThreads();
49546 (arg1)->AddButton(arg2);
49547 wxPyEndAllowThreads(__tstate);
49548 if (PyErr_Occurred()) SWIG_fail;
49549 }
49550 resultobj = SWIG_Py_Void();
49551 return resultobj;
49552 fail:
49553 return NULL;
49554 }
49555
49556
49557 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49558 PyObject *resultobj = 0;
49559 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49560 void *argp1 = 0 ;
49561 int res1 = 0 ;
49562 PyObject *swig_obj[1] ;
49563
49564 if (!args) SWIG_fail;
49565 swig_obj[0] = args;
49566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49567 if (!SWIG_IsOK(res1)) {
49568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49569 }
49570 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49571 {
49572 PyThreadState* __tstate = wxPyBeginAllowThreads();
49573 (arg1)->Realize();
49574 wxPyEndAllowThreads(__tstate);
49575 if (PyErr_Occurred()) SWIG_fail;
49576 }
49577 resultobj = SWIG_Py_Void();
49578 return resultobj;
49579 fail:
49580 return NULL;
49581 }
49582
49583
49584 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49585 PyObject *resultobj = 0;
49586 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49587 wxButton *arg2 = (wxButton *) 0 ;
49588 void *argp1 = 0 ;
49589 int res1 = 0 ;
49590 void *argp2 = 0 ;
49591 int res2 = 0 ;
49592 PyObject * obj0 = 0 ;
49593 PyObject * obj1 = 0 ;
49594 char * kwnames[] = {
49595 (char *) "self",(char *) "button", NULL
49596 };
49597
49598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49600 if (!SWIG_IsOK(res1)) {
49601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49602 }
49603 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49604 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49605 if (!SWIG_IsOK(res2)) {
49606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49607 }
49608 arg2 = reinterpret_cast< wxButton * >(argp2);
49609 {
49610 PyThreadState* __tstate = wxPyBeginAllowThreads();
49611 (arg1)->SetAffirmativeButton(arg2);
49612 wxPyEndAllowThreads(__tstate);
49613 if (PyErr_Occurred()) SWIG_fail;
49614 }
49615 resultobj = SWIG_Py_Void();
49616 return resultobj;
49617 fail:
49618 return NULL;
49619 }
49620
49621
49622 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49623 PyObject *resultobj = 0;
49624 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49625 wxButton *arg2 = (wxButton *) 0 ;
49626 void *argp1 = 0 ;
49627 int res1 = 0 ;
49628 void *argp2 = 0 ;
49629 int res2 = 0 ;
49630 PyObject * obj0 = 0 ;
49631 PyObject * obj1 = 0 ;
49632 char * kwnames[] = {
49633 (char *) "self",(char *) "button", NULL
49634 };
49635
49636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49638 if (!SWIG_IsOK(res1)) {
49639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49640 }
49641 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49642 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49643 if (!SWIG_IsOK(res2)) {
49644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49645 }
49646 arg2 = reinterpret_cast< wxButton * >(argp2);
49647 {
49648 PyThreadState* __tstate = wxPyBeginAllowThreads();
49649 (arg1)->SetNegativeButton(arg2);
49650 wxPyEndAllowThreads(__tstate);
49651 if (PyErr_Occurred()) SWIG_fail;
49652 }
49653 resultobj = SWIG_Py_Void();
49654 return resultobj;
49655 fail:
49656 return NULL;
49657 }
49658
49659
49660 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49661 PyObject *resultobj = 0;
49662 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49663 wxButton *arg2 = (wxButton *) 0 ;
49664 void *argp1 = 0 ;
49665 int res1 = 0 ;
49666 void *argp2 = 0 ;
49667 int res2 = 0 ;
49668 PyObject * obj0 = 0 ;
49669 PyObject * obj1 = 0 ;
49670 char * kwnames[] = {
49671 (char *) "self",(char *) "button", NULL
49672 };
49673
49674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49676 if (!SWIG_IsOK(res1)) {
49677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49678 }
49679 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49681 if (!SWIG_IsOK(res2)) {
49682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49683 }
49684 arg2 = reinterpret_cast< wxButton * >(argp2);
49685 {
49686 PyThreadState* __tstate = wxPyBeginAllowThreads();
49687 (arg1)->SetCancelButton(arg2);
49688 wxPyEndAllowThreads(__tstate);
49689 if (PyErr_Occurred()) SWIG_fail;
49690 }
49691 resultobj = SWIG_Py_Void();
49692 return resultobj;
49693 fail:
49694 return NULL;
49695 }
49696
49697
49698 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49699 PyObject *resultobj = 0;
49700 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49701 wxButton *result = 0 ;
49702 void *argp1 = 0 ;
49703 int res1 = 0 ;
49704 PyObject *swig_obj[1] ;
49705
49706 if (!args) SWIG_fail;
49707 swig_obj[0] = args;
49708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49709 if (!SWIG_IsOK(res1)) {
49710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49711 }
49712 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49713 {
49714 PyThreadState* __tstate = wxPyBeginAllowThreads();
49715 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49716 wxPyEndAllowThreads(__tstate);
49717 if (PyErr_Occurred()) SWIG_fail;
49718 }
49719 {
49720 resultobj = wxPyMake_wxObject(result, (bool)0);
49721 }
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49729 PyObject *resultobj = 0;
49730 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49731 wxButton *result = 0 ;
49732 void *argp1 = 0 ;
49733 int res1 = 0 ;
49734 PyObject *swig_obj[1] ;
49735
49736 if (!args) SWIG_fail;
49737 swig_obj[0] = args;
49738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49739 if (!SWIG_IsOK(res1)) {
49740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49741 }
49742 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49743 {
49744 PyThreadState* __tstate = wxPyBeginAllowThreads();
49745 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49746 wxPyEndAllowThreads(__tstate);
49747 if (PyErr_Occurred()) SWIG_fail;
49748 }
49749 {
49750 resultobj = wxPyMake_wxObject(result, (bool)0);
49751 }
49752 return resultobj;
49753 fail:
49754 return NULL;
49755 }
49756
49757
49758 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49759 PyObject *resultobj = 0;
49760 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49761 wxButton *result = 0 ;
49762 void *argp1 = 0 ;
49763 int res1 = 0 ;
49764 PyObject *swig_obj[1] ;
49765
49766 if (!args) SWIG_fail;
49767 swig_obj[0] = args;
49768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49769 if (!SWIG_IsOK(res1)) {
49770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49771 }
49772 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49773 {
49774 PyThreadState* __tstate = wxPyBeginAllowThreads();
49775 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49776 wxPyEndAllowThreads(__tstate);
49777 if (PyErr_Occurred()) SWIG_fail;
49778 }
49779 {
49780 resultobj = wxPyMake_wxObject(result, (bool)0);
49781 }
49782 return resultobj;
49783 fail:
49784 return NULL;
49785 }
49786
49787
49788 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49789 PyObject *resultobj = 0;
49790 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49791 wxButton *result = 0 ;
49792 void *argp1 = 0 ;
49793 int res1 = 0 ;
49794 PyObject *swig_obj[1] ;
49795
49796 if (!args) SWIG_fail;
49797 swig_obj[0] = args;
49798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49799 if (!SWIG_IsOK(res1)) {
49800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49801 }
49802 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49803 {
49804 PyThreadState* __tstate = wxPyBeginAllowThreads();
49805 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49806 wxPyEndAllowThreads(__tstate);
49807 if (PyErr_Occurred()) SWIG_fail;
49808 }
49809 {
49810 resultobj = wxPyMake_wxObject(result, (bool)0);
49811 }
49812 return resultobj;
49813 fail:
49814 return NULL;
49815 }
49816
49817
49818 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49819 PyObject *resultobj = 0;
49820 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49821 wxButton *result = 0 ;
49822 void *argp1 = 0 ;
49823 int res1 = 0 ;
49824 PyObject *swig_obj[1] ;
49825
49826 if (!args) SWIG_fail;
49827 swig_obj[0] = args;
49828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49829 if (!SWIG_IsOK(res1)) {
49830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49831 }
49832 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49833 {
49834 PyThreadState* __tstate = wxPyBeginAllowThreads();
49835 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49836 wxPyEndAllowThreads(__tstate);
49837 if (PyErr_Occurred()) SWIG_fail;
49838 }
49839 {
49840 resultobj = wxPyMake_wxObject(result, (bool)0);
49841 }
49842 return resultobj;
49843 fail:
49844 return NULL;
49845 }
49846
49847
49848 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49849 PyObject *obj;
49850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49851 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49852 return SWIG_Py_Void();
49853 }
49854
49855 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49856 return SWIG_Python_InitShadowInstance(args);
49857 }
49858
49859 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49860 PyObject *resultobj = 0;
49861 int arg1 = (int) 0 ;
49862 int arg2 = (int) 0 ;
49863 wxGBPosition *result = 0 ;
49864 int val1 ;
49865 int ecode1 = 0 ;
49866 int val2 ;
49867 int ecode2 = 0 ;
49868 PyObject * obj0 = 0 ;
49869 PyObject * obj1 = 0 ;
49870 char * kwnames[] = {
49871 (char *) "row",(char *) "col", NULL
49872 };
49873
49874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49875 if (obj0) {
49876 ecode1 = SWIG_AsVal_int(obj0, &val1);
49877 if (!SWIG_IsOK(ecode1)) {
49878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49879 }
49880 arg1 = static_cast< int >(val1);
49881 }
49882 if (obj1) {
49883 ecode2 = SWIG_AsVal_int(obj1, &val2);
49884 if (!SWIG_IsOK(ecode2)) {
49885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49886 }
49887 arg2 = static_cast< int >(val2);
49888 }
49889 {
49890 PyThreadState* __tstate = wxPyBeginAllowThreads();
49891 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49892 wxPyEndAllowThreads(__tstate);
49893 if (PyErr_Occurred()) SWIG_fail;
49894 }
49895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49896 return resultobj;
49897 fail:
49898 return NULL;
49899 }
49900
49901
49902 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49903 PyObject *resultobj = 0;
49904 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49905 void *argp1 = 0 ;
49906 int res1 = 0 ;
49907 PyObject *swig_obj[1] ;
49908
49909 if (!args) SWIG_fail;
49910 swig_obj[0] = args;
49911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49912 if (!SWIG_IsOK(res1)) {
49913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49914 }
49915 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49916 {
49917 PyThreadState* __tstate = wxPyBeginAllowThreads();
49918 delete arg1;
49919
49920 wxPyEndAllowThreads(__tstate);
49921 if (PyErr_Occurred()) SWIG_fail;
49922 }
49923 resultobj = SWIG_Py_Void();
49924 return resultobj;
49925 fail:
49926 return NULL;
49927 }
49928
49929
49930 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49931 PyObject *resultobj = 0;
49932 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49933 int result;
49934 void *argp1 = 0 ;
49935 int res1 = 0 ;
49936 PyObject *swig_obj[1] ;
49937
49938 if (!args) SWIG_fail;
49939 swig_obj[0] = args;
49940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49941 if (!SWIG_IsOK(res1)) {
49942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49943 }
49944 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49945 {
49946 PyThreadState* __tstate = wxPyBeginAllowThreads();
49947 result = (int)((wxGBPosition const *)arg1)->GetRow();
49948 wxPyEndAllowThreads(__tstate);
49949 if (PyErr_Occurred()) SWIG_fail;
49950 }
49951 resultobj = SWIG_From_int(static_cast< int >(result));
49952 return resultobj;
49953 fail:
49954 return NULL;
49955 }
49956
49957
49958 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49959 PyObject *resultobj = 0;
49960 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49961 int result;
49962 void *argp1 = 0 ;
49963 int res1 = 0 ;
49964 PyObject *swig_obj[1] ;
49965
49966 if (!args) SWIG_fail;
49967 swig_obj[0] = args;
49968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49969 if (!SWIG_IsOK(res1)) {
49970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49971 }
49972 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49973 {
49974 PyThreadState* __tstate = wxPyBeginAllowThreads();
49975 result = (int)((wxGBPosition const *)arg1)->GetCol();
49976 wxPyEndAllowThreads(__tstate);
49977 if (PyErr_Occurred()) SWIG_fail;
49978 }
49979 resultobj = SWIG_From_int(static_cast< int >(result));
49980 return resultobj;
49981 fail:
49982 return NULL;
49983 }
49984
49985
49986 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49987 PyObject *resultobj = 0;
49988 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49989 int arg2 ;
49990 void *argp1 = 0 ;
49991 int res1 = 0 ;
49992 int val2 ;
49993 int ecode2 = 0 ;
49994 PyObject * obj0 = 0 ;
49995 PyObject * obj1 = 0 ;
49996 char * kwnames[] = {
49997 (char *) "self",(char *) "row", NULL
49998 };
49999
50000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50002 if (!SWIG_IsOK(res1)) {
50003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50004 }
50005 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50006 ecode2 = SWIG_AsVal_int(obj1, &val2);
50007 if (!SWIG_IsOK(ecode2)) {
50008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50009 }
50010 arg2 = static_cast< int >(val2);
50011 {
50012 PyThreadState* __tstate = wxPyBeginAllowThreads();
50013 (arg1)->SetRow(arg2);
50014 wxPyEndAllowThreads(__tstate);
50015 if (PyErr_Occurred()) SWIG_fail;
50016 }
50017 resultobj = SWIG_Py_Void();
50018 return resultobj;
50019 fail:
50020 return NULL;
50021 }
50022
50023
50024 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50025 PyObject *resultobj = 0;
50026 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50027 int arg2 ;
50028 void *argp1 = 0 ;
50029 int res1 = 0 ;
50030 int val2 ;
50031 int ecode2 = 0 ;
50032 PyObject * obj0 = 0 ;
50033 PyObject * obj1 = 0 ;
50034 char * kwnames[] = {
50035 (char *) "self",(char *) "col", NULL
50036 };
50037
50038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50040 if (!SWIG_IsOK(res1)) {
50041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50042 }
50043 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50044 ecode2 = SWIG_AsVal_int(obj1, &val2);
50045 if (!SWIG_IsOK(ecode2)) {
50046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50047 }
50048 arg2 = static_cast< int >(val2);
50049 {
50050 PyThreadState* __tstate = wxPyBeginAllowThreads();
50051 (arg1)->SetCol(arg2);
50052 wxPyEndAllowThreads(__tstate);
50053 if (PyErr_Occurred()) SWIG_fail;
50054 }
50055 resultobj = SWIG_Py_Void();
50056 return resultobj;
50057 fail:
50058 return NULL;
50059 }
50060
50061
50062 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50063 PyObject *resultobj = 0;
50064 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50065 PyObject *arg2 = (PyObject *) 0 ;
50066 bool result;
50067 void *argp1 = 0 ;
50068 int res1 = 0 ;
50069 PyObject * obj0 = 0 ;
50070 PyObject * obj1 = 0 ;
50071 char * kwnames[] = {
50072 (char *) "self",(char *) "other", NULL
50073 };
50074
50075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50077 if (!SWIG_IsOK(res1)) {
50078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50079 }
50080 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50081 arg2 = obj1;
50082 {
50083 result = (bool)wxGBPosition___eq__(arg1,arg2);
50084 if (PyErr_Occurred()) SWIG_fail;
50085 }
50086 {
50087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50088 }
50089 return resultobj;
50090 fail:
50091 return NULL;
50092 }
50093
50094
50095 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50096 PyObject *resultobj = 0;
50097 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50098 PyObject *arg2 = (PyObject *) 0 ;
50099 bool result;
50100 void *argp1 = 0 ;
50101 int res1 = 0 ;
50102 PyObject * obj0 = 0 ;
50103 PyObject * obj1 = 0 ;
50104 char * kwnames[] = {
50105 (char *) "self",(char *) "other", NULL
50106 };
50107
50108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50110 if (!SWIG_IsOK(res1)) {
50111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50112 }
50113 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50114 arg2 = obj1;
50115 {
50116 result = (bool)wxGBPosition___ne__(arg1,arg2);
50117 if (PyErr_Occurred()) SWIG_fail;
50118 }
50119 {
50120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50121 }
50122 return resultobj;
50123 fail:
50124 return NULL;
50125 }
50126
50127
50128 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50129 PyObject *resultobj = 0;
50130 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50131 int arg2 = (int) 0 ;
50132 int arg3 = (int) 0 ;
50133 void *argp1 = 0 ;
50134 int res1 = 0 ;
50135 int val2 ;
50136 int ecode2 = 0 ;
50137 int val3 ;
50138 int ecode3 = 0 ;
50139 PyObject * obj0 = 0 ;
50140 PyObject * obj1 = 0 ;
50141 PyObject * obj2 = 0 ;
50142 char * kwnames[] = {
50143 (char *) "self",(char *) "row",(char *) "col", NULL
50144 };
50145
50146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50148 if (!SWIG_IsOK(res1)) {
50149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50150 }
50151 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50152 if (obj1) {
50153 ecode2 = SWIG_AsVal_int(obj1, &val2);
50154 if (!SWIG_IsOK(ecode2)) {
50155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50156 }
50157 arg2 = static_cast< int >(val2);
50158 }
50159 if (obj2) {
50160 ecode3 = SWIG_AsVal_int(obj2, &val3);
50161 if (!SWIG_IsOK(ecode3)) {
50162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50163 }
50164 arg3 = static_cast< int >(val3);
50165 }
50166 {
50167 PyThreadState* __tstate = wxPyBeginAllowThreads();
50168 wxGBPosition_Set(arg1,arg2,arg3);
50169 wxPyEndAllowThreads(__tstate);
50170 if (PyErr_Occurred()) SWIG_fail;
50171 }
50172 resultobj = SWIG_Py_Void();
50173 return resultobj;
50174 fail:
50175 return NULL;
50176 }
50177
50178
50179 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50180 PyObject *resultobj = 0;
50181 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50182 PyObject *result = 0 ;
50183 void *argp1 = 0 ;
50184 int res1 = 0 ;
50185 PyObject *swig_obj[1] ;
50186
50187 if (!args) SWIG_fail;
50188 swig_obj[0] = args;
50189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50190 if (!SWIG_IsOK(res1)) {
50191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50192 }
50193 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50194 {
50195 PyThreadState* __tstate = wxPyBeginAllowThreads();
50196 result = (PyObject *)wxGBPosition_Get(arg1);
50197 wxPyEndAllowThreads(__tstate);
50198 if (PyErr_Occurred()) SWIG_fail;
50199 }
50200 resultobj = result;
50201 return resultobj;
50202 fail:
50203 return NULL;
50204 }
50205
50206
50207 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50208 PyObject *obj;
50209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50210 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50211 return SWIG_Py_Void();
50212 }
50213
50214 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50215 return SWIG_Python_InitShadowInstance(args);
50216 }
50217
50218 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50219 PyObject *resultobj = 0;
50220 int arg1 = (int) 1 ;
50221 int arg2 = (int) 1 ;
50222 wxGBSpan *result = 0 ;
50223 int val1 ;
50224 int ecode1 = 0 ;
50225 int val2 ;
50226 int ecode2 = 0 ;
50227 PyObject * obj0 = 0 ;
50228 PyObject * obj1 = 0 ;
50229 char * kwnames[] = {
50230 (char *) "rowspan",(char *) "colspan", NULL
50231 };
50232
50233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50234 if (obj0) {
50235 ecode1 = SWIG_AsVal_int(obj0, &val1);
50236 if (!SWIG_IsOK(ecode1)) {
50237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50238 }
50239 arg1 = static_cast< int >(val1);
50240 }
50241 if (obj1) {
50242 ecode2 = SWIG_AsVal_int(obj1, &val2);
50243 if (!SWIG_IsOK(ecode2)) {
50244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50245 }
50246 arg2 = static_cast< int >(val2);
50247 }
50248 {
50249 PyThreadState* __tstate = wxPyBeginAllowThreads();
50250 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50251 wxPyEndAllowThreads(__tstate);
50252 if (PyErr_Occurred()) SWIG_fail;
50253 }
50254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50255 return resultobj;
50256 fail:
50257 return NULL;
50258 }
50259
50260
50261 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50262 PyObject *resultobj = 0;
50263 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50264 void *argp1 = 0 ;
50265 int res1 = 0 ;
50266 PyObject *swig_obj[1] ;
50267
50268 if (!args) SWIG_fail;
50269 swig_obj[0] = args;
50270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50271 if (!SWIG_IsOK(res1)) {
50272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50273 }
50274 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50275 {
50276 PyThreadState* __tstate = wxPyBeginAllowThreads();
50277 delete arg1;
50278
50279 wxPyEndAllowThreads(__tstate);
50280 if (PyErr_Occurred()) SWIG_fail;
50281 }
50282 resultobj = SWIG_Py_Void();
50283 return resultobj;
50284 fail:
50285 return NULL;
50286 }
50287
50288
50289 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50290 PyObject *resultobj = 0;
50291 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50292 int result;
50293 void *argp1 = 0 ;
50294 int res1 = 0 ;
50295 PyObject *swig_obj[1] ;
50296
50297 if (!args) SWIG_fail;
50298 swig_obj[0] = args;
50299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50300 if (!SWIG_IsOK(res1)) {
50301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50302 }
50303 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50304 {
50305 PyThreadState* __tstate = wxPyBeginAllowThreads();
50306 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50307 wxPyEndAllowThreads(__tstate);
50308 if (PyErr_Occurred()) SWIG_fail;
50309 }
50310 resultobj = SWIG_From_int(static_cast< int >(result));
50311 return resultobj;
50312 fail:
50313 return NULL;
50314 }
50315
50316
50317 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50318 PyObject *resultobj = 0;
50319 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50320 int result;
50321 void *argp1 = 0 ;
50322 int res1 = 0 ;
50323 PyObject *swig_obj[1] ;
50324
50325 if (!args) SWIG_fail;
50326 swig_obj[0] = args;
50327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50328 if (!SWIG_IsOK(res1)) {
50329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50330 }
50331 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50332 {
50333 PyThreadState* __tstate = wxPyBeginAllowThreads();
50334 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50335 wxPyEndAllowThreads(__tstate);
50336 if (PyErr_Occurred()) SWIG_fail;
50337 }
50338 resultobj = SWIG_From_int(static_cast< int >(result));
50339 return resultobj;
50340 fail:
50341 return NULL;
50342 }
50343
50344
50345 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50346 PyObject *resultobj = 0;
50347 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50348 int arg2 ;
50349 void *argp1 = 0 ;
50350 int res1 = 0 ;
50351 int val2 ;
50352 int ecode2 = 0 ;
50353 PyObject * obj0 = 0 ;
50354 PyObject * obj1 = 0 ;
50355 char * kwnames[] = {
50356 (char *) "self",(char *) "rowspan", NULL
50357 };
50358
50359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50361 if (!SWIG_IsOK(res1)) {
50362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50363 }
50364 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50365 ecode2 = SWIG_AsVal_int(obj1, &val2);
50366 if (!SWIG_IsOK(ecode2)) {
50367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50368 }
50369 arg2 = static_cast< int >(val2);
50370 {
50371 PyThreadState* __tstate = wxPyBeginAllowThreads();
50372 (arg1)->SetRowspan(arg2);
50373 wxPyEndAllowThreads(__tstate);
50374 if (PyErr_Occurred()) SWIG_fail;
50375 }
50376 resultobj = SWIG_Py_Void();
50377 return resultobj;
50378 fail:
50379 return NULL;
50380 }
50381
50382
50383 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50384 PyObject *resultobj = 0;
50385 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50386 int arg2 ;
50387 void *argp1 = 0 ;
50388 int res1 = 0 ;
50389 int val2 ;
50390 int ecode2 = 0 ;
50391 PyObject * obj0 = 0 ;
50392 PyObject * obj1 = 0 ;
50393 char * kwnames[] = {
50394 (char *) "self",(char *) "colspan", NULL
50395 };
50396
50397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50399 if (!SWIG_IsOK(res1)) {
50400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50401 }
50402 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50403 ecode2 = SWIG_AsVal_int(obj1, &val2);
50404 if (!SWIG_IsOK(ecode2)) {
50405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50406 }
50407 arg2 = static_cast< int >(val2);
50408 {
50409 PyThreadState* __tstate = wxPyBeginAllowThreads();
50410 (arg1)->SetColspan(arg2);
50411 wxPyEndAllowThreads(__tstate);
50412 if (PyErr_Occurred()) SWIG_fail;
50413 }
50414 resultobj = SWIG_Py_Void();
50415 return resultobj;
50416 fail:
50417 return NULL;
50418 }
50419
50420
50421 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50422 PyObject *resultobj = 0;
50423 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50424 PyObject *arg2 = (PyObject *) 0 ;
50425 bool result;
50426 void *argp1 = 0 ;
50427 int res1 = 0 ;
50428 PyObject * obj0 = 0 ;
50429 PyObject * obj1 = 0 ;
50430 char * kwnames[] = {
50431 (char *) "self",(char *) "other", NULL
50432 };
50433
50434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50436 if (!SWIG_IsOK(res1)) {
50437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50438 }
50439 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50440 arg2 = obj1;
50441 {
50442 result = (bool)wxGBSpan___eq__(arg1,arg2);
50443 if (PyErr_Occurred()) SWIG_fail;
50444 }
50445 {
50446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50447 }
50448 return resultobj;
50449 fail:
50450 return NULL;
50451 }
50452
50453
50454 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50455 PyObject *resultobj = 0;
50456 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50457 PyObject *arg2 = (PyObject *) 0 ;
50458 bool result;
50459 void *argp1 = 0 ;
50460 int res1 = 0 ;
50461 PyObject * obj0 = 0 ;
50462 PyObject * obj1 = 0 ;
50463 char * kwnames[] = {
50464 (char *) "self",(char *) "other", NULL
50465 };
50466
50467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50469 if (!SWIG_IsOK(res1)) {
50470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50471 }
50472 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50473 arg2 = obj1;
50474 {
50475 result = (bool)wxGBSpan___ne__(arg1,arg2);
50476 if (PyErr_Occurred()) SWIG_fail;
50477 }
50478 {
50479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50480 }
50481 return resultobj;
50482 fail:
50483 return NULL;
50484 }
50485
50486
50487 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50488 PyObject *resultobj = 0;
50489 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50490 int arg2 = (int) 1 ;
50491 int arg3 = (int) 1 ;
50492 void *argp1 = 0 ;
50493 int res1 = 0 ;
50494 int val2 ;
50495 int ecode2 = 0 ;
50496 int val3 ;
50497 int ecode3 = 0 ;
50498 PyObject * obj0 = 0 ;
50499 PyObject * obj1 = 0 ;
50500 PyObject * obj2 = 0 ;
50501 char * kwnames[] = {
50502 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50503 };
50504
50505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50507 if (!SWIG_IsOK(res1)) {
50508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50509 }
50510 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50511 if (obj1) {
50512 ecode2 = SWIG_AsVal_int(obj1, &val2);
50513 if (!SWIG_IsOK(ecode2)) {
50514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50515 }
50516 arg2 = static_cast< int >(val2);
50517 }
50518 if (obj2) {
50519 ecode3 = SWIG_AsVal_int(obj2, &val3);
50520 if (!SWIG_IsOK(ecode3)) {
50521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50522 }
50523 arg3 = static_cast< int >(val3);
50524 }
50525 {
50526 PyThreadState* __tstate = wxPyBeginAllowThreads();
50527 wxGBSpan_Set(arg1,arg2,arg3);
50528 wxPyEndAllowThreads(__tstate);
50529 if (PyErr_Occurred()) SWIG_fail;
50530 }
50531 resultobj = SWIG_Py_Void();
50532 return resultobj;
50533 fail:
50534 return NULL;
50535 }
50536
50537
50538 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50539 PyObject *resultobj = 0;
50540 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50541 PyObject *result = 0 ;
50542 void *argp1 = 0 ;
50543 int res1 = 0 ;
50544 PyObject *swig_obj[1] ;
50545
50546 if (!args) SWIG_fail;
50547 swig_obj[0] = args;
50548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50549 if (!SWIG_IsOK(res1)) {
50550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50551 }
50552 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50553 {
50554 PyThreadState* __tstate = wxPyBeginAllowThreads();
50555 result = (PyObject *)wxGBSpan_Get(arg1);
50556 wxPyEndAllowThreads(__tstate);
50557 if (PyErr_Occurred()) SWIG_fail;
50558 }
50559 resultobj = result;
50560 return resultobj;
50561 fail:
50562 return NULL;
50563 }
50564
50565
50566 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50567 PyObject *obj;
50568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50569 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50570 return SWIG_Py_Void();
50571 }
50572
50573 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50574 return SWIG_Python_InitShadowInstance(args);
50575 }
50576
50577 SWIGINTERN int DefaultSpan_set(PyObject *) {
50578 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50579 return 1;
50580 }
50581
50582
50583 SWIGINTERN PyObject *DefaultSpan_get(void) {
50584 PyObject *pyobj = 0;
50585
50586 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50587 return pyobj;
50588 }
50589
50590
50591 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50592 PyObject *resultobj = 0;
50593 wxGBSizerItem *result = 0 ;
50594
50595 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50596 {
50597 PyThreadState* __tstate = wxPyBeginAllowThreads();
50598 result = (wxGBSizerItem *)new wxGBSizerItem();
50599 wxPyEndAllowThreads(__tstate);
50600 if (PyErr_Occurred()) SWIG_fail;
50601 }
50602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50603 return resultobj;
50604 fail:
50605 return NULL;
50606 }
50607
50608
50609 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50610 PyObject *resultobj = 0;
50611 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50612 void *argp1 = 0 ;
50613 int res1 = 0 ;
50614 PyObject *swig_obj[1] ;
50615
50616 if (!args) SWIG_fail;
50617 swig_obj[0] = args;
50618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50619 if (!SWIG_IsOK(res1)) {
50620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50621 }
50622 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50623 {
50624 PyThreadState* __tstate = wxPyBeginAllowThreads();
50625 delete arg1;
50626
50627 wxPyEndAllowThreads(__tstate);
50628 if (PyErr_Occurred()) SWIG_fail;
50629 }
50630 resultobj = SWIG_Py_Void();
50631 return resultobj;
50632 fail:
50633 return NULL;
50634 }
50635
50636
50637 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50638 PyObject *resultobj = 0;
50639 wxWindow *arg1 = (wxWindow *) 0 ;
50640 wxGBPosition *arg2 = 0 ;
50641 wxGBSpan *arg3 = 0 ;
50642 int arg4 ;
50643 int arg5 ;
50644 PyObject *arg6 = (PyObject *) NULL ;
50645 wxGBSizerItem *result = 0 ;
50646 void *argp1 = 0 ;
50647 int res1 = 0 ;
50648 wxGBPosition temp2 ;
50649 wxGBSpan temp3 ;
50650 int val4 ;
50651 int ecode4 = 0 ;
50652 int val5 ;
50653 int ecode5 = 0 ;
50654 PyObject * obj0 = 0 ;
50655 PyObject * obj1 = 0 ;
50656 PyObject * obj2 = 0 ;
50657 PyObject * obj3 = 0 ;
50658 PyObject * obj4 = 0 ;
50659 PyObject * obj5 = 0 ;
50660 char * kwnames[] = {
50661 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50662 };
50663
50664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50666 if (!SWIG_IsOK(res1)) {
50667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50668 }
50669 arg1 = reinterpret_cast< wxWindow * >(argp1);
50670 {
50671 arg2 = &temp2;
50672 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50673 }
50674 {
50675 arg3 = &temp3;
50676 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50677 }
50678 ecode4 = SWIG_AsVal_int(obj3, &val4);
50679 if (!SWIG_IsOK(ecode4)) {
50680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50681 }
50682 arg4 = static_cast< int >(val4);
50683 ecode5 = SWIG_AsVal_int(obj4, &val5);
50684 if (!SWIG_IsOK(ecode5)) {
50685 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50686 }
50687 arg5 = static_cast< int >(val5);
50688 if (obj5) {
50689 arg6 = obj5;
50690 }
50691 {
50692 PyThreadState* __tstate = wxPyBeginAllowThreads();
50693 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50694 wxPyEndAllowThreads(__tstate);
50695 if (PyErr_Occurred()) SWIG_fail;
50696 }
50697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50698 return resultobj;
50699 fail:
50700 return NULL;
50701 }
50702
50703
50704 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50705 PyObject *resultobj = 0;
50706 wxSizer *arg1 = (wxSizer *) 0 ;
50707 wxGBPosition *arg2 = 0 ;
50708 wxGBSpan *arg3 = 0 ;
50709 int arg4 ;
50710 int arg5 ;
50711 PyObject *arg6 = (PyObject *) NULL ;
50712 wxGBSizerItem *result = 0 ;
50713 int res1 = 0 ;
50714 wxGBPosition temp2 ;
50715 wxGBSpan temp3 ;
50716 int val4 ;
50717 int ecode4 = 0 ;
50718 int val5 ;
50719 int ecode5 = 0 ;
50720 PyObject * obj0 = 0 ;
50721 PyObject * obj1 = 0 ;
50722 PyObject * obj2 = 0 ;
50723 PyObject * obj3 = 0 ;
50724 PyObject * obj4 = 0 ;
50725 PyObject * obj5 = 0 ;
50726 char * kwnames[] = {
50727 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50728 };
50729
50730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50731 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50732 if (!SWIG_IsOK(res1)) {
50733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50734 }
50735 {
50736 arg2 = &temp2;
50737 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50738 }
50739 {
50740 arg3 = &temp3;
50741 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50742 }
50743 ecode4 = SWIG_AsVal_int(obj3, &val4);
50744 if (!SWIG_IsOK(ecode4)) {
50745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50746 }
50747 arg4 = static_cast< int >(val4);
50748 ecode5 = SWIG_AsVal_int(obj4, &val5);
50749 if (!SWIG_IsOK(ecode5)) {
50750 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50751 }
50752 arg5 = static_cast< int >(val5);
50753 if (obj5) {
50754 arg6 = obj5;
50755 }
50756 {
50757 PyThreadState* __tstate = wxPyBeginAllowThreads();
50758 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50759 wxPyEndAllowThreads(__tstate);
50760 if (PyErr_Occurred()) SWIG_fail;
50761 }
50762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50763 return resultobj;
50764 fail:
50765 return NULL;
50766 }
50767
50768
50769 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50770 PyObject *resultobj = 0;
50771 int arg1 ;
50772 int arg2 ;
50773 wxGBPosition *arg3 = 0 ;
50774 wxGBSpan *arg4 = 0 ;
50775 int arg5 ;
50776 int arg6 ;
50777 PyObject *arg7 = (PyObject *) NULL ;
50778 wxGBSizerItem *result = 0 ;
50779 int val1 ;
50780 int ecode1 = 0 ;
50781 int val2 ;
50782 int ecode2 = 0 ;
50783 wxGBPosition temp3 ;
50784 wxGBSpan temp4 ;
50785 int val5 ;
50786 int ecode5 = 0 ;
50787 int val6 ;
50788 int ecode6 = 0 ;
50789 PyObject * obj0 = 0 ;
50790 PyObject * obj1 = 0 ;
50791 PyObject * obj2 = 0 ;
50792 PyObject * obj3 = 0 ;
50793 PyObject * obj4 = 0 ;
50794 PyObject * obj5 = 0 ;
50795 PyObject * obj6 = 0 ;
50796 char * kwnames[] = {
50797 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50798 };
50799
50800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50801 ecode1 = SWIG_AsVal_int(obj0, &val1);
50802 if (!SWIG_IsOK(ecode1)) {
50803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50804 }
50805 arg1 = static_cast< int >(val1);
50806 ecode2 = SWIG_AsVal_int(obj1, &val2);
50807 if (!SWIG_IsOK(ecode2)) {
50808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50809 }
50810 arg2 = static_cast< int >(val2);
50811 {
50812 arg3 = &temp3;
50813 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50814 }
50815 {
50816 arg4 = &temp4;
50817 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50818 }
50819 ecode5 = SWIG_AsVal_int(obj4, &val5);
50820 if (!SWIG_IsOK(ecode5)) {
50821 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50822 }
50823 arg5 = static_cast< int >(val5);
50824 ecode6 = SWIG_AsVal_int(obj5, &val6);
50825 if (!SWIG_IsOK(ecode6)) {
50826 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50827 }
50828 arg6 = static_cast< int >(val6);
50829 if (obj6) {
50830 arg7 = obj6;
50831 }
50832 {
50833 PyThreadState* __tstate = wxPyBeginAllowThreads();
50834 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50835 wxPyEndAllowThreads(__tstate);
50836 if (PyErr_Occurred()) SWIG_fail;
50837 }
50838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50839 return resultobj;
50840 fail:
50841 return NULL;
50842 }
50843
50844
50845 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50846 PyObject *resultobj = 0;
50847 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50848 wxGBPosition result;
50849 void *argp1 = 0 ;
50850 int res1 = 0 ;
50851 PyObject *swig_obj[1] ;
50852
50853 if (!args) SWIG_fail;
50854 swig_obj[0] = args;
50855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50856 if (!SWIG_IsOK(res1)) {
50857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50858 }
50859 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50860 {
50861 PyThreadState* __tstate = wxPyBeginAllowThreads();
50862 result = ((wxGBSizerItem const *)arg1)->GetPos();
50863 wxPyEndAllowThreads(__tstate);
50864 if (PyErr_Occurred()) SWIG_fail;
50865 }
50866 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50867 return resultobj;
50868 fail:
50869 return NULL;
50870 }
50871
50872
50873 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50874 PyObject *resultobj = 0;
50875 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50876 wxGBSpan result;
50877 void *argp1 = 0 ;
50878 int res1 = 0 ;
50879 PyObject *swig_obj[1] ;
50880
50881 if (!args) SWIG_fail;
50882 swig_obj[0] = args;
50883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50884 if (!SWIG_IsOK(res1)) {
50885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50886 }
50887 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50888 {
50889 PyThreadState* __tstate = wxPyBeginAllowThreads();
50890 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50891 wxPyEndAllowThreads(__tstate);
50892 if (PyErr_Occurred()) SWIG_fail;
50893 }
50894 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50895 return resultobj;
50896 fail:
50897 return NULL;
50898 }
50899
50900
50901 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50902 PyObject *resultobj = 0;
50903 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50904 wxGBPosition *arg2 = 0 ;
50905 bool result;
50906 void *argp1 = 0 ;
50907 int res1 = 0 ;
50908 wxGBPosition temp2 ;
50909 PyObject * obj0 = 0 ;
50910 PyObject * obj1 = 0 ;
50911 char * kwnames[] = {
50912 (char *) "self",(char *) "pos", NULL
50913 };
50914
50915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50917 if (!SWIG_IsOK(res1)) {
50918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50919 }
50920 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50921 {
50922 arg2 = &temp2;
50923 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50924 }
50925 {
50926 PyThreadState* __tstate = wxPyBeginAllowThreads();
50927 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50928 wxPyEndAllowThreads(__tstate);
50929 if (PyErr_Occurred()) SWIG_fail;
50930 }
50931 {
50932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50933 }
50934 return resultobj;
50935 fail:
50936 return NULL;
50937 }
50938
50939
50940 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50941 PyObject *resultobj = 0;
50942 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50943 wxGBSpan *arg2 = 0 ;
50944 bool result;
50945 void *argp1 = 0 ;
50946 int res1 = 0 ;
50947 wxGBSpan temp2 ;
50948 PyObject * obj0 = 0 ;
50949 PyObject * obj1 = 0 ;
50950 char * kwnames[] = {
50951 (char *) "self",(char *) "span", NULL
50952 };
50953
50954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50956 if (!SWIG_IsOK(res1)) {
50957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50958 }
50959 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50960 {
50961 arg2 = &temp2;
50962 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50963 }
50964 {
50965 PyThreadState* __tstate = wxPyBeginAllowThreads();
50966 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50967 wxPyEndAllowThreads(__tstate);
50968 if (PyErr_Occurred()) SWIG_fail;
50969 }
50970 {
50971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50972 }
50973 return resultobj;
50974 fail:
50975 return NULL;
50976 }
50977
50978
50979 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50980 PyObject *resultobj = 0;
50981 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50982 wxGBSizerItem *arg2 = 0 ;
50983 bool result;
50984 void *argp1 = 0 ;
50985 int res1 = 0 ;
50986 void *argp2 = 0 ;
50987 int res2 = 0 ;
50988 PyObject * obj0 = 0 ;
50989 PyObject * obj1 = 0 ;
50990 char * kwnames[] = {
50991 (char *) "self",(char *) "other", NULL
50992 };
50993
50994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50996 if (!SWIG_IsOK(res1)) {
50997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50998 }
50999 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51000 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51001 if (!SWIG_IsOK(res2)) {
51002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51003 }
51004 if (!argp2) {
51005 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51006 }
51007 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51008 {
51009 PyThreadState* __tstate = wxPyBeginAllowThreads();
51010 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51011 wxPyEndAllowThreads(__tstate);
51012 if (PyErr_Occurred()) SWIG_fail;
51013 }
51014 {
51015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51016 }
51017 return resultobj;
51018 fail:
51019 return NULL;
51020 }
51021
51022
51023 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51024 PyObject *resultobj = 0;
51025 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51026 wxGBPosition *arg2 = 0 ;
51027 wxGBSpan *arg3 = 0 ;
51028 bool result;
51029 void *argp1 = 0 ;
51030 int res1 = 0 ;
51031 wxGBPosition temp2 ;
51032 wxGBSpan temp3 ;
51033 PyObject * obj0 = 0 ;
51034 PyObject * obj1 = 0 ;
51035 PyObject * obj2 = 0 ;
51036 char * kwnames[] = {
51037 (char *) "self",(char *) "pos",(char *) "span", NULL
51038 };
51039
51040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51042 if (!SWIG_IsOK(res1)) {
51043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51044 }
51045 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51046 {
51047 arg2 = &temp2;
51048 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51049 }
51050 {
51051 arg3 = &temp3;
51052 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51053 }
51054 {
51055 PyThreadState* __tstate = wxPyBeginAllowThreads();
51056 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51057 wxPyEndAllowThreads(__tstate);
51058 if (PyErr_Occurred()) SWIG_fail;
51059 }
51060 {
51061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51062 }
51063 return resultobj;
51064 fail:
51065 return NULL;
51066 }
51067
51068
51069 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51070 PyObject *resultobj = 0;
51071 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51072 wxGBPosition result;
51073 void *argp1 = 0 ;
51074 int res1 = 0 ;
51075 PyObject *swig_obj[1] ;
51076
51077 if (!args) SWIG_fail;
51078 swig_obj[0] = args;
51079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51080 if (!SWIG_IsOK(res1)) {
51081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51082 }
51083 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51084 {
51085 PyThreadState* __tstate = wxPyBeginAllowThreads();
51086 result = wxGBSizerItem_GetEndPos(arg1);
51087 wxPyEndAllowThreads(__tstate);
51088 if (PyErr_Occurred()) SWIG_fail;
51089 }
51090 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51091 return resultobj;
51092 fail:
51093 return NULL;
51094 }
51095
51096
51097 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51098 PyObject *resultobj = 0;
51099 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51100 wxGridBagSizer *result = 0 ;
51101 void *argp1 = 0 ;
51102 int res1 = 0 ;
51103 PyObject *swig_obj[1] ;
51104
51105 if (!args) SWIG_fail;
51106 swig_obj[0] = args;
51107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51108 if (!SWIG_IsOK(res1)) {
51109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51110 }
51111 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51112 {
51113 PyThreadState* __tstate = wxPyBeginAllowThreads();
51114 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51115 wxPyEndAllowThreads(__tstate);
51116 if (PyErr_Occurred()) SWIG_fail;
51117 }
51118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51119 return resultobj;
51120 fail:
51121 return NULL;
51122 }
51123
51124
51125 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51126 PyObject *resultobj = 0;
51127 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51128 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51129 void *argp1 = 0 ;
51130 int res1 = 0 ;
51131 void *argp2 = 0 ;
51132 int res2 = 0 ;
51133 PyObject * obj0 = 0 ;
51134 PyObject * obj1 = 0 ;
51135 char * kwnames[] = {
51136 (char *) "self",(char *) "sizer", NULL
51137 };
51138
51139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51141 if (!SWIG_IsOK(res1)) {
51142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51143 }
51144 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51146 if (!SWIG_IsOK(res2)) {
51147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51148 }
51149 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51150 {
51151 PyThreadState* __tstate = wxPyBeginAllowThreads();
51152 (arg1)->SetGBSizer(arg2);
51153 wxPyEndAllowThreads(__tstate);
51154 if (PyErr_Occurred()) SWIG_fail;
51155 }
51156 resultobj = SWIG_Py_Void();
51157 return resultobj;
51158 fail:
51159 return NULL;
51160 }
51161
51162
51163 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51164 PyObject *obj;
51165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51166 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51167 return SWIG_Py_Void();
51168 }
51169
51170 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51171 return SWIG_Python_InitShadowInstance(args);
51172 }
51173
51174 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51175 PyObject *resultobj = 0;
51176 int arg1 = (int) 0 ;
51177 int arg2 = (int) 0 ;
51178 wxGridBagSizer *result = 0 ;
51179 int val1 ;
51180 int ecode1 = 0 ;
51181 int val2 ;
51182 int ecode2 = 0 ;
51183 PyObject * obj0 = 0 ;
51184 PyObject * obj1 = 0 ;
51185 char * kwnames[] = {
51186 (char *) "vgap",(char *) "hgap", NULL
51187 };
51188
51189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51190 if (obj0) {
51191 ecode1 = SWIG_AsVal_int(obj0, &val1);
51192 if (!SWIG_IsOK(ecode1)) {
51193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51194 }
51195 arg1 = static_cast< int >(val1);
51196 }
51197 if (obj1) {
51198 ecode2 = SWIG_AsVal_int(obj1, &val2);
51199 if (!SWIG_IsOK(ecode2)) {
51200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51201 }
51202 arg2 = static_cast< int >(val2);
51203 }
51204 {
51205 PyThreadState* __tstate = wxPyBeginAllowThreads();
51206 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51207 wxPyEndAllowThreads(__tstate);
51208 if (PyErr_Occurred()) SWIG_fail;
51209 }
51210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51211 return resultobj;
51212 fail:
51213 return NULL;
51214 }
51215
51216
51217 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51218 PyObject *resultobj = 0;
51219 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51220 PyObject *arg2 = (PyObject *) 0 ;
51221 wxGBPosition *arg3 = 0 ;
51222 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51223 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51224 int arg5 = (int) 0 ;
51225 int arg6 = (int) 0 ;
51226 PyObject *arg7 = (PyObject *) NULL ;
51227 wxGBSizerItem *result = 0 ;
51228 void *argp1 = 0 ;
51229 int res1 = 0 ;
51230 wxGBPosition temp3 ;
51231 wxGBSpan temp4 ;
51232 int val5 ;
51233 int ecode5 = 0 ;
51234 int val6 ;
51235 int ecode6 = 0 ;
51236 PyObject * obj0 = 0 ;
51237 PyObject * obj1 = 0 ;
51238 PyObject * obj2 = 0 ;
51239 PyObject * obj3 = 0 ;
51240 PyObject * obj4 = 0 ;
51241 PyObject * obj5 = 0 ;
51242 PyObject * obj6 = 0 ;
51243 char * kwnames[] = {
51244 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51245 };
51246
51247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51249 if (!SWIG_IsOK(res1)) {
51250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51251 }
51252 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51253 arg2 = obj1;
51254 {
51255 arg3 = &temp3;
51256 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51257 }
51258 if (obj3) {
51259 {
51260 arg4 = &temp4;
51261 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51262 }
51263 }
51264 if (obj4) {
51265 ecode5 = SWIG_AsVal_int(obj4, &val5);
51266 if (!SWIG_IsOK(ecode5)) {
51267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51268 }
51269 arg5 = static_cast< int >(val5);
51270 }
51271 if (obj5) {
51272 ecode6 = SWIG_AsVal_int(obj5, &val6);
51273 if (!SWIG_IsOK(ecode6)) {
51274 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51275 }
51276 arg6 = static_cast< int >(val6);
51277 }
51278 if (obj6) {
51279 arg7 = obj6;
51280 }
51281 {
51282 PyThreadState* __tstate = wxPyBeginAllowThreads();
51283 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51284 wxPyEndAllowThreads(__tstate);
51285 if (PyErr_Occurred()) SWIG_fail;
51286 }
51287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51288 return resultobj;
51289 fail:
51290 return NULL;
51291 }
51292
51293
51294 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51295 PyObject *resultobj = 0;
51296 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51297 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51298 wxGBSizerItem *result = 0 ;
51299 void *argp1 = 0 ;
51300 int res1 = 0 ;
51301 int res2 = 0 ;
51302 PyObject * obj0 = 0 ;
51303 PyObject * obj1 = 0 ;
51304 char * kwnames[] = {
51305 (char *) "self",(char *) "item", NULL
51306 };
51307
51308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51310 if (!SWIG_IsOK(res1)) {
51311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51312 }
51313 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51314 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51315 if (!SWIG_IsOK(res2)) {
51316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51317 }
51318 {
51319 PyThreadState* __tstate = wxPyBeginAllowThreads();
51320 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51321 wxPyEndAllowThreads(__tstate);
51322 if (PyErr_Occurred()) SWIG_fail;
51323 }
51324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51325 return resultobj;
51326 fail:
51327 return NULL;
51328 }
51329
51330
51331 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51332 PyObject *resultobj = 0;
51333 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51334 int arg2 ;
51335 int arg3 ;
51336 wxSize result;
51337 void *argp1 = 0 ;
51338 int res1 = 0 ;
51339 int val2 ;
51340 int ecode2 = 0 ;
51341 int val3 ;
51342 int ecode3 = 0 ;
51343 PyObject * obj0 = 0 ;
51344 PyObject * obj1 = 0 ;
51345 PyObject * obj2 = 0 ;
51346 char * kwnames[] = {
51347 (char *) "self",(char *) "row",(char *) "col", NULL
51348 };
51349
51350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51352 if (!SWIG_IsOK(res1)) {
51353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51354 }
51355 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51356 ecode2 = SWIG_AsVal_int(obj1, &val2);
51357 if (!SWIG_IsOK(ecode2)) {
51358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51359 }
51360 arg2 = static_cast< int >(val2);
51361 ecode3 = SWIG_AsVal_int(obj2, &val3);
51362 if (!SWIG_IsOK(ecode3)) {
51363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51364 }
51365 arg3 = static_cast< int >(val3);
51366 {
51367 PyThreadState* __tstate = wxPyBeginAllowThreads();
51368 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51369 wxPyEndAllowThreads(__tstate);
51370 if (PyErr_Occurred()) SWIG_fail;
51371 }
51372 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51373 return resultobj;
51374 fail:
51375 return NULL;
51376 }
51377
51378
51379 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51380 PyObject *resultobj = 0;
51381 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51382 wxSize result;
51383 void *argp1 = 0 ;
51384 int res1 = 0 ;
51385 PyObject *swig_obj[1] ;
51386
51387 if (!args) SWIG_fail;
51388 swig_obj[0] = args;
51389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51390 if (!SWIG_IsOK(res1)) {
51391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51392 }
51393 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51394 {
51395 PyThreadState* __tstate = wxPyBeginAllowThreads();
51396 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51397 wxPyEndAllowThreads(__tstate);
51398 if (PyErr_Occurred()) SWIG_fail;
51399 }
51400 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51401 return resultobj;
51402 fail:
51403 return NULL;
51404 }
51405
51406
51407 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51408 PyObject *resultobj = 0;
51409 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51410 wxSize *arg2 = 0 ;
51411 void *argp1 = 0 ;
51412 int res1 = 0 ;
51413 wxSize temp2 ;
51414 PyObject * obj0 = 0 ;
51415 PyObject * obj1 = 0 ;
51416 char * kwnames[] = {
51417 (char *) "self",(char *) "sz", NULL
51418 };
51419
51420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51422 if (!SWIG_IsOK(res1)) {
51423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51424 }
51425 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51426 {
51427 arg2 = &temp2;
51428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51429 }
51430 {
51431 PyThreadState* __tstate = wxPyBeginAllowThreads();
51432 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51433 wxPyEndAllowThreads(__tstate);
51434 if (PyErr_Occurred()) SWIG_fail;
51435 }
51436 resultobj = SWIG_Py_Void();
51437 return resultobj;
51438 fail:
51439 return NULL;
51440 }
51441
51442
51443 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51444 PyObject *resultobj = 0;
51445 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51446 wxWindow *arg2 = (wxWindow *) 0 ;
51447 wxGBPosition result;
51448 void *argp1 = 0 ;
51449 int res1 = 0 ;
51450 void *argp2 = 0 ;
51451 int res2 = 0 ;
51452
51453 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51455 if (!SWIG_IsOK(res1)) {
51456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51457 }
51458 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51459 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51460 if (!SWIG_IsOK(res2)) {
51461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51462 }
51463 arg2 = reinterpret_cast< wxWindow * >(argp2);
51464 {
51465 PyThreadState* __tstate = wxPyBeginAllowThreads();
51466 result = (arg1)->GetItemPosition(arg2);
51467 wxPyEndAllowThreads(__tstate);
51468 if (PyErr_Occurred()) SWIG_fail;
51469 }
51470 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51471 return resultobj;
51472 fail:
51473 return NULL;
51474 }
51475
51476
51477 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51478 PyObject *resultobj = 0;
51479 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51480 wxSizer *arg2 = (wxSizer *) 0 ;
51481 wxGBPosition result;
51482 void *argp1 = 0 ;
51483 int res1 = 0 ;
51484 void *argp2 = 0 ;
51485 int res2 = 0 ;
51486
51487 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51489 if (!SWIG_IsOK(res1)) {
51490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51491 }
51492 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51493 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51494 if (!SWIG_IsOK(res2)) {
51495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51496 }
51497 arg2 = reinterpret_cast< wxSizer * >(argp2);
51498 {
51499 PyThreadState* __tstate = wxPyBeginAllowThreads();
51500 result = (arg1)->GetItemPosition(arg2);
51501 wxPyEndAllowThreads(__tstate);
51502 if (PyErr_Occurred()) SWIG_fail;
51503 }
51504 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51505 return resultobj;
51506 fail:
51507 return NULL;
51508 }
51509
51510
51511 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51512 PyObject *resultobj = 0;
51513 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51514 size_t arg2 ;
51515 wxGBPosition result;
51516 void *argp1 = 0 ;
51517 int res1 = 0 ;
51518 size_t val2 ;
51519 int ecode2 = 0 ;
51520
51521 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51523 if (!SWIG_IsOK(res1)) {
51524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51525 }
51526 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51527 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51528 if (!SWIG_IsOK(ecode2)) {
51529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51530 }
51531 arg2 = static_cast< size_t >(val2);
51532 {
51533 PyThreadState* __tstate = wxPyBeginAllowThreads();
51534 result = (arg1)->GetItemPosition(arg2);
51535 wxPyEndAllowThreads(__tstate);
51536 if (PyErr_Occurred()) SWIG_fail;
51537 }
51538 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51539 return resultobj;
51540 fail:
51541 return NULL;
51542 }
51543
51544
51545 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51546 int argc;
51547 PyObject *argv[3];
51548
51549 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51550 --argc;
51551 if (argc == 2) {
51552 int _v = 0;
51553 {
51554 void *vptr = 0;
51555 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51556 _v = SWIG_CheckState(res);
51557 }
51558 if (!_v) goto check_1;
51559 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51560 }
51561 check_1:
51562
51563 if (argc == 2) {
51564 int _v = 0;
51565 {
51566 void *vptr = 0;
51567 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51568 _v = SWIG_CheckState(res);
51569 }
51570 if (!_v) goto check_2;
51571 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51572 }
51573 check_2:
51574
51575 if (argc == 2) {
51576 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51577 }
51578
51579 fail:
51580 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51581 return NULL;
51582 }
51583
51584
51585 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51586 PyObject *resultobj = 0;
51587 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51588 wxWindow *arg2 = (wxWindow *) 0 ;
51589 wxGBPosition *arg3 = 0 ;
51590 bool result;
51591 void *argp1 = 0 ;
51592 int res1 = 0 ;
51593 void *argp2 = 0 ;
51594 int res2 = 0 ;
51595 wxGBPosition temp3 ;
51596
51597 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51599 if (!SWIG_IsOK(res1)) {
51600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51601 }
51602 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51603 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51604 if (!SWIG_IsOK(res2)) {
51605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51606 }
51607 arg2 = reinterpret_cast< wxWindow * >(argp2);
51608 {
51609 arg3 = &temp3;
51610 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51611 }
51612 {
51613 PyThreadState* __tstate = wxPyBeginAllowThreads();
51614 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51615 wxPyEndAllowThreads(__tstate);
51616 if (PyErr_Occurred()) SWIG_fail;
51617 }
51618 {
51619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51620 }
51621 return resultobj;
51622 fail:
51623 return NULL;
51624 }
51625
51626
51627 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51628 PyObject *resultobj = 0;
51629 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51630 wxSizer *arg2 = (wxSizer *) 0 ;
51631 wxGBPosition *arg3 = 0 ;
51632 bool result;
51633 void *argp1 = 0 ;
51634 int res1 = 0 ;
51635 void *argp2 = 0 ;
51636 int res2 = 0 ;
51637 wxGBPosition temp3 ;
51638
51639 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51641 if (!SWIG_IsOK(res1)) {
51642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51643 }
51644 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51645 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51646 if (!SWIG_IsOK(res2)) {
51647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51648 }
51649 arg2 = reinterpret_cast< wxSizer * >(argp2);
51650 {
51651 arg3 = &temp3;
51652 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51653 }
51654 {
51655 PyThreadState* __tstate = wxPyBeginAllowThreads();
51656 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51657 wxPyEndAllowThreads(__tstate);
51658 if (PyErr_Occurred()) SWIG_fail;
51659 }
51660 {
51661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51662 }
51663 return resultobj;
51664 fail:
51665 return NULL;
51666 }
51667
51668
51669 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51670 PyObject *resultobj = 0;
51671 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51672 size_t arg2 ;
51673 wxGBPosition *arg3 = 0 ;
51674 bool result;
51675 void *argp1 = 0 ;
51676 int res1 = 0 ;
51677 size_t val2 ;
51678 int ecode2 = 0 ;
51679 wxGBPosition temp3 ;
51680
51681 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51683 if (!SWIG_IsOK(res1)) {
51684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51685 }
51686 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51687 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51688 if (!SWIG_IsOK(ecode2)) {
51689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51690 }
51691 arg2 = static_cast< size_t >(val2);
51692 {
51693 arg3 = &temp3;
51694 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51695 }
51696 {
51697 PyThreadState* __tstate = wxPyBeginAllowThreads();
51698 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51699 wxPyEndAllowThreads(__tstate);
51700 if (PyErr_Occurred()) SWIG_fail;
51701 }
51702 {
51703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51704 }
51705 return resultobj;
51706 fail:
51707 return NULL;
51708 }
51709
51710
51711 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51712 int argc;
51713 PyObject *argv[4];
51714
51715 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51716 --argc;
51717 if (argc == 3) {
51718 int _v = 0;
51719 {
51720 void *vptr = 0;
51721 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51722 _v = SWIG_CheckState(res);
51723 }
51724 if (!_v) goto check_1;
51725 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51726 }
51727 check_1:
51728
51729 if (argc == 3) {
51730 int _v = 0;
51731 {
51732 void *vptr = 0;
51733 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51734 _v = SWIG_CheckState(res);
51735 }
51736 if (!_v) goto check_2;
51737 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51738 }
51739 check_2:
51740
51741 if (argc == 3) {
51742 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51743 }
51744
51745 fail:
51746 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51747 return NULL;
51748 }
51749
51750
51751 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51752 PyObject *resultobj = 0;
51753 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51754 wxWindow *arg2 = (wxWindow *) 0 ;
51755 wxGBSpan result;
51756 void *argp1 = 0 ;
51757 int res1 = 0 ;
51758 void *argp2 = 0 ;
51759 int res2 = 0 ;
51760
51761 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51763 if (!SWIG_IsOK(res1)) {
51764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51765 }
51766 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51767 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51768 if (!SWIG_IsOK(res2)) {
51769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51770 }
51771 arg2 = reinterpret_cast< wxWindow * >(argp2);
51772 {
51773 PyThreadState* __tstate = wxPyBeginAllowThreads();
51774 result = (arg1)->GetItemSpan(arg2);
51775 wxPyEndAllowThreads(__tstate);
51776 if (PyErr_Occurred()) SWIG_fail;
51777 }
51778 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51779 return resultobj;
51780 fail:
51781 return NULL;
51782 }
51783
51784
51785 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51786 PyObject *resultobj = 0;
51787 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51788 wxSizer *arg2 = (wxSizer *) 0 ;
51789 wxGBSpan result;
51790 void *argp1 = 0 ;
51791 int res1 = 0 ;
51792 void *argp2 = 0 ;
51793 int res2 = 0 ;
51794
51795 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51797 if (!SWIG_IsOK(res1)) {
51798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51799 }
51800 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51801 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51802 if (!SWIG_IsOK(res2)) {
51803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51804 }
51805 arg2 = reinterpret_cast< wxSizer * >(argp2);
51806 {
51807 PyThreadState* __tstate = wxPyBeginAllowThreads();
51808 result = (arg1)->GetItemSpan(arg2);
51809 wxPyEndAllowThreads(__tstate);
51810 if (PyErr_Occurred()) SWIG_fail;
51811 }
51812 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51813 return resultobj;
51814 fail:
51815 return NULL;
51816 }
51817
51818
51819 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51820 PyObject *resultobj = 0;
51821 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51822 size_t arg2 ;
51823 wxGBSpan result;
51824 void *argp1 = 0 ;
51825 int res1 = 0 ;
51826 size_t val2 ;
51827 int ecode2 = 0 ;
51828
51829 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51831 if (!SWIG_IsOK(res1)) {
51832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51833 }
51834 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51835 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51836 if (!SWIG_IsOK(ecode2)) {
51837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51838 }
51839 arg2 = static_cast< size_t >(val2);
51840 {
51841 PyThreadState* __tstate = wxPyBeginAllowThreads();
51842 result = (arg1)->GetItemSpan(arg2);
51843 wxPyEndAllowThreads(__tstate);
51844 if (PyErr_Occurred()) SWIG_fail;
51845 }
51846 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51847 return resultobj;
51848 fail:
51849 return NULL;
51850 }
51851
51852
51853 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51854 int argc;
51855 PyObject *argv[3];
51856
51857 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51858 --argc;
51859 if (argc == 2) {
51860 int _v = 0;
51861 {
51862 void *vptr = 0;
51863 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51864 _v = SWIG_CheckState(res);
51865 }
51866 if (!_v) goto check_1;
51867 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51868 }
51869 check_1:
51870
51871 if (argc == 2) {
51872 int _v = 0;
51873 {
51874 void *vptr = 0;
51875 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51876 _v = SWIG_CheckState(res);
51877 }
51878 if (!_v) goto check_2;
51879 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51880 }
51881 check_2:
51882
51883 if (argc == 2) {
51884 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51885 }
51886
51887 fail:
51888 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51889 return NULL;
51890 }
51891
51892
51893 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51894 PyObject *resultobj = 0;
51895 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51896 wxWindow *arg2 = (wxWindow *) 0 ;
51897 wxGBSpan *arg3 = 0 ;
51898 bool result;
51899 void *argp1 = 0 ;
51900 int res1 = 0 ;
51901 void *argp2 = 0 ;
51902 int res2 = 0 ;
51903 wxGBSpan temp3 ;
51904
51905 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51907 if (!SWIG_IsOK(res1)) {
51908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51909 }
51910 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51911 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51912 if (!SWIG_IsOK(res2)) {
51913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51914 }
51915 arg2 = reinterpret_cast< wxWindow * >(argp2);
51916 {
51917 arg3 = &temp3;
51918 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51919 }
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 {
51927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51928 }
51929 return resultobj;
51930 fail:
51931 return NULL;
51932 }
51933
51934
51935 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51936 PyObject *resultobj = 0;
51937 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51938 wxSizer *arg2 = (wxSizer *) 0 ;
51939 wxGBSpan *arg3 = 0 ;
51940 bool result;
51941 void *argp1 = 0 ;
51942 int res1 = 0 ;
51943 void *argp2 = 0 ;
51944 int res2 = 0 ;
51945 wxGBSpan temp3 ;
51946
51947 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51949 if (!SWIG_IsOK(res1)) {
51950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51951 }
51952 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51953 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51954 if (!SWIG_IsOK(res2)) {
51955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51956 }
51957 arg2 = reinterpret_cast< wxSizer * >(argp2);
51958 {
51959 arg3 = &temp3;
51960 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51961 }
51962 {
51963 PyThreadState* __tstate = wxPyBeginAllowThreads();
51964 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51965 wxPyEndAllowThreads(__tstate);
51966 if (PyErr_Occurred()) SWIG_fail;
51967 }
51968 {
51969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51970 }
51971 return resultobj;
51972 fail:
51973 return NULL;
51974 }
51975
51976
51977 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51978 PyObject *resultobj = 0;
51979 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51980 size_t arg2 ;
51981 wxGBSpan *arg3 = 0 ;
51982 bool result;
51983 void *argp1 = 0 ;
51984 int res1 = 0 ;
51985 size_t val2 ;
51986 int ecode2 = 0 ;
51987 wxGBSpan temp3 ;
51988
51989 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51991 if (!SWIG_IsOK(res1)) {
51992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51993 }
51994 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51995 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51996 if (!SWIG_IsOK(ecode2)) {
51997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51998 }
51999 arg2 = static_cast< size_t >(val2);
52000 {
52001 arg3 = &temp3;
52002 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52003 }
52004 {
52005 PyThreadState* __tstate = wxPyBeginAllowThreads();
52006 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52007 wxPyEndAllowThreads(__tstate);
52008 if (PyErr_Occurred()) SWIG_fail;
52009 }
52010 {
52011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52012 }
52013 return resultobj;
52014 fail:
52015 return NULL;
52016 }
52017
52018
52019 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52020 int argc;
52021 PyObject *argv[4];
52022
52023 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52024 --argc;
52025 if (argc == 3) {
52026 int _v = 0;
52027 {
52028 void *vptr = 0;
52029 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52030 _v = SWIG_CheckState(res);
52031 }
52032 if (!_v) goto check_1;
52033 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52034 }
52035 check_1:
52036
52037 if (argc == 3) {
52038 int _v = 0;
52039 {
52040 void *vptr = 0;
52041 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52042 _v = SWIG_CheckState(res);
52043 }
52044 if (!_v) goto check_2;
52045 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52046 }
52047 check_2:
52048
52049 if (argc == 3) {
52050 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52051 }
52052
52053 fail:
52054 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52055 return NULL;
52056 }
52057
52058
52059 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52060 PyObject *resultobj = 0;
52061 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52062 wxWindow *arg2 = (wxWindow *) 0 ;
52063 wxGBSizerItem *result = 0 ;
52064 void *argp1 = 0 ;
52065 int res1 = 0 ;
52066 void *argp2 = 0 ;
52067 int res2 = 0 ;
52068
52069 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52071 if (!SWIG_IsOK(res1)) {
52072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52073 }
52074 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52075 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52076 if (!SWIG_IsOK(res2)) {
52077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52078 }
52079 arg2 = reinterpret_cast< wxWindow * >(argp2);
52080 {
52081 PyThreadState* __tstate = wxPyBeginAllowThreads();
52082 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52083 wxPyEndAllowThreads(__tstate);
52084 if (PyErr_Occurred()) SWIG_fail;
52085 }
52086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52087 return resultobj;
52088 fail:
52089 return NULL;
52090 }
52091
52092
52093 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52094 PyObject *resultobj = 0;
52095 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52096 wxSizer *arg2 = (wxSizer *) 0 ;
52097 wxGBSizerItem *result = 0 ;
52098 void *argp1 = 0 ;
52099 int res1 = 0 ;
52100 void *argp2 = 0 ;
52101 int res2 = 0 ;
52102
52103 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52105 if (!SWIG_IsOK(res1)) {
52106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52107 }
52108 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52109 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52110 if (!SWIG_IsOK(res2)) {
52111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52112 }
52113 arg2 = reinterpret_cast< wxSizer * >(argp2);
52114 {
52115 PyThreadState* __tstate = wxPyBeginAllowThreads();
52116 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52117 wxPyEndAllowThreads(__tstate);
52118 if (PyErr_Occurred()) SWIG_fail;
52119 }
52120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52121 return resultobj;
52122 fail:
52123 return NULL;
52124 }
52125
52126
52127 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52128 int argc;
52129 PyObject *argv[3];
52130
52131 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52132 --argc;
52133 if (argc == 2) {
52134 int _v = 0;
52135 {
52136 void *vptr = 0;
52137 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52138 _v = SWIG_CheckState(res);
52139 }
52140 if (!_v) goto check_1;
52141 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52142 }
52143 check_1:
52144
52145 if (argc == 2) {
52146 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52147 }
52148
52149 fail:
52150 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52151 return NULL;
52152 }
52153
52154
52155 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52156 PyObject *resultobj = 0;
52157 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52158 wxGBPosition *arg2 = 0 ;
52159 wxGBSizerItem *result = 0 ;
52160 void *argp1 = 0 ;
52161 int res1 = 0 ;
52162 wxGBPosition temp2 ;
52163 PyObject * obj0 = 0 ;
52164 PyObject * obj1 = 0 ;
52165 char * kwnames[] = {
52166 (char *) "self",(char *) "pos", NULL
52167 };
52168
52169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52171 if (!SWIG_IsOK(res1)) {
52172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52173 }
52174 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52175 {
52176 arg2 = &temp2;
52177 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52178 }
52179 {
52180 PyThreadState* __tstate = wxPyBeginAllowThreads();
52181 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52182 wxPyEndAllowThreads(__tstate);
52183 if (PyErr_Occurred()) SWIG_fail;
52184 }
52185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52186 return resultobj;
52187 fail:
52188 return NULL;
52189 }
52190
52191
52192 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52193 PyObject *resultobj = 0;
52194 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52195 wxPoint *arg2 = 0 ;
52196 wxGBSizerItem *result = 0 ;
52197 void *argp1 = 0 ;
52198 int res1 = 0 ;
52199 wxPoint temp2 ;
52200 PyObject * obj0 = 0 ;
52201 PyObject * obj1 = 0 ;
52202 char * kwnames[] = {
52203 (char *) "self",(char *) "pt", NULL
52204 };
52205
52206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52208 if (!SWIG_IsOK(res1)) {
52209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52210 }
52211 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52212 {
52213 arg2 = &temp2;
52214 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52215 }
52216 {
52217 PyThreadState* __tstate = wxPyBeginAllowThreads();
52218 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52219 wxPyEndAllowThreads(__tstate);
52220 if (PyErr_Occurred()) SWIG_fail;
52221 }
52222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52223 return resultobj;
52224 fail:
52225 return NULL;
52226 }
52227
52228
52229 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52230 PyObject *resultobj = 0;
52231 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52232 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52233 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52234 bool result;
52235 void *argp1 = 0 ;
52236 int res1 = 0 ;
52237 void *argp2 = 0 ;
52238 int res2 = 0 ;
52239 void *argp3 = 0 ;
52240 int res3 = 0 ;
52241 PyObject * obj0 = 0 ;
52242 PyObject * obj1 = 0 ;
52243 PyObject * obj2 = 0 ;
52244 char * kwnames[] = {
52245 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52246 };
52247
52248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52250 if (!SWIG_IsOK(res1)) {
52251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52252 }
52253 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52255 if (!SWIG_IsOK(res2)) {
52256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52257 }
52258 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52259 if (obj2) {
52260 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52261 if (!SWIG_IsOK(res3)) {
52262 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52263 }
52264 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52265 }
52266 {
52267 PyThreadState* __tstate = wxPyBeginAllowThreads();
52268 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52269 wxPyEndAllowThreads(__tstate);
52270 if (PyErr_Occurred()) SWIG_fail;
52271 }
52272 {
52273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52274 }
52275 return resultobj;
52276 fail:
52277 return NULL;
52278 }
52279
52280
52281 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52282 PyObject *resultobj = 0;
52283 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52284 wxGBPosition *arg2 = 0 ;
52285 wxGBSpan *arg3 = 0 ;
52286 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52287 bool result;
52288 void *argp1 = 0 ;
52289 int res1 = 0 ;
52290 wxGBPosition temp2 ;
52291 wxGBSpan temp3 ;
52292 void *argp4 = 0 ;
52293 int res4 = 0 ;
52294 PyObject * obj0 = 0 ;
52295 PyObject * obj1 = 0 ;
52296 PyObject * obj2 = 0 ;
52297 PyObject * obj3 = 0 ;
52298 char * kwnames[] = {
52299 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52300 };
52301
52302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52304 if (!SWIG_IsOK(res1)) {
52305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52306 }
52307 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52308 {
52309 arg2 = &temp2;
52310 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52311 }
52312 {
52313 arg3 = &temp3;
52314 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52315 }
52316 if (obj3) {
52317 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52318 if (!SWIG_IsOK(res4)) {
52319 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52320 }
52321 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52322 }
52323 {
52324 PyThreadState* __tstate = wxPyBeginAllowThreads();
52325 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52326 wxPyEndAllowThreads(__tstate);
52327 if (PyErr_Occurred()) SWIG_fail;
52328 }
52329 {
52330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52331 }
52332 return resultobj;
52333 fail:
52334 return NULL;
52335 }
52336
52337
52338 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52339 PyObject *obj;
52340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52341 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52342 return SWIG_Py_Void();
52343 }
52344
52345 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52346 return SWIG_Python_InitShadowInstance(args);
52347 }
52348
52349 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52350 PyObject *resultobj = 0;
52351 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52352 wxRelationship arg2 ;
52353 wxWindow *arg3 = (wxWindow *) 0 ;
52354 wxEdge arg4 ;
52355 int arg5 = (int) 0 ;
52356 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52357 void *argp1 = 0 ;
52358 int res1 = 0 ;
52359 int val2 ;
52360 int ecode2 = 0 ;
52361 void *argp3 = 0 ;
52362 int res3 = 0 ;
52363 int val4 ;
52364 int ecode4 = 0 ;
52365 int val5 ;
52366 int ecode5 = 0 ;
52367 int val6 ;
52368 int ecode6 = 0 ;
52369 PyObject * obj0 = 0 ;
52370 PyObject * obj1 = 0 ;
52371 PyObject * obj2 = 0 ;
52372 PyObject * obj3 = 0 ;
52373 PyObject * obj4 = 0 ;
52374 PyObject * obj5 = 0 ;
52375 char * kwnames[] = {
52376 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52377 };
52378
52379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52381 if (!SWIG_IsOK(res1)) {
52382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52383 }
52384 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52385 ecode2 = SWIG_AsVal_int(obj1, &val2);
52386 if (!SWIG_IsOK(ecode2)) {
52387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52388 }
52389 arg2 = static_cast< wxRelationship >(val2);
52390 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52391 if (!SWIG_IsOK(res3)) {
52392 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52393 }
52394 arg3 = reinterpret_cast< wxWindow * >(argp3);
52395 ecode4 = SWIG_AsVal_int(obj3, &val4);
52396 if (!SWIG_IsOK(ecode4)) {
52397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52398 }
52399 arg4 = static_cast< wxEdge >(val4);
52400 if (obj4) {
52401 ecode5 = SWIG_AsVal_int(obj4, &val5);
52402 if (!SWIG_IsOK(ecode5)) {
52403 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52404 }
52405 arg5 = static_cast< int >(val5);
52406 }
52407 if (obj5) {
52408 ecode6 = SWIG_AsVal_int(obj5, &val6);
52409 if (!SWIG_IsOK(ecode6)) {
52410 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52411 }
52412 arg6 = static_cast< int >(val6);
52413 }
52414 {
52415 PyThreadState* __tstate = wxPyBeginAllowThreads();
52416 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52417 wxPyEndAllowThreads(__tstate);
52418 if (PyErr_Occurred()) SWIG_fail;
52419 }
52420 resultobj = SWIG_Py_Void();
52421 return resultobj;
52422 fail:
52423 return NULL;
52424 }
52425
52426
52427 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52428 PyObject *resultobj = 0;
52429 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52430 wxWindow *arg2 = (wxWindow *) 0 ;
52431 int arg3 = (int) 0 ;
52432 void *argp1 = 0 ;
52433 int res1 = 0 ;
52434 void *argp2 = 0 ;
52435 int res2 = 0 ;
52436 int val3 ;
52437 int ecode3 = 0 ;
52438 PyObject * obj0 = 0 ;
52439 PyObject * obj1 = 0 ;
52440 PyObject * obj2 = 0 ;
52441 char * kwnames[] = {
52442 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52443 };
52444
52445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52447 if (!SWIG_IsOK(res1)) {
52448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52449 }
52450 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52452 if (!SWIG_IsOK(res2)) {
52453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52454 }
52455 arg2 = reinterpret_cast< wxWindow * >(argp2);
52456 if (obj2) {
52457 ecode3 = SWIG_AsVal_int(obj2, &val3);
52458 if (!SWIG_IsOK(ecode3)) {
52459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52460 }
52461 arg3 = static_cast< int >(val3);
52462 }
52463 {
52464 PyThreadState* __tstate = wxPyBeginAllowThreads();
52465 (arg1)->LeftOf(arg2,arg3);
52466 wxPyEndAllowThreads(__tstate);
52467 if (PyErr_Occurred()) SWIG_fail;
52468 }
52469 resultobj = SWIG_Py_Void();
52470 return resultobj;
52471 fail:
52472 return NULL;
52473 }
52474
52475
52476 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52477 PyObject *resultobj = 0;
52478 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52479 wxWindow *arg2 = (wxWindow *) 0 ;
52480 int arg3 = (int) 0 ;
52481 void *argp1 = 0 ;
52482 int res1 = 0 ;
52483 void *argp2 = 0 ;
52484 int res2 = 0 ;
52485 int val3 ;
52486 int ecode3 = 0 ;
52487 PyObject * obj0 = 0 ;
52488 PyObject * obj1 = 0 ;
52489 PyObject * obj2 = 0 ;
52490 char * kwnames[] = {
52491 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52492 };
52493
52494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52496 if (!SWIG_IsOK(res1)) {
52497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52498 }
52499 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52501 if (!SWIG_IsOK(res2)) {
52502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52503 }
52504 arg2 = reinterpret_cast< wxWindow * >(argp2);
52505 if (obj2) {
52506 ecode3 = SWIG_AsVal_int(obj2, &val3);
52507 if (!SWIG_IsOK(ecode3)) {
52508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52509 }
52510 arg3 = static_cast< int >(val3);
52511 }
52512 {
52513 PyThreadState* __tstate = wxPyBeginAllowThreads();
52514 (arg1)->RightOf(arg2,arg3);
52515 wxPyEndAllowThreads(__tstate);
52516 if (PyErr_Occurred()) SWIG_fail;
52517 }
52518 resultobj = SWIG_Py_Void();
52519 return resultobj;
52520 fail:
52521 return NULL;
52522 }
52523
52524
52525 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52526 PyObject *resultobj = 0;
52527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52528 wxWindow *arg2 = (wxWindow *) 0 ;
52529 int arg3 = (int) 0 ;
52530 void *argp1 = 0 ;
52531 int res1 = 0 ;
52532 void *argp2 = 0 ;
52533 int res2 = 0 ;
52534 int val3 ;
52535 int ecode3 = 0 ;
52536 PyObject * obj0 = 0 ;
52537 PyObject * obj1 = 0 ;
52538 PyObject * obj2 = 0 ;
52539 char * kwnames[] = {
52540 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52541 };
52542
52543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52545 if (!SWIG_IsOK(res1)) {
52546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52547 }
52548 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52550 if (!SWIG_IsOK(res2)) {
52551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52552 }
52553 arg2 = reinterpret_cast< wxWindow * >(argp2);
52554 if (obj2) {
52555 ecode3 = SWIG_AsVal_int(obj2, &val3);
52556 if (!SWIG_IsOK(ecode3)) {
52557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52558 }
52559 arg3 = static_cast< int >(val3);
52560 }
52561 {
52562 PyThreadState* __tstate = wxPyBeginAllowThreads();
52563 (arg1)->Above(arg2,arg3);
52564 wxPyEndAllowThreads(__tstate);
52565 if (PyErr_Occurred()) SWIG_fail;
52566 }
52567 resultobj = SWIG_Py_Void();
52568 return resultobj;
52569 fail:
52570 return NULL;
52571 }
52572
52573
52574 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52575 PyObject *resultobj = 0;
52576 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52577 wxWindow *arg2 = (wxWindow *) 0 ;
52578 int arg3 = (int) 0 ;
52579 void *argp1 = 0 ;
52580 int res1 = 0 ;
52581 void *argp2 = 0 ;
52582 int res2 = 0 ;
52583 int val3 ;
52584 int ecode3 = 0 ;
52585 PyObject * obj0 = 0 ;
52586 PyObject * obj1 = 0 ;
52587 PyObject * obj2 = 0 ;
52588 char * kwnames[] = {
52589 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52590 };
52591
52592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52594 if (!SWIG_IsOK(res1)) {
52595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52596 }
52597 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52599 if (!SWIG_IsOK(res2)) {
52600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52601 }
52602 arg2 = reinterpret_cast< wxWindow * >(argp2);
52603 if (obj2) {
52604 ecode3 = SWIG_AsVal_int(obj2, &val3);
52605 if (!SWIG_IsOK(ecode3)) {
52606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52607 }
52608 arg3 = static_cast< int >(val3);
52609 }
52610 {
52611 PyThreadState* __tstate = wxPyBeginAllowThreads();
52612 (arg1)->Below(arg2,arg3);
52613 wxPyEndAllowThreads(__tstate);
52614 if (PyErr_Occurred()) SWIG_fail;
52615 }
52616 resultobj = SWIG_Py_Void();
52617 return resultobj;
52618 fail:
52619 return NULL;
52620 }
52621
52622
52623 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52624 PyObject *resultobj = 0;
52625 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52626 wxWindow *arg2 = (wxWindow *) 0 ;
52627 wxEdge arg3 ;
52628 int arg4 = (int) 0 ;
52629 void *argp1 = 0 ;
52630 int res1 = 0 ;
52631 void *argp2 = 0 ;
52632 int res2 = 0 ;
52633 int val3 ;
52634 int ecode3 = 0 ;
52635 int val4 ;
52636 int ecode4 = 0 ;
52637 PyObject * obj0 = 0 ;
52638 PyObject * obj1 = 0 ;
52639 PyObject * obj2 = 0 ;
52640 PyObject * obj3 = 0 ;
52641 char * kwnames[] = {
52642 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52643 };
52644
52645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52647 if (!SWIG_IsOK(res1)) {
52648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52649 }
52650 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52652 if (!SWIG_IsOK(res2)) {
52653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52654 }
52655 arg2 = reinterpret_cast< wxWindow * >(argp2);
52656 ecode3 = SWIG_AsVal_int(obj2, &val3);
52657 if (!SWIG_IsOK(ecode3)) {
52658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52659 }
52660 arg3 = static_cast< wxEdge >(val3);
52661 if (obj3) {
52662 ecode4 = SWIG_AsVal_int(obj3, &val4);
52663 if (!SWIG_IsOK(ecode4)) {
52664 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52665 }
52666 arg4 = static_cast< int >(val4);
52667 }
52668 {
52669 PyThreadState* __tstate = wxPyBeginAllowThreads();
52670 (arg1)->SameAs(arg2,arg3,arg4);
52671 wxPyEndAllowThreads(__tstate);
52672 if (PyErr_Occurred()) SWIG_fail;
52673 }
52674 resultobj = SWIG_Py_Void();
52675 return resultobj;
52676 fail:
52677 return NULL;
52678 }
52679
52680
52681 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52682 PyObject *resultobj = 0;
52683 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52684 wxWindow *arg2 = (wxWindow *) 0 ;
52685 wxEdge arg3 ;
52686 int arg4 ;
52687 void *argp1 = 0 ;
52688 int res1 = 0 ;
52689 void *argp2 = 0 ;
52690 int res2 = 0 ;
52691 int val3 ;
52692 int ecode3 = 0 ;
52693 int val4 ;
52694 int ecode4 = 0 ;
52695 PyObject * obj0 = 0 ;
52696 PyObject * obj1 = 0 ;
52697 PyObject * obj2 = 0 ;
52698 PyObject * obj3 = 0 ;
52699 char * kwnames[] = {
52700 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52701 };
52702
52703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52705 if (!SWIG_IsOK(res1)) {
52706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52707 }
52708 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52710 if (!SWIG_IsOK(res2)) {
52711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52712 }
52713 arg2 = reinterpret_cast< wxWindow * >(argp2);
52714 ecode3 = SWIG_AsVal_int(obj2, &val3);
52715 if (!SWIG_IsOK(ecode3)) {
52716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52717 }
52718 arg3 = static_cast< wxEdge >(val3);
52719 ecode4 = SWIG_AsVal_int(obj3, &val4);
52720 if (!SWIG_IsOK(ecode4)) {
52721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52722 }
52723 arg4 = static_cast< int >(val4);
52724 {
52725 PyThreadState* __tstate = wxPyBeginAllowThreads();
52726 (arg1)->PercentOf(arg2,arg3,arg4);
52727 wxPyEndAllowThreads(__tstate);
52728 if (PyErr_Occurred()) SWIG_fail;
52729 }
52730 resultobj = SWIG_Py_Void();
52731 return resultobj;
52732 fail:
52733 return NULL;
52734 }
52735
52736
52737 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52738 PyObject *resultobj = 0;
52739 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52740 int arg2 ;
52741 void *argp1 = 0 ;
52742 int res1 = 0 ;
52743 int val2 ;
52744 int ecode2 = 0 ;
52745 PyObject * obj0 = 0 ;
52746 PyObject * obj1 = 0 ;
52747 char * kwnames[] = {
52748 (char *) "self",(char *) "val", NULL
52749 };
52750
52751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52753 if (!SWIG_IsOK(res1)) {
52754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52755 }
52756 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52757 ecode2 = SWIG_AsVal_int(obj1, &val2);
52758 if (!SWIG_IsOK(ecode2)) {
52759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52760 }
52761 arg2 = static_cast< int >(val2);
52762 {
52763 PyThreadState* __tstate = wxPyBeginAllowThreads();
52764 (arg1)->Absolute(arg2);
52765 wxPyEndAllowThreads(__tstate);
52766 if (PyErr_Occurred()) SWIG_fail;
52767 }
52768 resultobj = SWIG_Py_Void();
52769 return resultobj;
52770 fail:
52771 return NULL;
52772 }
52773
52774
52775 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52776 PyObject *resultobj = 0;
52777 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52778 void *argp1 = 0 ;
52779 int res1 = 0 ;
52780 PyObject *swig_obj[1] ;
52781
52782 if (!args) SWIG_fail;
52783 swig_obj[0] = args;
52784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52785 if (!SWIG_IsOK(res1)) {
52786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52787 }
52788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52789 {
52790 PyThreadState* __tstate = wxPyBeginAllowThreads();
52791 (arg1)->Unconstrained();
52792 wxPyEndAllowThreads(__tstate);
52793 if (PyErr_Occurred()) SWIG_fail;
52794 }
52795 resultobj = SWIG_Py_Void();
52796 return resultobj;
52797 fail:
52798 return NULL;
52799 }
52800
52801
52802 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52803 PyObject *resultobj = 0;
52804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52805 void *argp1 = 0 ;
52806 int res1 = 0 ;
52807 PyObject *swig_obj[1] ;
52808
52809 if (!args) SWIG_fail;
52810 swig_obj[0] = args;
52811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52812 if (!SWIG_IsOK(res1)) {
52813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52814 }
52815 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52816 {
52817 PyThreadState* __tstate = wxPyBeginAllowThreads();
52818 (arg1)->AsIs();
52819 wxPyEndAllowThreads(__tstate);
52820 if (PyErr_Occurred()) SWIG_fail;
52821 }
52822 resultobj = SWIG_Py_Void();
52823 return resultobj;
52824 fail:
52825 return NULL;
52826 }
52827
52828
52829 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52830 PyObject *resultobj = 0;
52831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52832 wxWindow *result = 0 ;
52833 void *argp1 = 0 ;
52834 int res1 = 0 ;
52835 PyObject *swig_obj[1] ;
52836
52837 if (!args) SWIG_fail;
52838 swig_obj[0] = args;
52839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52840 if (!SWIG_IsOK(res1)) {
52841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52842 }
52843 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52844 {
52845 PyThreadState* __tstate = wxPyBeginAllowThreads();
52846 result = (wxWindow *)(arg1)->GetOtherWindow();
52847 wxPyEndAllowThreads(__tstate);
52848 if (PyErr_Occurred()) SWIG_fail;
52849 }
52850 {
52851 resultobj = wxPyMake_wxObject(result, 0);
52852 }
52853 return resultobj;
52854 fail:
52855 return NULL;
52856 }
52857
52858
52859 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52860 PyObject *resultobj = 0;
52861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52862 wxEdge result;
52863 void *argp1 = 0 ;
52864 int res1 = 0 ;
52865 PyObject *swig_obj[1] ;
52866
52867 if (!args) SWIG_fail;
52868 swig_obj[0] = args;
52869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52870 if (!SWIG_IsOK(res1)) {
52871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52872 }
52873 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52874 {
52875 PyThreadState* __tstate = wxPyBeginAllowThreads();
52876 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52877 wxPyEndAllowThreads(__tstate);
52878 if (PyErr_Occurred()) SWIG_fail;
52879 }
52880 resultobj = SWIG_From_int(static_cast< int >(result));
52881 return resultobj;
52882 fail:
52883 return NULL;
52884 }
52885
52886
52887 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52888 PyObject *resultobj = 0;
52889 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52890 wxEdge arg2 ;
52891 void *argp1 = 0 ;
52892 int res1 = 0 ;
52893 int val2 ;
52894 int ecode2 = 0 ;
52895 PyObject * obj0 = 0 ;
52896 PyObject * obj1 = 0 ;
52897 char * kwnames[] = {
52898 (char *) "self",(char *) "which", NULL
52899 };
52900
52901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52903 if (!SWIG_IsOK(res1)) {
52904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52905 }
52906 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52907 ecode2 = SWIG_AsVal_int(obj1, &val2);
52908 if (!SWIG_IsOK(ecode2)) {
52909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52910 }
52911 arg2 = static_cast< wxEdge >(val2);
52912 {
52913 PyThreadState* __tstate = wxPyBeginAllowThreads();
52914 (arg1)->SetEdge(arg2);
52915 wxPyEndAllowThreads(__tstate);
52916 if (PyErr_Occurred()) SWIG_fail;
52917 }
52918 resultobj = SWIG_Py_Void();
52919 return resultobj;
52920 fail:
52921 return NULL;
52922 }
52923
52924
52925 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52926 PyObject *resultobj = 0;
52927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52928 int arg2 ;
52929 void *argp1 = 0 ;
52930 int res1 = 0 ;
52931 int val2 ;
52932 int ecode2 = 0 ;
52933 PyObject * obj0 = 0 ;
52934 PyObject * obj1 = 0 ;
52935 char * kwnames[] = {
52936 (char *) "self",(char *) "v", NULL
52937 };
52938
52939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52941 if (!SWIG_IsOK(res1)) {
52942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52943 }
52944 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52945 ecode2 = SWIG_AsVal_int(obj1, &val2);
52946 if (!SWIG_IsOK(ecode2)) {
52947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52948 }
52949 arg2 = static_cast< int >(val2);
52950 {
52951 PyThreadState* __tstate = wxPyBeginAllowThreads();
52952 (arg1)->SetValue(arg2);
52953 wxPyEndAllowThreads(__tstate);
52954 if (PyErr_Occurred()) SWIG_fail;
52955 }
52956 resultobj = SWIG_Py_Void();
52957 return resultobj;
52958 fail:
52959 return NULL;
52960 }
52961
52962
52963 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52964 PyObject *resultobj = 0;
52965 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52966 int result;
52967 void *argp1 = 0 ;
52968 int res1 = 0 ;
52969 PyObject *swig_obj[1] ;
52970
52971 if (!args) SWIG_fail;
52972 swig_obj[0] = args;
52973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52974 if (!SWIG_IsOK(res1)) {
52975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52976 }
52977 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52978 {
52979 PyThreadState* __tstate = wxPyBeginAllowThreads();
52980 result = (int)(arg1)->GetMargin();
52981 wxPyEndAllowThreads(__tstate);
52982 if (PyErr_Occurred()) SWIG_fail;
52983 }
52984 resultobj = SWIG_From_int(static_cast< int >(result));
52985 return resultobj;
52986 fail:
52987 return NULL;
52988 }
52989
52990
52991 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52992 PyObject *resultobj = 0;
52993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52994 int arg2 ;
52995 void *argp1 = 0 ;
52996 int res1 = 0 ;
52997 int val2 ;
52998 int ecode2 = 0 ;
52999 PyObject * obj0 = 0 ;
53000 PyObject * obj1 = 0 ;
53001 char * kwnames[] = {
53002 (char *) "self",(char *) "m", NULL
53003 };
53004
53005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53007 if (!SWIG_IsOK(res1)) {
53008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53009 }
53010 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53011 ecode2 = SWIG_AsVal_int(obj1, &val2);
53012 if (!SWIG_IsOK(ecode2)) {
53013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53014 }
53015 arg2 = static_cast< int >(val2);
53016 {
53017 PyThreadState* __tstate = wxPyBeginAllowThreads();
53018 (arg1)->SetMargin(arg2);
53019 wxPyEndAllowThreads(__tstate);
53020 if (PyErr_Occurred()) SWIG_fail;
53021 }
53022 resultobj = SWIG_Py_Void();
53023 return resultobj;
53024 fail:
53025 return NULL;
53026 }
53027
53028
53029 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53030 PyObject *resultobj = 0;
53031 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53032 int result;
53033 void *argp1 = 0 ;
53034 int res1 = 0 ;
53035 PyObject *swig_obj[1] ;
53036
53037 if (!args) SWIG_fail;
53038 swig_obj[0] = args;
53039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53040 if (!SWIG_IsOK(res1)) {
53041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53042 }
53043 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53044 {
53045 PyThreadState* __tstate = wxPyBeginAllowThreads();
53046 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53047 wxPyEndAllowThreads(__tstate);
53048 if (PyErr_Occurred()) SWIG_fail;
53049 }
53050 resultobj = SWIG_From_int(static_cast< int >(result));
53051 return resultobj;
53052 fail:
53053 return NULL;
53054 }
53055
53056
53057 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53058 PyObject *resultobj = 0;
53059 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53060 int result;
53061 void *argp1 = 0 ;
53062 int res1 = 0 ;
53063 PyObject *swig_obj[1] ;
53064
53065 if (!args) SWIG_fail;
53066 swig_obj[0] = args;
53067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53068 if (!SWIG_IsOK(res1)) {
53069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53070 }
53071 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53072 {
53073 PyThreadState* __tstate = wxPyBeginAllowThreads();
53074 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53075 wxPyEndAllowThreads(__tstate);
53076 if (PyErr_Occurred()) SWIG_fail;
53077 }
53078 resultobj = SWIG_From_int(static_cast< int >(result));
53079 return resultobj;
53080 fail:
53081 return NULL;
53082 }
53083
53084
53085 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53086 PyObject *resultobj = 0;
53087 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53088 int result;
53089 void *argp1 = 0 ;
53090 int res1 = 0 ;
53091 PyObject *swig_obj[1] ;
53092
53093 if (!args) SWIG_fail;
53094 swig_obj[0] = args;
53095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53096 if (!SWIG_IsOK(res1)) {
53097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53098 }
53099 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53100 {
53101 PyThreadState* __tstate = wxPyBeginAllowThreads();
53102 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53103 wxPyEndAllowThreads(__tstate);
53104 if (PyErr_Occurred()) SWIG_fail;
53105 }
53106 resultobj = SWIG_From_int(static_cast< int >(result));
53107 return resultobj;
53108 fail:
53109 return NULL;
53110 }
53111
53112
53113 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53114 PyObject *resultobj = 0;
53115 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53116 bool result;
53117 void *argp1 = 0 ;
53118 int res1 = 0 ;
53119 PyObject *swig_obj[1] ;
53120
53121 if (!args) SWIG_fail;
53122 swig_obj[0] = args;
53123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53124 if (!SWIG_IsOK(res1)) {
53125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53126 }
53127 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53128 {
53129 PyThreadState* __tstate = wxPyBeginAllowThreads();
53130 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53131 wxPyEndAllowThreads(__tstate);
53132 if (PyErr_Occurred()) SWIG_fail;
53133 }
53134 {
53135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53136 }
53137 return resultobj;
53138 fail:
53139 return NULL;
53140 }
53141
53142
53143 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53144 PyObject *resultobj = 0;
53145 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53146 bool arg2 ;
53147 void *argp1 = 0 ;
53148 int res1 = 0 ;
53149 bool val2 ;
53150 int ecode2 = 0 ;
53151 PyObject * obj0 = 0 ;
53152 PyObject * obj1 = 0 ;
53153 char * kwnames[] = {
53154 (char *) "self",(char *) "d", NULL
53155 };
53156
53157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53159 if (!SWIG_IsOK(res1)) {
53160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53161 }
53162 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53164 if (!SWIG_IsOK(ecode2)) {
53165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53166 }
53167 arg2 = static_cast< bool >(val2);
53168 {
53169 PyThreadState* __tstate = wxPyBeginAllowThreads();
53170 (arg1)->SetDone(arg2);
53171 wxPyEndAllowThreads(__tstate);
53172 if (PyErr_Occurred()) SWIG_fail;
53173 }
53174 resultobj = SWIG_Py_Void();
53175 return resultobj;
53176 fail:
53177 return NULL;
53178 }
53179
53180
53181 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53182 PyObject *resultobj = 0;
53183 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53184 wxRelationship result;
53185 void *argp1 = 0 ;
53186 int res1 = 0 ;
53187 PyObject *swig_obj[1] ;
53188
53189 if (!args) SWIG_fail;
53190 swig_obj[0] = args;
53191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53192 if (!SWIG_IsOK(res1)) {
53193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53194 }
53195 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53196 {
53197 PyThreadState* __tstate = wxPyBeginAllowThreads();
53198 result = (wxRelationship)(arg1)->GetRelationship();
53199 wxPyEndAllowThreads(__tstate);
53200 if (PyErr_Occurred()) SWIG_fail;
53201 }
53202 resultobj = SWIG_From_int(static_cast< int >(result));
53203 return resultobj;
53204 fail:
53205 return NULL;
53206 }
53207
53208
53209 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53210 PyObject *resultobj = 0;
53211 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53212 wxRelationship arg2 ;
53213 void *argp1 = 0 ;
53214 int res1 = 0 ;
53215 int val2 ;
53216 int ecode2 = 0 ;
53217 PyObject * obj0 = 0 ;
53218 PyObject * obj1 = 0 ;
53219 char * kwnames[] = {
53220 (char *) "self",(char *) "r", NULL
53221 };
53222
53223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53225 if (!SWIG_IsOK(res1)) {
53226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53227 }
53228 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53229 ecode2 = SWIG_AsVal_int(obj1, &val2);
53230 if (!SWIG_IsOK(ecode2)) {
53231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53232 }
53233 arg2 = static_cast< wxRelationship >(val2);
53234 {
53235 PyThreadState* __tstate = wxPyBeginAllowThreads();
53236 (arg1)->SetRelationship(arg2);
53237 wxPyEndAllowThreads(__tstate);
53238 if (PyErr_Occurred()) SWIG_fail;
53239 }
53240 resultobj = SWIG_Py_Void();
53241 return resultobj;
53242 fail:
53243 return NULL;
53244 }
53245
53246
53247 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53248 PyObject *resultobj = 0;
53249 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53250 wxWindow *arg2 = (wxWindow *) 0 ;
53251 bool result;
53252 void *argp1 = 0 ;
53253 int res1 = 0 ;
53254 void *argp2 = 0 ;
53255 int res2 = 0 ;
53256 PyObject * obj0 = 0 ;
53257 PyObject * obj1 = 0 ;
53258 char * kwnames[] = {
53259 (char *) "self",(char *) "otherW", NULL
53260 };
53261
53262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53264 if (!SWIG_IsOK(res1)) {
53265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53266 }
53267 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53269 if (!SWIG_IsOK(res2)) {
53270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53271 }
53272 arg2 = reinterpret_cast< wxWindow * >(argp2);
53273 {
53274 PyThreadState* __tstate = wxPyBeginAllowThreads();
53275 result = (bool)(arg1)->ResetIfWin(arg2);
53276 wxPyEndAllowThreads(__tstate);
53277 if (PyErr_Occurred()) SWIG_fail;
53278 }
53279 {
53280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53281 }
53282 return resultobj;
53283 fail:
53284 return NULL;
53285 }
53286
53287
53288 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53289 PyObject *resultobj = 0;
53290 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53291 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53292 wxWindow *arg3 = (wxWindow *) 0 ;
53293 bool result;
53294 void *argp1 = 0 ;
53295 int res1 = 0 ;
53296 void *argp2 = 0 ;
53297 int res2 = 0 ;
53298 void *argp3 = 0 ;
53299 int res3 = 0 ;
53300 PyObject * obj0 = 0 ;
53301 PyObject * obj1 = 0 ;
53302 PyObject * obj2 = 0 ;
53303 char * kwnames[] = {
53304 (char *) "self",(char *) "constraints",(char *) "win", NULL
53305 };
53306
53307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53309 if (!SWIG_IsOK(res1)) {
53310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53311 }
53312 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53314 if (!SWIG_IsOK(res2)) {
53315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53316 }
53317 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53318 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53319 if (!SWIG_IsOK(res3)) {
53320 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53321 }
53322 arg3 = reinterpret_cast< wxWindow * >(argp3);
53323 {
53324 PyThreadState* __tstate = wxPyBeginAllowThreads();
53325 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53326 wxPyEndAllowThreads(__tstate);
53327 if (PyErr_Occurred()) SWIG_fail;
53328 }
53329 {
53330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53331 }
53332 return resultobj;
53333 fail:
53334 return NULL;
53335 }
53336
53337
53338 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53339 PyObject *resultobj = 0;
53340 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53341 wxEdge arg2 ;
53342 wxWindow *arg3 = (wxWindow *) 0 ;
53343 wxWindow *arg4 = (wxWindow *) 0 ;
53344 int result;
53345 void *argp1 = 0 ;
53346 int res1 = 0 ;
53347 int val2 ;
53348 int ecode2 = 0 ;
53349 void *argp3 = 0 ;
53350 int res3 = 0 ;
53351 void *argp4 = 0 ;
53352 int res4 = 0 ;
53353 PyObject * obj0 = 0 ;
53354 PyObject * obj1 = 0 ;
53355 PyObject * obj2 = 0 ;
53356 PyObject * obj3 = 0 ;
53357 char * kwnames[] = {
53358 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53359 };
53360
53361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53363 if (!SWIG_IsOK(res1)) {
53364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53365 }
53366 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53367 ecode2 = SWIG_AsVal_int(obj1, &val2);
53368 if (!SWIG_IsOK(ecode2)) {
53369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53370 }
53371 arg2 = static_cast< wxEdge >(val2);
53372 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53373 if (!SWIG_IsOK(res3)) {
53374 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53375 }
53376 arg3 = reinterpret_cast< wxWindow * >(argp3);
53377 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53378 if (!SWIG_IsOK(res4)) {
53379 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53380 }
53381 arg4 = reinterpret_cast< wxWindow * >(argp4);
53382 {
53383 PyThreadState* __tstate = wxPyBeginAllowThreads();
53384 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53385 wxPyEndAllowThreads(__tstate);
53386 if (PyErr_Occurred()) SWIG_fail;
53387 }
53388 resultobj = SWIG_From_int(static_cast< int >(result));
53389 return resultobj;
53390 fail:
53391 return NULL;
53392 }
53393
53394
53395 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53396 PyObject *obj;
53397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53398 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53399 return SWIG_Py_Void();
53400 }
53401
53402 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53403 PyObject *resultobj = 0;
53404 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53405 wxIndividualLayoutConstraint *result = 0 ;
53406 void *argp1 = 0 ;
53407 int res1 = 0 ;
53408 PyObject *swig_obj[1] ;
53409
53410 if (!args) SWIG_fail;
53411 swig_obj[0] = args;
53412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53413 if (!SWIG_IsOK(res1)) {
53414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53415 }
53416 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53417 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53419 return resultobj;
53420 fail:
53421 return NULL;
53422 }
53423
53424
53425 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53426 PyObject *resultobj = 0;
53427 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53428 wxIndividualLayoutConstraint *result = 0 ;
53429 void *argp1 = 0 ;
53430 int res1 = 0 ;
53431 PyObject *swig_obj[1] ;
53432
53433 if (!args) SWIG_fail;
53434 swig_obj[0] = args;
53435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53436 if (!SWIG_IsOK(res1)) {
53437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53438 }
53439 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53440 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53442 return resultobj;
53443 fail:
53444 return NULL;
53445 }
53446
53447
53448 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53449 PyObject *resultobj = 0;
53450 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53451 wxIndividualLayoutConstraint *result = 0 ;
53452 void *argp1 = 0 ;
53453 int res1 = 0 ;
53454 PyObject *swig_obj[1] ;
53455
53456 if (!args) SWIG_fail;
53457 swig_obj[0] = args;
53458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53459 if (!SWIG_IsOK(res1)) {
53460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53461 }
53462 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53463 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53465 return resultobj;
53466 fail:
53467 return NULL;
53468 }
53469
53470
53471 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53472 PyObject *resultobj = 0;
53473 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53474 wxIndividualLayoutConstraint *result = 0 ;
53475 void *argp1 = 0 ;
53476 int res1 = 0 ;
53477 PyObject *swig_obj[1] ;
53478
53479 if (!args) SWIG_fail;
53480 swig_obj[0] = args;
53481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53482 if (!SWIG_IsOK(res1)) {
53483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53484 }
53485 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53486 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53488 return resultobj;
53489 fail:
53490 return NULL;
53491 }
53492
53493
53494 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53495 PyObject *resultobj = 0;
53496 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53497 wxIndividualLayoutConstraint *result = 0 ;
53498 void *argp1 = 0 ;
53499 int res1 = 0 ;
53500 PyObject *swig_obj[1] ;
53501
53502 if (!args) SWIG_fail;
53503 swig_obj[0] = args;
53504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53505 if (!SWIG_IsOK(res1)) {
53506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53507 }
53508 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53509 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53511 return resultobj;
53512 fail:
53513 return NULL;
53514 }
53515
53516
53517 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53518 PyObject *resultobj = 0;
53519 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53520 wxIndividualLayoutConstraint *result = 0 ;
53521 void *argp1 = 0 ;
53522 int res1 = 0 ;
53523 PyObject *swig_obj[1] ;
53524
53525 if (!args) SWIG_fail;
53526 swig_obj[0] = args;
53527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53528 if (!SWIG_IsOK(res1)) {
53529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53530 }
53531 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53532 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53534 return resultobj;
53535 fail:
53536 return NULL;
53537 }
53538
53539
53540 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53541 PyObject *resultobj = 0;
53542 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53543 wxIndividualLayoutConstraint *result = 0 ;
53544 void *argp1 = 0 ;
53545 int res1 = 0 ;
53546 PyObject *swig_obj[1] ;
53547
53548 if (!args) SWIG_fail;
53549 swig_obj[0] = args;
53550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53551 if (!SWIG_IsOK(res1)) {
53552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53553 }
53554 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53555 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53557 return resultobj;
53558 fail:
53559 return NULL;
53560 }
53561
53562
53563 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53564 PyObject *resultobj = 0;
53565 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53566 wxIndividualLayoutConstraint *result = 0 ;
53567 void *argp1 = 0 ;
53568 int res1 = 0 ;
53569 PyObject *swig_obj[1] ;
53570
53571 if (!args) SWIG_fail;
53572 swig_obj[0] = args;
53573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53574 if (!SWIG_IsOK(res1)) {
53575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53576 }
53577 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53578 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53580 return resultobj;
53581 fail:
53582 return NULL;
53583 }
53584
53585
53586 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53587 PyObject *resultobj = 0;
53588 wxLayoutConstraints *result = 0 ;
53589
53590 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53591 {
53592 PyThreadState* __tstate = wxPyBeginAllowThreads();
53593 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53594 wxPyEndAllowThreads(__tstate);
53595 if (PyErr_Occurred()) SWIG_fail;
53596 }
53597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53598 return resultobj;
53599 fail:
53600 return NULL;
53601 }
53602
53603
53604 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53605 PyObject *resultobj = 0;
53606 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53607 void *argp1 = 0 ;
53608 int res1 = 0 ;
53609 PyObject *swig_obj[1] ;
53610
53611 if (!args) SWIG_fail;
53612 swig_obj[0] = args;
53613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53614 if (!SWIG_IsOK(res1)) {
53615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53616 }
53617 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53618 {
53619 PyThreadState* __tstate = wxPyBeginAllowThreads();
53620 delete arg1;
53621
53622 wxPyEndAllowThreads(__tstate);
53623 if (PyErr_Occurred()) SWIG_fail;
53624 }
53625 resultobj = SWIG_Py_Void();
53626 return resultobj;
53627 fail:
53628 return NULL;
53629 }
53630
53631
53632 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53633 PyObject *resultobj = 0;
53634 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53635 wxWindow *arg2 = (wxWindow *) 0 ;
53636 int *arg3 = (int *) 0 ;
53637 bool result;
53638 void *argp1 = 0 ;
53639 int res1 = 0 ;
53640 void *argp2 = 0 ;
53641 int res2 = 0 ;
53642 int temp3 ;
53643 int res3 = SWIG_TMPOBJ ;
53644 PyObject * obj0 = 0 ;
53645 PyObject * obj1 = 0 ;
53646 char * kwnames[] = {
53647 (char *) "self",(char *) "win", NULL
53648 };
53649
53650 arg3 = &temp3;
53651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53653 if (!SWIG_IsOK(res1)) {
53654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53655 }
53656 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53658 if (!SWIG_IsOK(res2)) {
53659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53660 }
53661 arg2 = reinterpret_cast< wxWindow * >(argp2);
53662 {
53663 PyThreadState* __tstate = wxPyBeginAllowThreads();
53664 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53665 wxPyEndAllowThreads(__tstate);
53666 if (PyErr_Occurred()) SWIG_fail;
53667 }
53668 {
53669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53670 }
53671 if (SWIG_IsTmpObj(res3)) {
53672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53673 } else {
53674 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53676 }
53677 return resultobj;
53678 fail:
53679 return NULL;
53680 }
53681
53682
53683 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53684 PyObject *resultobj = 0;
53685 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53686 bool result;
53687 void *argp1 = 0 ;
53688 int res1 = 0 ;
53689 PyObject *swig_obj[1] ;
53690
53691 if (!args) SWIG_fail;
53692 swig_obj[0] = args;
53693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53694 if (!SWIG_IsOK(res1)) {
53695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53696 }
53697 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53698 {
53699 PyThreadState* __tstate = wxPyBeginAllowThreads();
53700 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53701 wxPyEndAllowThreads(__tstate);
53702 if (PyErr_Occurred()) SWIG_fail;
53703 }
53704 {
53705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53706 }
53707 return resultobj;
53708 fail:
53709 return NULL;
53710 }
53711
53712
53713 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53714 PyObject *obj;
53715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53716 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53717 return SWIG_Py_Void();
53718 }
53719
53720 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53721 return SWIG_Python_InitShadowInstance(args);
53722 }
53723
53724 static PyMethodDef SwigMethods[] = {
53725 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53726 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53727 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53728 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53729 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53730 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53731 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53732 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53733 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53735 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53746 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53747 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53748 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53750 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53751 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53752 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53753 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53754 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53755 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53756 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53758 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53764 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53765 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53766 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53767 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53768 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53769 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53770 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53772 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53780 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53781 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53782 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53787 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53788 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53790 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53792 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53794 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53796 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53798 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53800 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53801 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53803 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53805 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53806 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53807 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53808 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53828 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53829 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53830 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53831 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53832 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53833 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53834 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53835 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53837 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53838 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53839 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53844 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53845 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53846 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53847 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53854 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53861 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53862 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53863 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53864 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53866 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53867 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53868 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53870 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53871 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53872 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53873 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53878 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53879 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53880 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53881 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53882 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53883 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53886 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53887 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53888 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53890 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53891 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53893 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53894 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53895 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53896 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53897 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53898 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53899 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53900 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53901 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53902 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53903 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53904 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53909 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53915 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53916 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53917 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53918 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53920 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53923 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53926 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53929 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53930 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53931 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53934 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53935 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53936 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53940 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53941 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53942 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53946 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53951 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53952 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53953 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53954 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53955 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53956 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53957 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53964 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53965 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53967 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53968 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53969 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53975 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53976 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53978 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53979 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53980 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53981 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53982 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53983 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53984 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53985 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53987 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53988 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53989 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53990 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53991 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53992 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53993 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53994 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53996 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54005 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54017 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54018 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54033 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54034 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54035 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54036 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54039 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54041 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54043 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54045 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54047 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54050 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54051 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54052 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54053 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54055 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54072 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54073 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54079 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54080 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54082 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54083 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54084 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54085 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54086 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54087 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54088 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54089 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54090 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54091 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54092 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54093 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54094 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54095 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54096 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54097 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54098 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54099 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54100 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54101 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54102 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54103 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54104 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54105 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54106 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54107 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54108 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54109 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54110 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54111 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54112 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54113 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54114 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54116 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54117 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54118 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54119 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54122 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54126 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54130 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54131 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54132 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54133 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54135 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54136 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54138 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54140 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54142 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54144 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54145 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54146 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54148 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54149 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54151 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54152 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54153 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54155 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54156 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54157 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54159 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54161 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54162 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54163 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54165 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54167 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54168 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54170 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54171 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54172 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54174 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54175 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54176 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54177 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54178 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54180 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54181 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54184 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54185 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54187 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54188 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54191 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54192 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54194 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54200 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54201 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54202 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54203 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54204 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54205 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54206 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54207 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54208 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54209 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54210 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54211 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54212 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54213 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54214 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54215 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54216 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54217 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54218 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54219 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54220 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54221 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54222 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54223 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54225 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54226 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54227 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54228 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54229 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54230 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54231 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54232 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54233 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54234 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54235 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54236 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54237 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54238 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54239 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54240 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54241 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54242 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54243 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54244 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54245 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54246 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54247 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54248 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54249 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54250 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54251 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54252 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54253 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54254 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54255 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54256 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54258 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54259 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54261 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54262 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54263 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54264 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54266 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54267 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54268 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54269 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54270 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54271 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54272 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54273 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54274 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54276 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54277 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54278 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54279 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54280 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54281 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54282 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54283 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54284 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54285 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54286 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54287 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54288 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54289 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54290 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54291 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54292 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54293 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54294 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54295 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54296 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54297 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54298 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54299 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54300 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54301 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54302 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54303 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54305 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54306 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54309 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54310 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54311 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54312 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54313 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54314 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54316 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54317 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54320 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54321 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54323 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54324 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54326 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54327 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54329 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54330 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54331 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54333 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54335 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54336 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54338 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54339 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54340 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54342 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54343 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54344 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54346 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54347 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54349 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54350 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54351 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54352 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54353 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54356 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54358 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54360 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54361 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54362 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54365 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54366 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54367 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54369 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54370 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54371 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54373 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54374 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54375 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54376 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54377 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54378 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54380 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54381 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54382 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54383 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54384 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54385 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54386 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54387 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54393 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54395 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54397 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54398 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54399 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54400 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54401 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54402 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54404 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54405 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54406 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54408 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54409 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54410 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54411 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54412 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54415 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54416 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54417 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54420 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54421 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54422 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54423 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54424 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54426 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54428 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54431 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54433 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54434 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54436 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54437 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54438 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54440 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54441 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54442 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54444 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54446 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54447 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54448 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54450 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54452 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54454 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54455 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54457 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54458 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54460 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54462 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54463 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54464 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54466 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54468 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54469 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54470 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54472 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54474 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54475 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54476 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54477 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54479 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54481 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54483 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54485 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54486 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54488 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54489 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54490 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54491 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54492 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54493 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54494 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54495 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54496 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54498 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54500 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54502 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54504 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54506 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54508 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54509 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54510 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54511 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54512 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54513 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54519 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54520 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54521 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54522 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54523 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54524 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54525 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54526 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54528 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54529 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54530 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54531 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54533 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54534 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54535 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54536 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54538 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54539 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54540 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54541 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54543 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54544 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54546 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54547 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54548 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54550 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54553 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54554 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54555 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54556 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54557 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54559 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54560 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54562 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54563 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54564 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54565 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54567 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54568 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54569 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54570 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54571 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54572 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54573 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54574 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54575 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54576 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54578 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54581 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54582 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54583 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54585 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54587 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54589 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54590 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54591 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54592 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54595 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54605 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54606 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54610 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54611 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54612 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54613 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54614 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54615 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54616 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54617 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54618 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54619 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54620 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54621 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54622 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54623 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54624 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54626 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54627 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54630 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54631 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54636 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54637 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54640 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54641 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54642 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54643 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54646 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54647 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54648 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54650 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54652 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54653 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54654 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54655 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54657 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54659 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54661 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54663 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54664 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54665 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54666 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54667 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54668 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54669 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54673 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54674 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54675 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54676 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54677 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54678 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54680 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54681 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54682 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54683 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54684 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54685 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54687 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54688 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54689 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54690 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54691 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54692 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54693 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54695 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54700 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54701 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54702 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54705 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54706 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54707 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54708 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54711 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54712 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54713 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54714 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54715 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54716 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54717 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54718 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54722 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54728 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54729 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54730 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54731 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54733 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54734 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54736 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54738 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54739 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54741 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54742 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54743 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54744 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54751 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54752 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54754 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54756 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54757 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54759 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54769 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54770 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54771 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54772 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54776 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54779 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54781 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54784 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54786 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54787 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54790 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54792 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54793 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54794 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54795 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54797 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54798 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54803 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54804 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54805 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54807 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54808 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54809 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54811 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54812 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54813 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54814 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54815 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54816 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54817 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54818 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54820 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54821 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54829 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54836 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54844 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54845 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54846 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54847 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54848 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54861 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54863 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54865 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54866 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54868 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54870 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54871 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54873 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54874 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54875 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54879 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54888 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54898 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54899 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54901 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54902 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54903 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54904 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54905 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54906 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54908 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54909 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54912 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54913 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54915 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54916 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54918 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54921 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54922 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54924 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54925 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54926 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54928 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54929 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54931 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54932 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54935 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54937 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54939 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54941 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54944 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54946 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54947 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54948 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54950 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54951 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54952 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54953 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54954 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54955 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54956 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54957 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54959 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54961 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54962 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54966 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54970 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54971 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54973 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54977 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54979 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54981 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54982 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54983 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54984 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54987 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54988 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54989 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54990 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54991 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54992 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54993 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54994 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54999 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55000 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55001 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55002 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55003 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55005 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55007 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55009 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55010 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55012 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55014 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55017 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55018 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55019 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55021 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55022 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55023 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55036 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55042 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55043 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55044 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55045 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55046 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55047 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55052 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55053 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55054 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55058 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55059 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55061 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55062 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55064 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55066 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55067 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55069 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55070 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55071 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55077 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55078 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55079 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55080 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55081 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55082 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55089 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55091 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55092 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55093 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55094 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55095 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55096 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55098 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55102 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55103 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55104 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55105 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55106 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55107 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55108 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55110 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55111 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55112 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55118 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55119 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55120 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55122 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55123 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55124 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55130 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55131 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55132 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55133 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55134 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55138 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55139 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55141 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55142 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55144 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55145 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55146 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55147 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55148 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55153 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55155 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55156 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55157 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55158 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55159 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55164 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55165 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55167 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55173 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55174 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55175 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55176 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55177 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55180 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55182 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55183 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55184 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55185 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55187 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55192 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55193 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55194 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55195 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55196 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55197 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55198 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55199 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55200 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55201 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55202 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55203 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55204 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55205 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55206 { NULL, NULL, 0, NULL }
55207 };
55208
55209
55210 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55211
55212 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55213 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55214 }
55215 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55216 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55217 }
55218 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55219 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55220 }
55221 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55222 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55223 }
55224 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55225 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55226 }
55227 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55228 return (void *)((wxSizer *) ((wxGridSizer *) x));
55229 }
55230 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55231 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55232 }
55233 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55234 return (void *)((wxSizer *) ((wxPySizer *) x));
55235 }
55236 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55237 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55238 }
55239 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55240 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55241 }
55242 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55243 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55244 }
55245 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55246 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55247 }
55248 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55249 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55250 }
55251 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55252 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55253 }
55254 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55255 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55256 }
55257 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55258 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55259 }
55260 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55261 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55262 }
55263 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55264 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55265 }
55266 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55268 }
55269 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55270 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55271 }
55272 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55273 return (void *)((wxEvent *) ((wxPyEvent *) x));
55274 }
55275 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55276 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55277 }
55278 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55280 }
55281 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55282 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55283 }
55284 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55285 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55286 }
55287 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55288 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55289 }
55290 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55291 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55292 }
55293 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55294 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55295 }
55296 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55297 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55298 }
55299 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55301 }
55302 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55303 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55304 }
55305 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55306 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55307 }
55308 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55309 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55310 }
55311 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55312 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55313 }
55314 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55315 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55316 }
55317 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55318 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55319 }
55320 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55321 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55322 }
55323 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55324 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55325 }
55326 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55327 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55328 }
55329 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55330 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55331 }
55332 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55334 }
55335 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55336 return (void *)((wxEvent *) ((wxShowEvent *) x));
55337 }
55338 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55339 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55340 }
55341 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55342 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55343 }
55344 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55345 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55346 }
55347 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55348 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55349 }
55350 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55351 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55352 }
55353 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55354 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55355 }
55356 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55357 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55358 }
55359 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55360 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55361 }
55362 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55363 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55364 }
55365 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55366 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55367 }
55368 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55369 return (void *)((wxControl *) ((wxControlWithItems *) x));
55370 }
55371 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55372 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55373 }
55374 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55375 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55376 }
55377 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55378 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55379 }
55380 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55381 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55382 }
55383 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55384 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55385 }
55386 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55387 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55388 }
55389 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55390 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55391 }
55392 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55393 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55394 }
55395 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55396 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55397 }
55398 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55399 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55400 }
55401 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55402 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55403 }
55404 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55405 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55406 }
55407 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55408 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55409 }
55410 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55411 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55412 }
55413 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55414 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55415 }
55416 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55417 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55418 }
55419 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55420 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55421 }
55422 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55423 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55424 }
55425 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55426 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55427 }
55428 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55429 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55430 }
55431 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55432 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55433 }
55434 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55435 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55436 }
55437 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55438 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55439 }
55440 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55441 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55442 }
55443 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55444 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55445 }
55446 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55447 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55448 }
55449 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55450 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55451 }
55452 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55453 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55454 }
55455 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55456 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55457 }
55458 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55459 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55460 }
55461 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55462 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55463 }
55464 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55465 return (void *)((wxObject *) ((wxSizerItem *) x));
55466 }
55467 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55468 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55469 }
55470 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55471 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55472 }
55473 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55474 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55475 }
55476 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55477 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55478 }
55479 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55480 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55481 }
55482 static void *_p_wxSizerTo_p_wxObject(void *x) {
55483 return (void *)((wxObject *) ((wxSizer *) x));
55484 }
55485 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55486 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55487 }
55488 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55489 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55490 }
55491 static void *_p_wxEventTo_p_wxObject(void *x) {
55492 return (void *)((wxObject *) ((wxEvent *) x));
55493 }
55494 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55495 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55496 }
55497 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55498 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55499 }
55500 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55501 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55502 }
55503 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55504 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55505 }
55506 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55507 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55508 }
55509 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55510 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55511 }
55512 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55513 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55514 }
55515 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55516 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55517 }
55518 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55519 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55520 }
55521 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55522 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55523 }
55524 static void *_p_wxControlTo_p_wxObject(void *x) {
55525 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55526 }
55527 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55528 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55529 }
55530 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55531 return (void *)((wxObject *) ((wxFSFile *) x));
55532 }
55533 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55534 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55535 }
55536 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55537 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55538 }
55539 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55540 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55541 }
55542 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55543 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55544 }
55545 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55546 return (void *)((wxObject *) ((wxMenuItem *) x));
55547 }
55548 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55549 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55550 }
55551 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55552 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55553 }
55554 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55555 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55556 }
55557 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55558 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55559 }
55560 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55561 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55562 }
55563 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55564 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55565 }
55566 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55567 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55568 }
55569 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55570 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55571 }
55572 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55573 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55574 }
55575 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55576 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55577 }
55578 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55579 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55580 }
55581 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55582 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55583 }
55584 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55585 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55586 }
55587 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55588 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55589 }
55590 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55591 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55592 }
55593 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55594 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55595 }
55596 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55597 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55598 }
55599 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55600 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55601 }
55602 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55603 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55604 }
55605 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55606 return (void *)((wxObject *) ((wxImageHandler *) x));
55607 }
55608 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55609 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55610 }
55611 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55612 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55613 }
55614 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55615 return (void *)((wxObject *) ((wxEvtHandler *) x));
55616 }
55617 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55618 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55619 }
55620 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55621 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55622 }
55623 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55624 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55625 }
55626 static void *_p_wxImageTo_p_wxObject(void *x) {
55627 return (void *)((wxObject *) ((wxImage *) x));
55628 }
55629 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55630 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55631 }
55632 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55633 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55634 }
55635 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55636 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55637 }
55638 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55639 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55640 }
55641 static void *_p_wxWindowTo_p_wxObject(void *x) {
55642 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55643 }
55644 static void *_p_wxMenuTo_p_wxObject(void *x) {
55645 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55646 }
55647 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55648 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55649 }
55650 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55651 return (void *)((wxObject *) ((wxFileSystem *) x));
55652 }
55653 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55654 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55655 }
55656 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55657 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55658 }
55659 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55660 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55661 }
55662 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55663 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55664 }
55665 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55666 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55667 }
55668 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55669 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55670 }
55671 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55672 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55673 }
55674 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55675 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55676 }
55677 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55678 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55679 }
55680 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55681 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55682 }
55683 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55684 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55685 }
55686 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55687 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55688 }
55689 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55690 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55691 }
55692 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55693 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55694 }
55695 static void *_p_wxControlTo_p_wxWindow(void *x) {
55696 return (void *)((wxWindow *) ((wxControl *) x));
55697 }
55698 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55699 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55700 }
55701 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55702 return (void *)((wxWindow *) ((wxMenuBar *) x));
55703 }
55704 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55705 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55706 }
55707 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55708 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55709 }
55710 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55711 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55712 }
55713 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55714 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55715 }
55716 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55717 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55718 }
55719 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55720 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55721 }
55722 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55723 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55724 }
55725 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55726 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55727 }
55728 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55729 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55730 }
55731 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55732 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55733 }
55734 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55735 return (void *)((wxValidator *) ((wxPyValidator *) x));
55736 }
55737 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55738 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55739 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};
55740 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55741 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55742 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55743 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55744 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55745 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55746 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55747 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55748 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55749 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55750 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55751 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55752 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55753 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55754 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55755 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55756 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55757 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55758 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55759 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55760 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55761 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55762 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55763 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55765 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55766 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55817 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55818 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55819 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55820 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55821 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55822 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55823 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55824 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55825 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55826 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55827 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55828 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55829 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55830 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55831 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55832 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55833 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55834 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55835 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55836 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55837 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55838 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55839 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55840 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55841 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55842 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55843 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55844 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55845 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55846 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55847 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55848 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55849 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55850 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55851 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55852 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55853 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55854 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55855 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55856 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55857 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55858 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55859 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55860 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55861 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55862 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55863 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55864 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55865 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55866 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55867 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55868 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55869
55870 static swig_type_info *swig_type_initial[] = {
55871 &_swigt__p_buffer,
55872 &_swigt__p_char,
55873 &_swigt__p_form_ops_t,
55874 &_swigt__p_int,
55875 &_swigt__p_long,
55876 &_swigt__p_unsigned_char,
55877 &_swigt__p_unsigned_int,
55878 &_swigt__p_unsigned_long,
55879 &_swigt__p_wxANIHandler,
55880 &_swigt__p_wxAcceleratorEntry,
55881 &_swigt__p_wxAcceleratorTable,
55882 &_swigt__p_wxActivateEvent,
55883 &_swigt__p_wxAppTraits,
55884 &_swigt__p_wxArrayString,
55885 &_swigt__p_wxBMPHandler,
55886 &_swigt__p_wxBitmap,
55887 &_swigt__p_wxBoxSizer,
55888 &_swigt__p_wxButton,
55889 &_swigt__p_wxCURHandler,
55890 &_swigt__p_wxCaret,
55891 &_swigt__p_wxChildFocusEvent,
55892 &_swigt__p_wxClipboardTextEvent,
55893 &_swigt__p_wxCloseEvent,
55894 &_swigt__p_wxColour,
55895 &_swigt__p_wxCommandEvent,
55896 &_swigt__p_wxContextMenuEvent,
55897 &_swigt__p_wxControl,
55898 &_swigt__p_wxControlWithItems,
55899 &_swigt__p_wxCursor,
55900 &_swigt__p_wxDC,
55901 &_swigt__p_wxDateEvent,
55902 &_swigt__p_wxDateTime,
55903 &_swigt__p_wxDisplayChangedEvent,
55904 &_swigt__p_wxDropFilesEvent,
55905 &_swigt__p_wxDuplexMode,
55906 &_swigt__p_wxEraseEvent,
55907 &_swigt__p_wxEvent,
55908 &_swigt__p_wxEventLoop,
55909 &_swigt__p_wxEventLoopActivator,
55910 &_swigt__p_wxEvtHandler,
55911 &_swigt__p_wxFSFile,
55912 &_swigt__p_wxFileSystem,
55913 &_swigt__p_wxFileSystemHandler,
55914 &_swigt__p_wxFlexGridSizer,
55915 &_swigt__p_wxFocusEvent,
55916 &_swigt__p_wxFont,
55917 &_swigt__p_wxFrame,
55918 &_swigt__p_wxGBPosition,
55919 &_swigt__p_wxGBSizerItem,
55920 &_swigt__p_wxGBSpan,
55921 &_swigt__p_wxGIFHandler,
55922 &_swigt__p_wxGridBagSizer,
55923 &_swigt__p_wxGridSizer,
55924 &_swigt__p_wxHelpEvent__Origin,
55925 &_swigt__p_wxICOHandler,
55926 &_swigt__p_wxIconizeEvent,
55927 &_swigt__p_wxIdleEvent,
55928 &_swigt__p_wxImage,
55929 &_swigt__p_wxImageHandler,
55930 &_swigt__p_wxImageHistogram,
55931 &_swigt__p_wxImage_HSVValue,
55932 &_swigt__p_wxImage_RGBValue,
55933 &_swigt__p_wxIndividualLayoutConstraint,
55934 &_swigt__p_wxInitDialogEvent,
55935 &_swigt__p_wxInputStream,
55936 &_swigt__p_wxInternetFSHandler,
55937 &_swigt__p_wxItemContainer,
55938 &_swigt__p_wxJPEGHandler,
55939 &_swigt__p_wxKeyEvent,
55940 &_swigt__p_wxLayoutConstraints,
55941 &_swigt__p_wxMaximizeEvent,
55942 &_swigt__p_wxMemoryFSHandler,
55943 &_swigt__p_wxMenu,
55944 &_swigt__p_wxMenuBar,
55945 &_swigt__p_wxMenuBarBase,
55946 &_swigt__p_wxMenuEvent,
55947 &_swigt__p_wxMenuItem,
55948 &_swigt__p_wxMouseCaptureChangedEvent,
55949 &_swigt__p_wxMouseCaptureLostEvent,
55950 &_swigt__p_wxMouseEvent,
55951 &_swigt__p_wxMoveEvent,
55952 &_swigt__p_wxNavigationKeyEvent,
55953 &_swigt__p_wxNcPaintEvent,
55954 &_swigt__p_wxNotifyEvent,
55955 &_swigt__p_wxObject,
55956 &_swigt__p_wxOutputStream,
55957 &_swigt__p_wxPCXHandler,
55958 &_swigt__p_wxPNGHandler,
55959 &_swigt__p_wxPNMHandler,
55960 &_swigt__p_wxPaintEvent,
55961 &_swigt__p_wxPaletteChangedEvent,
55962 &_swigt__p_wxPaperSize,
55963 &_swigt__p_wxPoint,
55964 &_swigt__p_wxPoint2D,
55965 &_swigt__p_wxPropagateOnce,
55966 &_swigt__p_wxPropagationDisabler,
55967 &_swigt__p_wxPyApp,
55968 &_swigt__p_wxPyCommandEvent,
55969 &_swigt__p_wxPyDropTarget,
55970 &_swigt__p_wxPyEvent,
55971 &_swigt__p_wxPyFileSystemHandler,
55972 &_swigt__p_wxPyImageHandler,
55973 &_swigt__p_wxPyInputStream,
55974 &_swigt__p_wxPySizer,
55975 &_swigt__p_wxPyValidator,
55976 &_swigt__p_wxQuantize,
55977 &_swigt__p_wxQueryNewPaletteEvent,
55978 &_swigt__p_wxRealPoint,
55979 &_swigt__p_wxRect,
55980 &_swigt__p_wxRegion,
55981 &_swigt__p_wxScrollEvent,
55982 &_swigt__p_wxScrollWinEvent,
55983 &_swigt__p_wxSetCursorEvent,
55984 &_swigt__p_wxShowEvent,
55985 &_swigt__p_wxSize,
55986 &_swigt__p_wxSizeEvent,
55987 &_swigt__p_wxSizer,
55988 &_swigt__p_wxSizerItem,
55989 &_swigt__p_wxStaticBox,
55990 &_swigt__p_wxStaticBoxSizer,
55991 &_swigt__p_wxStdDialogButtonSizer,
55992 &_swigt__p_wxSysColourChangedEvent,
55993 &_swigt__p_wxTIFFHandler,
55994 &_swigt__p_wxToolTip,
55995 &_swigt__p_wxUpdateUIEvent,
55996 &_swigt__p_wxValidator,
55997 &_swigt__p_wxVisualAttributes,
55998 &_swigt__p_wxWindow,
55999 &_swigt__p_wxWindowCreateEvent,
56000 &_swigt__p_wxWindowDestroyEvent,
56001 &_swigt__p_wxXPMHandler,
56002 &_swigt__p_wxZipFSHandler,
56003 };
56004
56005 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56006 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56007 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56008 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56009 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56010 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56011 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56012 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56013 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56014 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56015 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56016 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56017 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56018 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56019 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}};
56020 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56021 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}};
56022 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56023 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}};
56024 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56025 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56026 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56027 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56028 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56029 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}};
56030 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56031 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}};
56032 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56033 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56034 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56035 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56038 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56039 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56040 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56041 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}};
56042 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56043 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56044 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}};
56045 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56046 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56047 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}};
56048 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}};
56049 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56055 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56056 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56057 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}};
56058 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56059 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}};
56060 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56063 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}};
56064 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56067 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56068 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56069 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56070 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56071 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}};
56072 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56073 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56074 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56075 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56079 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56080 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56081 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56082 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56083 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56084 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56085 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56086 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56087 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56088 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56089 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}};
56090 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56091 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56092 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56093 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56094 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56095 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56096 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56097 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56098 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56099 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56100 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56101 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56102 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56103 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56104 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56105 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56106 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56107 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56108 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56109 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56110 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56111 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56112 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56113 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56114 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56115 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56116 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56117 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56118 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56119 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56120 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56121 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}};
56122 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}};
56123 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56124 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56125 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56126 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56127 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56128 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56129 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56130 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}};
56131 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56132 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}};
56133 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56134 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56135 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56136 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56137
56138 static swig_cast_info *swig_cast_initial[] = {
56139 _swigc__p_buffer,
56140 _swigc__p_char,
56141 _swigc__p_form_ops_t,
56142 _swigc__p_int,
56143 _swigc__p_long,
56144 _swigc__p_unsigned_char,
56145 _swigc__p_unsigned_int,
56146 _swigc__p_unsigned_long,
56147 _swigc__p_wxANIHandler,
56148 _swigc__p_wxAcceleratorEntry,
56149 _swigc__p_wxAcceleratorTable,
56150 _swigc__p_wxActivateEvent,
56151 _swigc__p_wxAppTraits,
56152 _swigc__p_wxArrayString,
56153 _swigc__p_wxBMPHandler,
56154 _swigc__p_wxBitmap,
56155 _swigc__p_wxBoxSizer,
56156 _swigc__p_wxButton,
56157 _swigc__p_wxCURHandler,
56158 _swigc__p_wxCaret,
56159 _swigc__p_wxChildFocusEvent,
56160 _swigc__p_wxClipboardTextEvent,
56161 _swigc__p_wxCloseEvent,
56162 _swigc__p_wxColour,
56163 _swigc__p_wxCommandEvent,
56164 _swigc__p_wxContextMenuEvent,
56165 _swigc__p_wxControl,
56166 _swigc__p_wxControlWithItems,
56167 _swigc__p_wxCursor,
56168 _swigc__p_wxDC,
56169 _swigc__p_wxDateEvent,
56170 _swigc__p_wxDateTime,
56171 _swigc__p_wxDisplayChangedEvent,
56172 _swigc__p_wxDropFilesEvent,
56173 _swigc__p_wxDuplexMode,
56174 _swigc__p_wxEraseEvent,
56175 _swigc__p_wxEvent,
56176 _swigc__p_wxEventLoop,
56177 _swigc__p_wxEventLoopActivator,
56178 _swigc__p_wxEvtHandler,
56179 _swigc__p_wxFSFile,
56180 _swigc__p_wxFileSystem,
56181 _swigc__p_wxFileSystemHandler,
56182 _swigc__p_wxFlexGridSizer,
56183 _swigc__p_wxFocusEvent,
56184 _swigc__p_wxFont,
56185 _swigc__p_wxFrame,
56186 _swigc__p_wxGBPosition,
56187 _swigc__p_wxGBSizerItem,
56188 _swigc__p_wxGBSpan,
56189 _swigc__p_wxGIFHandler,
56190 _swigc__p_wxGridBagSizer,
56191 _swigc__p_wxGridSizer,
56192 _swigc__p_wxHelpEvent__Origin,
56193 _swigc__p_wxICOHandler,
56194 _swigc__p_wxIconizeEvent,
56195 _swigc__p_wxIdleEvent,
56196 _swigc__p_wxImage,
56197 _swigc__p_wxImageHandler,
56198 _swigc__p_wxImageHistogram,
56199 _swigc__p_wxImage_HSVValue,
56200 _swigc__p_wxImage_RGBValue,
56201 _swigc__p_wxIndividualLayoutConstraint,
56202 _swigc__p_wxInitDialogEvent,
56203 _swigc__p_wxInputStream,
56204 _swigc__p_wxInternetFSHandler,
56205 _swigc__p_wxItemContainer,
56206 _swigc__p_wxJPEGHandler,
56207 _swigc__p_wxKeyEvent,
56208 _swigc__p_wxLayoutConstraints,
56209 _swigc__p_wxMaximizeEvent,
56210 _swigc__p_wxMemoryFSHandler,
56211 _swigc__p_wxMenu,
56212 _swigc__p_wxMenuBar,
56213 _swigc__p_wxMenuBarBase,
56214 _swigc__p_wxMenuEvent,
56215 _swigc__p_wxMenuItem,
56216 _swigc__p_wxMouseCaptureChangedEvent,
56217 _swigc__p_wxMouseCaptureLostEvent,
56218 _swigc__p_wxMouseEvent,
56219 _swigc__p_wxMoveEvent,
56220 _swigc__p_wxNavigationKeyEvent,
56221 _swigc__p_wxNcPaintEvent,
56222 _swigc__p_wxNotifyEvent,
56223 _swigc__p_wxObject,
56224 _swigc__p_wxOutputStream,
56225 _swigc__p_wxPCXHandler,
56226 _swigc__p_wxPNGHandler,
56227 _swigc__p_wxPNMHandler,
56228 _swigc__p_wxPaintEvent,
56229 _swigc__p_wxPaletteChangedEvent,
56230 _swigc__p_wxPaperSize,
56231 _swigc__p_wxPoint,
56232 _swigc__p_wxPoint2D,
56233 _swigc__p_wxPropagateOnce,
56234 _swigc__p_wxPropagationDisabler,
56235 _swigc__p_wxPyApp,
56236 _swigc__p_wxPyCommandEvent,
56237 _swigc__p_wxPyDropTarget,
56238 _swigc__p_wxPyEvent,
56239 _swigc__p_wxPyFileSystemHandler,
56240 _swigc__p_wxPyImageHandler,
56241 _swigc__p_wxPyInputStream,
56242 _swigc__p_wxPySizer,
56243 _swigc__p_wxPyValidator,
56244 _swigc__p_wxQuantize,
56245 _swigc__p_wxQueryNewPaletteEvent,
56246 _swigc__p_wxRealPoint,
56247 _swigc__p_wxRect,
56248 _swigc__p_wxRegion,
56249 _swigc__p_wxScrollEvent,
56250 _swigc__p_wxScrollWinEvent,
56251 _swigc__p_wxSetCursorEvent,
56252 _swigc__p_wxShowEvent,
56253 _swigc__p_wxSize,
56254 _swigc__p_wxSizeEvent,
56255 _swigc__p_wxSizer,
56256 _swigc__p_wxSizerItem,
56257 _swigc__p_wxStaticBox,
56258 _swigc__p_wxStaticBoxSizer,
56259 _swigc__p_wxStdDialogButtonSizer,
56260 _swigc__p_wxSysColourChangedEvent,
56261 _swigc__p_wxTIFFHandler,
56262 _swigc__p_wxToolTip,
56263 _swigc__p_wxUpdateUIEvent,
56264 _swigc__p_wxValidator,
56265 _swigc__p_wxVisualAttributes,
56266 _swigc__p_wxWindow,
56267 _swigc__p_wxWindowCreateEvent,
56268 _swigc__p_wxWindowDestroyEvent,
56269 _swigc__p_wxXPMHandler,
56270 _swigc__p_wxZipFSHandler,
56271 };
56272
56273
56274 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56275
56276 static swig_const_info swig_const_table[] = {
56277 {0, 0, 0, 0.0, 0, 0}};
56278
56279 #ifdef __cplusplus
56280 }
56281 #endif
56282 /* -----------------------------------------------------------------------------
56283 * Type initialization:
56284 * This problem is tough by the requirement that no dynamic
56285 * memory is used. Also, since swig_type_info structures store pointers to
56286 * swig_cast_info structures and swig_cast_info structures store pointers back
56287 * to swig_type_info structures, we need some lookup code at initialization.
56288 * The idea is that swig generates all the structures that are needed.
56289 * The runtime then collects these partially filled structures.
56290 * The SWIG_InitializeModule function takes these initial arrays out of
56291 * swig_module, and does all the lookup, filling in the swig_module.types
56292 * array with the correct data and linking the correct swig_cast_info
56293 * structures together.
56294 *
56295 * The generated swig_type_info structures are assigned staticly to an initial
56296 * array. We just loop though that array, and handle each type individually.
56297 * First we lookup if this type has been already loaded, and if so, use the
56298 * loaded structure instead of the generated one. Then we have to fill in the
56299 * cast linked list. The cast data is initially stored in something like a
56300 * two-dimensional array. Each row corresponds to a type (there are the same
56301 * number of rows as there are in the swig_type_initial array). Each entry in
56302 * a column is one of the swig_cast_info structures for that type.
56303 * The cast_initial array is actually an array of arrays, because each row has
56304 * a variable number of columns. So to actually build the cast linked list,
56305 * we find the array of casts associated with the type, and loop through it
56306 * adding the casts to the list. The one last trick we need to do is making
56307 * sure the type pointer in the swig_cast_info struct is correct.
56308 *
56309 * First off, we lookup the cast->type name to see if it is already loaded.
56310 * There are three cases to handle:
56311 * 1) If the cast->type has already been loaded AND the type we are adding
56312 * casting info to has not been loaded (it is in this module), THEN we
56313 * replace the cast->type pointer with the type pointer that has already
56314 * been loaded.
56315 * 2) If BOTH types (the one we are adding casting info to, and the
56316 * cast->type) are loaded, THEN the cast info has already been loaded by
56317 * the previous module so we just ignore it.
56318 * 3) Finally, if cast->type has not already been loaded, then we add that
56319 * swig_cast_info to the linked list (because the cast->type) pointer will
56320 * be correct.
56321 * ----------------------------------------------------------------------------- */
56322
56323 #ifdef __cplusplus
56324 extern "C" {
56325 #if 0
56326 } /* c-mode */
56327 #endif
56328 #endif
56329
56330 #if 0
56331 #define SWIGRUNTIME_DEBUG
56332 #endif
56333
56334 SWIGRUNTIME void
56335 SWIG_InitializeModule(void *clientdata) {
56336 size_t i;
56337 swig_module_info *module_head;
56338 static int init_run = 0;
56339
56340 clientdata = clientdata;
56341
56342 if (init_run) return;
56343 init_run = 1;
56344
56345 /* Initialize the swig_module */
56346 swig_module.type_initial = swig_type_initial;
56347 swig_module.cast_initial = swig_cast_initial;
56348
56349 /* Try and load any already created modules */
56350 module_head = SWIG_GetModule(clientdata);
56351 if (module_head) {
56352 swig_module.next = module_head->next;
56353 module_head->next = &swig_module;
56354 } else {
56355 /* This is the first module loaded */
56356 swig_module.next = &swig_module;
56357 SWIG_SetModule(clientdata, &swig_module);
56358 }
56359
56360 /* Now work on filling in swig_module.types */
56361 #ifdef SWIGRUNTIME_DEBUG
56362 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56363 #endif
56364 for (i = 0; i < swig_module.size; ++i) {
56365 swig_type_info *type = 0;
56366 swig_type_info *ret;
56367 swig_cast_info *cast;
56368
56369 #ifdef SWIGRUNTIME_DEBUG
56370 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56371 #endif
56372
56373 /* if there is another module already loaded */
56374 if (swig_module.next != &swig_module) {
56375 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56376 }
56377 if (type) {
56378 /* Overwrite clientdata field */
56379 #ifdef SWIGRUNTIME_DEBUG
56380 printf("SWIG_InitializeModule: found type %s\n", type->name);
56381 #endif
56382 if (swig_module.type_initial[i]->clientdata) {
56383 type->clientdata = swig_module.type_initial[i]->clientdata;
56384 #ifdef SWIGRUNTIME_DEBUG
56385 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56386 #endif
56387 }
56388 } else {
56389 type = swig_module.type_initial[i];
56390 }
56391
56392 /* Insert casting types */
56393 cast = swig_module.cast_initial[i];
56394 while (cast->type) {
56395 /* Don't need to add information already in the list */
56396 ret = 0;
56397 #ifdef SWIGRUNTIME_DEBUG
56398 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56399 #endif
56400 if (swig_module.next != &swig_module) {
56401 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56402 #ifdef SWIGRUNTIME_DEBUG
56403 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56404 #endif
56405 }
56406 if (ret) {
56407 if (type == swig_module.type_initial[i]) {
56408 #ifdef SWIGRUNTIME_DEBUG
56409 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56410 #endif
56411 cast->type = ret;
56412 ret = 0;
56413 } else {
56414 /* Check for casting already in the list */
56415 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56416 #ifdef SWIGRUNTIME_DEBUG
56417 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56418 #endif
56419 if (!ocast) ret = 0;
56420 }
56421 }
56422
56423 if (!ret) {
56424 #ifdef SWIGRUNTIME_DEBUG
56425 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56426 #endif
56427 if (type->cast) {
56428 type->cast->prev = cast;
56429 cast->next = type->cast;
56430 }
56431 type->cast = cast;
56432 }
56433 cast++;
56434 }
56435 /* Set entry in modules->types array equal to the type */
56436 swig_module.types[i] = type;
56437 }
56438 swig_module.types[i] = 0;
56439
56440 #ifdef SWIGRUNTIME_DEBUG
56441 printf("**** SWIG_InitializeModule: Cast List ******\n");
56442 for (i = 0; i < swig_module.size; ++i) {
56443 int j = 0;
56444 swig_cast_info *cast = swig_module.cast_initial[i];
56445 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56446 while (cast->type) {
56447 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56448 cast++;
56449 ++j;
56450 }
56451 printf("---- Total casts: %d\n",j);
56452 }
56453 printf("**** SWIG_InitializeModule: Cast List ******\n");
56454 #endif
56455 }
56456
56457 /* This function will propagate the clientdata field of type to
56458 * any new swig_type_info structures that have been added into the list
56459 * of equivalent types. It is like calling
56460 * SWIG_TypeClientData(type, clientdata) a second time.
56461 */
56462 SWIGRUNTIME void
56463 SWIG_PropagateClientData(void) {
56464 size_t i;
56465 swig_cast_info *equiv;
56466 static int init_run = 0;
56467
56468 if (init_run) return;
56469 init_run = 1;
56470
56471 for (i = 0; i < swig_module.size; i++) {
56472 if (swig_module.types[i]->clientdata) {
56473 equiv = swig_module.types[i]->cast;
56474 while (equiv) {
56475 if (!equiv->converter) {
56476 if (equiv->type && !equiv->type->clientdata)
56477 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56478 }
56479 equiv = equiv->next;
56480 }
56481 }
56482 }
56483 }
56484
56485 #ifdef __cplusplus
56486 #if 0
56487 {
56488 /* c-mode */
56489 #endif
56490 }
56491 #endif
56492
56493
56494
56495 #ifdef __cplusplus
56496 extern "C" {
56497 #endif
56498
56499 /* Python-specific SWIG API */
56500 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56501 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56502 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56503
56504 /* -----------------------------------------------------------------------------
56505 * global variable support code.
56506 * ----------------------------------------------------------------------------- */
56507
56508 typedef struct swig_globalvar {
56509 char *name; /* Name of global variable */
56510 PyObject *(*get_attr)(void); /* Return the current value */
56511 int (*set_attr)(PyObject *); /* Set the value */
56512 struct swig_globalvar *next;
56513 } swig_globalvar;
56514
56515 typedef struct swig_varlinkobject {
56516 PyObject_HEAD
56517 swig_globalvar *vars;
56518 } swig_varlinkobject;
56519
56520 SWIGINTERN PyObject *
56521 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56522 return PyString_FromString("<Swig global variables>");
56523 }
56524
56525 SWIGINTERN PyObject *
56526 swig_varlink_str(swig_varlinkobject *v) {
56527 PyObject *str = PyString_FromString("(");
56528 swig_globalvar *var;
56529 for (var = v->vars; var; var=var->next) {
56530 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56531 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56532 }
56533 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56534 return str;
56535 }
56536
56537 SWIGINTERN int
56538 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56539 PyObject *str = swig_varlink_str(v);
56540 fprintf(fp,"Swig global variables ");
56541 fprintf(fp,"%s\n", PyString_AsString(str));
56542 Py_DECREF(str);
56543 return 0;
56544 }
56545
56546 SWIGINTERN void
56547 swig_varlink_dealloc(swig_varlinkobject *v) {
56548 swig_globalvar *var = v->vars;
56549 while (var) {
56550 swig_globalvar *n = var->next;
56551 free(var->name);
56552 free(var);
56553 var = n;
56554 }
56555 }
56556
56557 SWIGINTERN PyObject *
56558 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56559 PyObject *res = NULL;
56560 swig_globalvar *var = v->vars;
56561 while (var) {
56562 if (strcmp(var->name,n) == 0) {
56563 res = (*var->get_attr)();
56564 break;
56565 }
56566 var = var->next;
56567 }
56568 if (res == NULL && !PyErr_Occurred()) {
56569 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56570 }
56571 return res;
56572 }
56573
56574 SWIGINTERN int
56575 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56576 int res = 1;
56577 swig_globalvar *var = v->vars;
56578 while (var) {
56579 if (strcmp(var->name,n) == 0) {
56580 res = (*var->set_attr)(p);
56581 break;
56582 }
56583 var = var->next;
56584 }
56585 if (res == 1 && !PyErr_Occurred()) {
56586 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56587 }
56588 return res;
56589 }
56590
56591 SWIGINTERN PyTypeObject*
56592 swig_varlink_type(void) {
56593 static char varlink__doc__[] = "Swig var link object";
56594 static PyTypeObject varlink_type;
56595 static int type_init = 0;
56596 if (!type_init) {
56597 const PyTypeObject tmp
56598 = {
56599 PyObject_HEAD_INIT(NULL)
56600 0, /* Number of items in variable part (ob_size) */
56601 (char *)"swigvarlink", /* Type name (tp_name) */
56602 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56603 0, /* Itemsize (tp_itemsize) */
56604 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56605 (printfunc) swig_varlink_print, /* Print (tp_print) */
56606 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56607 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56608 0, /* tp_compare */
56609 (reprfunc) swig_varlink_repr, /* tp_repr */
56610 0, /* tp_as_number */
56611 0, /* tp_as_sequence */
56612 0, /* tp_as_mapping */
56613 0, /* tp_hash */
56614 0, /* tp_call */
56615 (reprfunc)swig_varlink_str, /* tp_str */
56616 0, /* tp_getattro */
56617 0, /* tp_setattro */
56618 0, /* tp_as_buffer */
56619 0, /* tp_flags */
56620 varlink__doc__, /* tp_doc */
56621 0, /* tp_traverse */
56622 0, /* tp_clear */
56623 0, /* tp_richcompare */
56624 0, /* tp_weaklistoffset */
56625 #if PY_VERSION_HEX >= 0x02020000
56626 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56627 #endif
56628 #if PY_VERSION_HEX >= 0x02030000
56629 0, /* tp_del */
56630 #endif
56631 #ifdef COUNT_ALLOCS
56632 0,0,0,0 /* tp_alloc -> tp_next */
56633 #endif
56634 };
56635 varlink_type = tmp;
56636 varlink_type.ob_type = &PyType_Type;
56637 type_init = 1;
56638 }
56639 return &varlink_type;
56640 }
56641
56642 /* Create a variable linking object for use later */
56643 SWIGINTERN PyObject *
56644 SWIG_Python_newvarlink(void) {
56645 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56646 if (result) {
56647 result->vars = 0;
56648 }
56649 return ((PyObject*) result);
56650 }
56651
56652 SWIGINTERN void
56653 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56654 swig_varlinkobject *v = (swig_varlinkobject *) p;
56655 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56656 if (gv) {
56657 size_t size = strlen(name)+1;
56658 gv->name = (char *)malloc(size);
56659 if (gv->name) {
56660 strncpy(gv->name,name,size);
56661 gv->get_attr = get_attr;
56662 gv->set_attr = set_attr;
56663 gv->next = v->vars;
56664 }
56665 }
56666 v->vars = gv;
56667 }
56668
56669 SWIGINTERN PyObject *
56670 SWIG_globals() {
56671 static PyObject *_SWIG_globals = 0;
56672 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56673 return _SWIG_globals;
56674 }
56675
56676 /* -----------------------------------------------------------------------------
56677 * constants/methods manipulation
56678 * ----------------------------------------------------------------------------- */
56679
56680 /* Install Constants */
56681 SWIGINTERN void
56682 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56683 PyObject *obj = 0;
56684 size_t i;
56685 for (i = 0; constants[i].type; ++i) {
56686 switch(constants[i].type) {
56687 case SWIG_PY_POINTER:
56688 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56689 break;
56690 case SWIG_PY_BINARY:
56691 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56692 break;
56693 default:
56694 obj = 0;
56695 break;
56696 }
56697 if (obj) {
56698 PyDict_SetItemString(d, constants[i].name, obj);
56699 Py_DECREF(obj);
56700 }
56701 }
56702 }
56703
56704 /* -----------------------------------------------------------------------------*/
56705 /* Fix SwigMethods to carry the callback ptrs when needed */
56706 /* -----------------------------------------------------------------------------*/
56707
56708 SWIGINTERN void
56709 SWIG_Python_FixMethods(PyMethodDef *methods,
56710 swig_const_info *const_table,
56711 swig_type_info **types,
56712 swig_type_info **types_initial) {
56713 size_t i;
56714 for (i = 0; methods[i].ml_name; ++i) {
56715 const char *c = methods[i].ml_doc;
56716 if (c && (c = strstr(c, "swig_ptr: "))) {
56717 int j;
56718 swig_const_info *ci = 0;
56719 const char *name = c + 10;
56720 for (j = 0; const_table[j].type; ++j) {
56721 if (strncmp(const_table[j].name, name,
56722 strlen(const_table[j].name)) == 0) {
56723 ci = &(const_table[j]);
56724 break;
56725 }
56726 }
56727 if (ci) {
56728 size_t shift = (ci->ptype) - types;
56729 swig_type_info *ty = types_initial[shift];
56730 size_t ldoc = (c - methods[i].ml_doc);
56731 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56732 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56733 if (ndoc) {
56734 char *buff = ndoc;
56735 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56736 if (ptr) {
56737 strncpy(buff, methods[i].ml_doc, ldoc);
56738 buff += ldoc;
56739 strncpy(buff, "swig_ptr: ", 10);
56740 buff += 10;
56741 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56742 methods[i].ml_doc = ndoc;
56743 }
56744 }
56745 }
56746 }
56747 }
56748 }
56749
56750 #ifdef __cplusplus
56751 }
56752 #endif
56753
56754 /* -----------------------------------------------------------------------------*
56755 * Partial Init method
56756 * -----------------------------------------------------------------------------*/
56757
56758 #ifdef __cplusplus
56759 extern "C"
56760 #endif
56761 SWIGEXPORT void SWIG_init(void) {
56762 PyObject *m, *d;
56763
56764 /* Fix SwigMethods to carry the callback ptrs when needed */
56765 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56766
56767 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56768 d = PyModule_GetDict(m);
56769
56770 SWIG_InitializeModule(0);
56771 SWIG_InstallConstants(d,swig_const_table);
56772
56773
56774
56775 #ifndef wxPyUSE_EXPORT
56776 // Make our API structure a CObject so other modules can import it
56777 // from this module.
56778 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56779 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56780 Py_XDECREF(cobj);
56781 #endif
56782
56783 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56784 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56785 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56786 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56787 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56788 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56789 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56790 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56791 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56792 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56793 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56794 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56795 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56796 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56797 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56798 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56799 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56800 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56801 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56802 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56803 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56804 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56805 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56806 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56807 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56808 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56809 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56810 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56811 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56812 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56813 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56814 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56815 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56816 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56817 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56818 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56819 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56820 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56821 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56822 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56823 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56824 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56825 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56826 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56827 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56828 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56829 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56830 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56831 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56832 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56833 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56834 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56835 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56836 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56837 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56838 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56839 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56840 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56841 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56842 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56843 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56844 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56845 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56846 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56847 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56848 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56849 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56850 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56851 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56852 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56853 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56854 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56855 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56856 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56857 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56858 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56859 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56860 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56861 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56862 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56863 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56864 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56865 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56866 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56867 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56868 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56869 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56870 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56871 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56872 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56873 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56874 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56875 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56876 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56877 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56878 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56879 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56880 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56881 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56882 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56883 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56884 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56885 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56886 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56887 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56888 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56889 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56890 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56891 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56892 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56893 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56894 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56895 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56896 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56897 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56898 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56899 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56900 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56901 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56902 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56903 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56904 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56905 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56906 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56907 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56908 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56909 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56910 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56911 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56912 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56913 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56914 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56915 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56916 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56917 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56918 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56919 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56920 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56921 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56922 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56923 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56924 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56925 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56926 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56927 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56928 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56929 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56930 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56931 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56932 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56933 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56934 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56935 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56936 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56937 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56938 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56939 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56940 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56941 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56942 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56943 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56944 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56945 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56946 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56947 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56948 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56949 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56950 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56951 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56952 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56953 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56954 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56955 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56956 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56957 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56958 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56959 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56960 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56961 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56962 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56963 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56964 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56965 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56966 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56967 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56968 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56969 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56970 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56971 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56972 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56973 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56974 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56975 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56976 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56977 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56978 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56979 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56980 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56981 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56982 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56983 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56984 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56985 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56986 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56987 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56988 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56989 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56990 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56991 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56992 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56993 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56994 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56995 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56996 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56997 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56998 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56999 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57000 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57001 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57002 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57003 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57004 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57005 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57006 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57007 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57008 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57009 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57010 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57011 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57012 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57013 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57014 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57015 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57016 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57017 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57018 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57019 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57020 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57021 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57022 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57023 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57024 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57025 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57026 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57027 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57028 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57029 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57030 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57031 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57032 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57033 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57034 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57035 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57036 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57037 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57038 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57039 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57040 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57041 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57042 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57043 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57044 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57045 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57046 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57047 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57048 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57049 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57050 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57051 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57052 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57053 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57054 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57055 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57056 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57057 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57058 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57059 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57060 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57061 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57062 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57063 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57064 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57065 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57066 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57067 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57068 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57069 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57070 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57071 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57072 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57073 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57074 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57075 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57076 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57077 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57078 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57079 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57080 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57081 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57082 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57083 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57084 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57085 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57086 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57087 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57088 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57089 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57090 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57091 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57092 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57093 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57094 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57095 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57096 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57097 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57098 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57099 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57100 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57101 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57102 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57103 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57104 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57105 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57106 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57107 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57108 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57109 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57110 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57111 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57112 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57113 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57114 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57115 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57116 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57117 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57118 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57119 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57120 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57121 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57122 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57123 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57124 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57125 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57126 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57127 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57128 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57129 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57130 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57131 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57132 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57133 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57134 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57135 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57136 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57137 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57138 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57139 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57140 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57141 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57142 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57143 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57144 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57145 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57146 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57147 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57148 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57149 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57150 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57151 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57152 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57153 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57154 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57155 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57156 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57157 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57158 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57159 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57160 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57161 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57162 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57163 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57164 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57165 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57166 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57167 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57168 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57169 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57170 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57171 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57172 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57173 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57174 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57175 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57176 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57177 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57178 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57179 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57180 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57181 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57182 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57183 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57184 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57185 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57186 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57187 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57188 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57189 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57190 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57191 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57192 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57193 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57194 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57195 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57196 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57197 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57198 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57199 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57200 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57201 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57202 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57203 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57204 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57205 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57206 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57207 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57208 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57209 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57210 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57211 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57212 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57213 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57214 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57215 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57216 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57217 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57218 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57219 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57220 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57221 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57222 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57223 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57224 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57225 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57226 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57227 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57228 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57229 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57230 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57231 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57232 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57233 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57234 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57235 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57236 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57237 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57238 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57239 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57240 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57241 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57242 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57243 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57244 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57245 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57246 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57247 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57248 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57249 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57250 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57251 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57252 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57253 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57254 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57255 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57256 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57257 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57258 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57259 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57260 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57261 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57262 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57263 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57264 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57265 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57266 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57267 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57268 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57269 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57270 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57271 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57272 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57273 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57274 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57275 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57276 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57277 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57278 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57279 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57280 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57281 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57282 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57283 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57284 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57285 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57286 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57287 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57288 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57289 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57290 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57291 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57292 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57293 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57294 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57295 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57296 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57297 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57298 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57299 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57300 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57301 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57302 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57303 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57304 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57305 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57306 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57307 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57308 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57309 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57310 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57311 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57312 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57313 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57314 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57315 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57316 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57317 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57318 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57319 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57320 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57321 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57322 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57323 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57324 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57325 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57326 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57327 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57328 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57329 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57330 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57331 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57332 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57333 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57334 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57335 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57336 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57337 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57338 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57339 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57340 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57341 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57342 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57343 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57344 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57345 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57346 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57347 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57348 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57349 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57350 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57351 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57352 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57353 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57354 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57355 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57356 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57357 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57358 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57359 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57360 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57361 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57362 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57363 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57364 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57365 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57366 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57367 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57368 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57369 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57370 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57371 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57372 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57373 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57374 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57375 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57376 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57377 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57378 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57379 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57380 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57381 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57382 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57383 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57384 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57385 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57386 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57387 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57388 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57389 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57390 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57391 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57392 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57393 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57394 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57395 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57396 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57397 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57398 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57399 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57400 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57401 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57402 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57403 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57404 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57405 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57406 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57407 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57408 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57409 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57410 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57411 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57412 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57413 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57414 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57415 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57416 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57417 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57418 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57419 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57420 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57421 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57422 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57423 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57424 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57425 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57426 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57427 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57428 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57429 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57430 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57431 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57432 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57433 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57434 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57435 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57436 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57437 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57438 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57439 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57440 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57441 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57442
57443 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57444
57445
57446 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57447
57448 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57449 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57450 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57451 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57452 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57453 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57454 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57455 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57456 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57457 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57458 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57459 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57460 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57461 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57462 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57463 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57464 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57465 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57466 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57467 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57468 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57469 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57470 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57471 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57472 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57473 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57474 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57475 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57476 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57477 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57478 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57479 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57480 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57481 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57482 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57483 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57484 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57485 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57486 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57487 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57488 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57489 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57490 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57491 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57492 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57493 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57494 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57495 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57496 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57497 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57498 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57499 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57500 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57501 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57502 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57503 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57504 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57505 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57506 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57507 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57508 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57509 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57510 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57511 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57512 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57513 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57514 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57515 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57516 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57517 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57518 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57519 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57520 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57521 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57522 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57523 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57524 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57525 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57526 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57527 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57528 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57529 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57530 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57531 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57532 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57533 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57534 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57535 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57536 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57537 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57538 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57539 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57540 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57541 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57542 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57543 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57544 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57545 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57546 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57547 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57548 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57549 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57550 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57551 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57552 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57553 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57554 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57555 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57556 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57557 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57558 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57559 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57560 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57561 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57562 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57563 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57564 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57565 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57566 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57567 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57568 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57569 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57570 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57571 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57572 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57573 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57574 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57575 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57576 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57577 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57578 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57579 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57580 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57581 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57582 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57583 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57584 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57585 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57586 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57587 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57588 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57589 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57590 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57591 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57592 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57593 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57594 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57595 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57596 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57597 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57598 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57599 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57600 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57601 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57602 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57603 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57604 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57605 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57606 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57607 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57608 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57609 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57610 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57611 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57612 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57613 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57614 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57615 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57616 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57617 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57618 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57619 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57620 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57621 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57622 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57623 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57624 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57625 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57626 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57627 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57628 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57629 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57630 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57631 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57632 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57633 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57634 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57635 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57636 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57637 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57638 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57639 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57640 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57641 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57642 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57643 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57644 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57645 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57646 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57647 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57648 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57649 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57650 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57651 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57652 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57653 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57654 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57655 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57656 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57657 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57658 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57659 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57660
57661 // Initialize threading, some globals and such
57662 __wxPyPreStart(d);
57663
57664
57665 // Although these are defined in __version__ they need to be here too so
57666 // that an assert can be done to ensure that the wxPython and the wxWindows
57667 // versions match.
57668 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57669 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57670 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57671
57672 }
57673
wxWidgets (Impactor)