]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
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
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29 /***********************************************************************
30 *
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 *
34 ************************************************************************/
35
36 /* template workaround for compilers that cannot correctly implement the C++ standard */
37 #ifndef SWIGTEMPLATEDISAMBIGUATOR
38 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 #endif
44
45 /* inline attribute */
46 #ifndef SWIGINLINE
47 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
48 # define SWIGINLINE inline
49 # else
50 # define SWIGINLINE
51 # endif
52 #endif
53
54 /* attribute recognised by some compilers to avoid 'unused' warnings */
55 #ifndef SWIGUNUSED
56 # if defined(__GNUC__) || defined(__ICC)
57 # define SWIGUNUSED __attribute__ ((unused))
58 # else
59 # define SWIGUNUSED
60 # endif
61 #endif
62
63 /* internal SWIG method */
64 #ifndef SWIGINTERN
65 # define SWIGINTERN static SWIGUNUSED
66 #endif
67
68 /* internal inline SWIG method */
69 #ifndef SWIGINTERNINLINE
70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
71 #endif
72
73 /* exporting methods for Windows DLLs */
74 #ifndef SWIGEXPORT
75 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
76 # if defined(STATIC_LINKED)
77 # define SWIGEXPORT
78 # else
79 # define SWIGEXPORT __declspec(dllexport)
80 # endif
81 # else
82 # define SWIGEXPORT
83 # endif
84 #endif
85
86 /* calling conventions for Windows */
87 #ifndef SWIGSTDCALL
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # define SWIGSTDCALL __stdcall
90 # else
91 # define SWIGSTDCALL
92 # endif
93 #endif
94
95
96
97 #include <Python.h>
98
99 /***********************************************************************
100 * swigrun.swg
101 *
102 * This file contains generic CAPI SWIG runtime support for pointer
103 * type checking.
104 *
105 ************************************************************************/
106
107 /* This should only be incremented when either the layout of swig_type_info changes,
108 or for whatever reason, the runtime changes incompatibly */
109 #define SWIG_RUNTIME_VERSION "2"
110
111 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
112 #ifdef SWIG_TYPE_TABLE
113 # define SWIG_QUOTE_STRING(x) #x
114 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
115 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
116 #else
117 # define SWIG_TYPE_TABLE_NAME
118 #endif
119
120 /*
121 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
122 creating a static or dynamic library from the swig runtime code.
123 In 99.9% of the cases, swig just needs to declare them as 'static'.
124
125 But only do this if is strictly necessary, ie, if you have problems
126 with your compiler or so.
127 */
128
129 #ifndef SWIGRUNTIME
130 # define SWIGRUNTIME SWIGINTERN
131 #endif
132
133 #ifndef SWIGRUNTIMEINLINE
134 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
135 #endif
136
137 #include <string.h>
138
139 #ifdef __cplusplus
140 extern "C" {
141 #endif
142
143 typedef void *(*swig_converter_func)(void *);
144 typedef struct swig_type_info *(*swig_dycast_func)(void **);
145
146 /* Structure to store inforomation on one type */
147 typedef struct swig_type_info {
148 const char *name; /* mangled name of this type */
149 const char *str; /* human readable name of this type */
150 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
151 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
152 void *clientdata; /* language specific type data */
153 } swig_type_info;
154
155 /* Structure to store a type and conversion function used for casting */
156 typedef struct swig_cast_info {
157 swig_type_info *type; /* pointer to type that is equivalent to this type */
158 swig_converter_func converter; /* function to cast the void pointers */
159 struct swig_cast_info *next; /* pointer to next cast in linked list */
160 struct swig_cast_info *prev; /* pointer to the previous cast */
161 } swig_cast_info;
162
163 /* Structure used to store module information
164 * Each module generates one structure like this, and the runtime collects
165 * all of these structures and stores them in a circularly linked list.*/
166 typedef struct swig_module_info {
167 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
168 size_t size; /* Number of types in this module */
169 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
170 swig_type_info **type_initial; /* Array of initially generated type structures */
171 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
172 void *clientdata; /* Language specific module data */
173 } swig_module_info;
174
175
176 /*
177 Compare two type names skipping the space characters, therefore
178 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
179
180 Return 0 when the two name types are equivalent, as in
181 strncmp, but skipping ' '.
182 */
183 SWIGRUNTIME int
184 SWIG_TypeNameComp(const char *f1, const char *l1,
185 const char *f2, const char *l2) {
186 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
187 while ((*f1 == ' ') && (f1 != l1)) ++f1;
188 while ((*f2 == ' ') && (f2 != l2)) ++f2;
189 if (*f1 != *f2) return (int)(*f1 - *f2);
190 }
191 return (l1 - f1) - (l2 - f2);
192 }
193
194 /*
195 Check type equivalence in a name list like <name1>|<name2>|...
196 Return 0 if not equal, 1 if equal
197 */
198 SWIGRUNTIME int
199 SWIG_TypeEquiv(const char *nb, const char *tb) {
200 int equiv = 0;
201 const char* te = tb + strlen(tb);
202 const char* ne = nb;
203 while (!equiv && *ne) {
204 for (nb = ne; *ne; ++ne) {
205 if (*ne == '|') break;
206 }
207 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
208 if (*ne) ++ne;
209 }
210 return equiv;
211 }
212
213 /*
214 Check type equivalence in a name list like <name1>|<name2>|...
215 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
216 */
217 SWIGRUNTIME int
218 SWIG_TypeCompare(const char *nb, const char *tb) {
219 int equiv = 0;
220 const char* te = tb + strlen(tb);
221 const char* ne = nb;
222 while (!equiv && *ne) {
223 for (nb = ne; *ne; ++ne) {
224 if (*ne == '|') break;
225 }
226 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
227 if (*ne) ++ne;
228 }
229 return equiv;
230 }
231
232
233 /* think of this as a c++ template<> or a scheme macro */
234 #define SWIG_TypeCheck_Template(comparison, ty) \
235 if (ty) { \
236 swig_cast_info *iter = ty->cast; \
237 while (iter) { \
238 if (comparison) { \
239 if (iter == ty->cast) return iter; \
240 /* Move iter to the top of the linked list */ \
241 iter->prev->next = iter->next; \
242 if (iter->next) \
243 iter->next->prev = iter->prev; \
244 iter->next = ty->cast; \
245 iter->prev = 0; \
246 if (ty->cast) ty->cast->prev = iter; \
247 ty->cast = iter; \
248 return iter; \
249 } \
250 iter = iter->next; \
251 } \
252 } \
253 return 0
254
255 /*
256 Check the typename
257 */
258 SWIGRUNTIME swig_cast_info *
259 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
260 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
261 }
262
263 /* Same as previous function, except strcmp is replaced with a pointer comparison */
264 SWIGRUNTIME swig_cast_info *
265 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
266 SWIG_TypeCheck_Template(iter->type == from, into);
267 }
268
269 /*
270 Cast a pointer up an inheritance hierarchy
271 */
272 SWIGRUNTIMEINLINE void *
273 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
274 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
275 }
276
277 /*
278 Dynamic pointer casting. Down an inheritance hierarchy
279 */
280 SWIGRUNTIME swig_type_info *
281 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
282 swig_type_info *lastty = ty;
283 if (!ty || !ty->dcast) return ty;
284 while (ty && (ty->dcast)) {
285 ty = (*ty->dcast)(ptr);
286 if (ty) lastty = ty;
287 }
288 return lastty;
289 }
290
291 /*
292 Return the name associated with this type
293 */
294 SWIGRUNTIMEINLINE const char *
295 SWIG_TypeName(const swig_type_info *ty) {
296 return ty->name;
297 }
298
299 /*
300 Return the pretty name associated with this type,
301 that is an unmangled type name in a form presentable to the user.
302 */
303 SWIGRUNTIME const char *
304 SWIG_TypePrettyName(const swig_type_info *type) {
305 /* The "str" field contains the equivalent pretty names of the
306 type, separated by vertical-bar characters. We choose
307 to print the last name, as it is often (?) the most
308 specific. */
309 if (type->str != NULL) {
310 const char *last_name = type->str;
311 const char *s;
312 for (s = type->str; *s; s++)
313 if (*s == '|') last_name = s+1;
314 return last_name;
315 }
316 else
317 return type->name;
318 }
319
320 /*
321 Set the clientdata field for a type
322 */
323 SWIGRUNTIME void
324 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
325 swig_cast_info *cast = ti->cast;
326 /* if (ti->clientdata == clientdata) return; */
327 ti->clientdata = clientdata;
328
329 while (cast) {
330 if (!cast->converter) {
331 swig_type_info *tc = cast->type;
332 if (!tc->clientdata) {
333 SWIG_TypeClientData(tc, clientdata);
334 }
335 }
336 cast = cast->next;
337 }
338 }
339
340 /*
341 Search for a swig_type_info structure only by mangled name
342 Search is a O(log #types)
343
344 We start searching at module start, and finish searching when start == end.
345 Note: if start == end at the beginning of the function, we go all the way around
346 the circular list.
347 */
348 SWIGRUNTIME swig_type_info *
349 SWIG_MangledTypeQueryModule(swig_module_info *start,
350 swig_module_info *end,
351 const char *name) {
352 swig_module_info *iter = start;
353 do {
354 if (iter->size) {
355 register size_t l = 0;
356 register size_t r = iter->size - 1;
357 do {
358 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
359 register size_t i = (l + r) >> 1;
360 const char *iname = iter->types[i]->name;
361 if (iname) {
362 register int compare = strcmp(name, iname);
363 if (compare == 0) {
364 return iter->types[i];
365 } else if (compare < 0) {
366 if (i) {
367 r = i - 1;
368 } else {
369 break;
370 }
371 } else if (compare > 0) {
372 l = i + 1;
373 }
374 } else {
375 break; /* should never happen */
376 }
377 } while (l <= r);
378 }
379 iter = iter->next;
380 } while (iter != end);
381 return 0;
382 }
383
384 /*
385 Search for a swig_type_info structure for either a mangled name or a human readable name.
386 It first searches the mangled names of the types, which is a O(log #types)
387 If a type is not found it then searches the human readable names, which is O(#types).
388
389 We start searching at module start, and finish searching when start == end.
390 Note: if start == end at the beginning of the function, we go all the way around
391 the circular list.
392 */
393 SWIGRUNTIME swig_type_info *
394 SWIG_TypeQueryModule(swig_module_info *start,
395 swig_module_info *end,
396 const char *name) {
397 /* STEP 1: Search the name field using binary search */
398 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
399 if (ret) {
400 return ret;
401 } else {
402 /* STEP 2: If the type hasn't been found, do a complete search
403 of the str field (the human readable name) */
404 swig_module_info *iter = start;
405 do {
406 register size_t i = 0;
407 for (; i < iter->size; ++i) {
408 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
409 return iter->types[i];
410 }
411 iter = iter->next;
412 } while (iter != end);
413 }
414
415 /* neither found a match */
416 return 0;
417 }
418
419
420 /*
421 Pack binary data into a string
422 */
423 SWIGRUNTIME char *
424 SWIG_PackData(char *c, void *ptr, size_t sz) {
425 static const char hex[17] = "0123456789abcdef";
426 register const unsigned char *u = (unsigned char *) ptr;
427 register const unsigned char *eu = u + sz;
428 for (; u != eu; ++u) {
429 register unsigned char uu = *u;
430 *(c++) = hex[(uu & 0xf0) >> 4];
431 *(c++) = hex[uu & 0xf];
432 }
433 return c;
434 }
435
436 /*
437 Unpack binary data from a string
438 */
439 SWIGRUNTIME const char *
440 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
441 register unsigned char *u = (unsigned char *) ptr;
442 register const unsigned char *eu = u + sz;
443 for (; u != eu; ++u) {
444 register char d = *(c++);
445 register unsigned char uu = 0;
446 if ((d >= '0') && (d <= '9'))
447 uu = ((d - '0') << 4);
448 else if ((d >= 'a') && (d <= 'f'))
449 uu = ((d - ('a'-10)) << 4);
450 else
451 return (char *) 0;
452 d = *(c++);
453 if ((d >= '0') && (d <= '9'))
454 uu |= (d - '0');
455 else if ((d >= 'a') && (d <= 'f'))
456 uu |= (d - ('a'-10));
457 else
458 return (char *) 0;
459 *u = uu;
460 }
461 return c;
462 }
463
464 /*
465 Pack 'void *' into a string buffer.
466 */
467 SWIGRUNTIME char *
468 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
469 char *r = buff;
470 if ((2*sizeof(void *) + 2) > bsz) return 0;
471 *(r++) = '_';
472 r = SWIG_PackData(r,&ptr,sizeof(void *));
473 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
474 strcpy(r,name);
475 return buff;
476 }
477
478 SWIGRUNTIME const char *
479 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
480 if (*c != '_') {
481 if (strcmp(c,"NULL") == 0) {
482 *ptr = (void *) 0;
483 return name;
484 } else {
485 return 0;
486 }
487 }
488 return SWIG_UnpackData(++c,ptr,sizeof(void *));
489 }
490
491 SWIGRUNTIME char *
492 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
493 char *r = buff;
494 size_t lname = (name ? strlen(name) : 0);
495 if ((2*sz + 2 + lname) > bsz) return 0;
496 *(r++) = '_';
497 r = SWIG_PackData(r,ptr,sz);
498 if (lname) {
499 strncpy(r,name,lname+1);
500 } else {
501 *r = 0;
502 }
503 return buff;
504 }
505
506 SWIGRUNTIME const char *
507 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
508 if (*c != '_') {
509 if (strcmp(c,"NULL") == 0) {
510 memset(ptr,0,sz);
511 return name;
512 } else {
513 return 0;
514 }
515 }
516 return SWIG_UnpackData(++c,ptr,sz);
517 }
518
519 #ifdef __cplusplus
520 }
521 #endif
522
523 /* -----------------------------------------------------------------------------
524 * SWIG API. Portion that goes into the runtime
525 * ----------------------------------------------------------------------------- */
526
527 #ifdef __cplusplus
528 extern "C" {
529 #endif
530
531 /* -----------------------------------------------------------------------------
532 * for internal method declarations
533 * ----------------------------------------------------------------------------- */
534
535 #ifndef SWIGINTERN
536 # define SWIGINTERN static SWIGUNUSED
537 #endif
538
539 #ifndef SWIGINTERNINLINE
540 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
541 #endif
542
543 /*
544 Exception handling in wrappers
545 */
546 #define SWIG_fail goto fail
547 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
548 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
549 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
550 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
551 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
552
553 /*
554 Contract support
555 */
556 #define SWIG_contract_assert(expr, msg) \
557 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
558
559 /* -----------------------------------------------------------------------------
560 * Constant declarations
561 * ----------------------------------------------------------------------------- */
562
563 /* Constant Types */
564 #define SWIG_PY_INT 1
565 #define SWIG_PY_FLOAT 2
566 #define SWIG_PY_STRING 3
567 #define SWIG_PY_POINTER 4
568 #define SWIG_PY_BINARY 5
569
570 /* Constant information structure */
571 typedef struct swig_const_info {
572 int type;
573 char *name;
574 long lvalue;
575 double dvalue;
576 void *pvalue;
577 swig_type_info **ptype;
578 } swig_const_info;
579
580
581 /* -----------------------------------------------------------------------------
582 * Alloc. memory flags
583 * ----------------------------------------------------------------------------- */
584 #define SWIG_OLDOBJ 1
585 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
586 #define SWIG_PYSTR SWIG_NEWOBJ + 1
587
588 #ifdef __cplusplus
589 }
590 #endif
591
592
593 /***********************************************************************
594 * pyrun.swg
595 *
596 * This file contains the runtime support for Python modules
597 * and includes code for managing global variables and pointer
598 * type checking.
599 *
600 * Author : David Beazley (beazley@cs.uchicago.edu)
601 ************************************************************************/
602
603 /* Common SWIG API */
604 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
605 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
606 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
607
608
609 /* Python-specific SWIG API */
610 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
611 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
612
613 /* Runtime API */
614 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
615 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
616
617 /* -----------------------------------------------------------------------------
618 * Pointer declarations
619 * ----------------------------------------------------------------------------- */
620 /*
621 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
622 C/C++ pointers in the python side. Very useful for debugging, but
623 not always safe.
624 */
625 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
626 # define SWIG_COBJECT_TYPES
627 #endif
628
629 /* Flags for pointer conversion */
630 #define SWIG_POINTER_EXCEPTION 0x1
631 #define SWIG_POINTER_DISOWN 0x2
632
633
634 /* Add PyOS_snprintf for old Pythons */
635 #if PY_VERSION_HEX < 0x02020000
636 #define PyOS_snprintf snprintf
637 #endif
638
639 #ifdef __cplusplus
640 extern "C" {
641 #endif
642
643 /* -----------------------------------------------------------------------------
644 * Create a new pointer string
645 * ----------------------------------------------------------------------------- */
646 #ifndef SWIG_BUFFER_SIZE
647 #define SWIG_BUFFER_SIZE 1024
648 #endif
649
650 /* A crude PyString_FromFormat implementation for old Pythons */
651 #if PY_VERSION_HEX < 0x02020000
652 static PyObject *
653 PyString_FromFormat(const char *fmt, ...) {
654 va_list ap;
655 char buf[SWIG_BUFFER_SIZE * 2];
656 int res;
657 va_start(ap, fmt);
658 res = vsnprintf(buf, sizeof(buf), fmt, ap);
659 va_end(ap);
660 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
661 }
662 #endif
663
664 #if PY_VERSION_HEX < 0x01060000
665 #define PyObject_Del(op) PyMem_DEL((op))
666 #endif
667
668 #if defined(SWIG_COBJECT_TYPES)
669 #if !defined(SWIG_COBJECT_PYTHON)
670 /* -----------------------------------------------------------------------------
671 * Implements a simple Swig Object type, and use it instead of PyCObject
672 * ----------------------------------------------------------------------------- */
673
674 typedef struct {
675 PyObject_HEAD
676 void *ptr;
677 const char *desc;
678 } PySwigObject;
679
680 /* Declarations for objects of type PySwigObject */
681
682 SWIGRUNTIME int
683 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
684 {
685 char result[SWIG_BUFFER_SIZE];
686 flags = flags;
687 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
688 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
689 return 0;
690 } else {
691 return 1;
692 }
693 }
694
695 SWIGRUNTIME PyObject *
696 PySwigObject_repr(PySwigObject *v)
697 {
698 char result[SWIG_BUFFER_SIZE];
699 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
700 PyString_FromFormat("<Swig Object at %s>", result) : 0;
701 }
702
703 SWIGRUNTIME PyObject *
704 PySwigObject_str(PySwigObject *v)
705 {
706 char result[SWIG_BUFFER_SIZE];
707 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
708 PyString_FromString(result) : 0;
709 }
710
711 SWIGRUNTIME PyObject *
712 PySwigObject_long(PySwigObject *v)
713 {
714 return PyLong_FromVoidPtr(v->ptr);
715 }
716
717 SWIGRUNTIME PyObject *
718 PySwigObject_format(const char* fmt, PySwigObject *v)
719 {
720 PyObject *res = NULL;
721 PyObject *args = PyTuple_New(1);
722 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
723 PyObject *ofmt = PyString_FromString(fmt);
724 if (ofmt) {
725 res = PyString_Format(ofmt,args);
726 Py_DECREF(ofmt);
727 }
728 Py_DECREF(args);
729 }
730 return res;
731 }
732
733 SWIGRUNTIME PyObject *
734 PySwigObject_oct(PySwigObject *v)
735 {
736 return PySwigObject_format("%o",v);
737 }
738
739 SWIGRUNTIME PyObject *
740 PySwigObject_hex(PySwigObject *v)
741 {
742 return PySwigObject_format("%x",v);
743 }
744
745 SWIGRUNTIME int
746 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
747 {
748 int c = strcmp(v->desc, w->desc);
749 if (c) {
750 return (c > 0) ? 1 : -1;
751 } else {
752 void *i = v->ptr;
753 void *j = w->ptr;
754 return (i < j) ? -1 : ((i > j) ? 1 : 0);
755 }
756 }
757
758 SWIGRUNTIME void
759 PySwigObject_dealloc(PySwigObject *self)
760 {
761 PyObject_Del(self);
762 }
763
764 SWIGRUNTIME PyTypeObject*
765 PySwigObject_type(void) {
766 static char pyswigobject_type__doc__[] =
767 "Swig object carries a C/C++ instance pointer";
768
769 static PyNumberMethods PySwigObject_as_number = {
770 (binaryfunc)0, /*nb_add*/
771 (binaryfunc)0, /*nb_subtract*/
772 (binaryfunc)0, /*nb_multiply*/
773 (binaryfunc)0, /*nb_divide*/
774 (binaryfunc)0, /*nb_remainder*/
775 (binaryfunc)0, /*nb_divmod*/
776 (ternaryfunc)0,/*nb_power*/
777 (unaryfunc)0, /*nb_negative*/
778 (unaryfunc)0, /*nb_positive*/
779 (unaryfunc)0, /*nb_absolute*/
780 (inquiry)0, /*nb_nonzero*/
781 0, /*nb_invert*/
782 0, /*nb_lshift*/
783 0, /*nb_rshift*/
784 0, /*nb_and*/
785 0, /*nb_xor*/
786 0, /*nb_or*/
787 (coercion)0, /*nb_coerce*/
788 (unaryfunc)PySwigObject_long, /*nb_int*/
789 (unaryfunc)PySwigObject_long, /*nb_long*/
790 (unaryfunc)0, /*nb_float*/
791 (unaryfunc)PySwigObject_oct, /*nb_oct*/
792 (unaryfunc)PySwigObject_hex, /*nb_hex*/
793 #if PY_VERSION_HEX >= 0x02020000
794 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
795 #elif PY_VERSION_HEX >= 0x02000000
796 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
797 #endif
798 };
799
800 static PyTypeObject pyswigobject_type
801 #if !defined(__cplusplus)
802 ;
803 static int type_init = 0;
804 if (!type_init) {
805 PyTypeObject tmp
806 #endif
807 = {
808 PyObject_HEAD_INIT(&PyType_Type)
809 0, /*ob_size*/
810 (char *)"PySwigObject", /*tp_name*/
811 sizeof(PySwigObject), /*tp_basicsize*/
812 0, /*tp_itemsize*/
813 /* methods */
814 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
815 (printfunc)PySwigObject_print, /*tp_print*/
816 (getattrfunc)0, /*tp_getattr*/
817 (setattrfunc)0, /*tp_setattr*/
818 (cmpfunc)PySwigObject_compare, /*tp_compare*/
819 (reprfunc)PySwigObject_repr, /*tp_repr*/
820 &PySwigObject_as_number, /*tp_as_number*/
821 0, /*tp_as_sequence*/
822 0, /*tp_as_mapping*/
823 (hashfunc)0, /*tp_hash*/
824 (ternaryfunc)0, /*tp_call*/
825 (reprfunc)PySwigObject_str, /*tp_str*/
826 /* Space for future expansion */
827 0,0,0,0,
828 pyswigobject_type__doc__, /* Documentation string */
829 #if PY_VERSION_HEX >= 0x02000000
830 0, /* tp_traverse */
831 0, /* tp_clear */
832 #endif
833 #if PY_VERSION_HEX >= 0x02010000
834 0, /* tp_richcompare */
835 0, /* tp_weaklistoffset */
836 #endif
837 #if PY_VERSION_HEX >= 0x02020000
838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
839 #endif
840 #if PY_VERSION_HEX >= 0x02030000
841 0, /* tp_del */
842 #endif
843 #ifdef COUNT_ALLOCS
844 0,0,0,0 /* tp_alloc -> tp_next */
845 #endif
846 };
847 #if !defined(__cplusplus)
848 pyswigobject_type = tmp;
849 type_init = 1;
850 }
851 #endif
852 return &pyswigobject_type;
853 }
854
855 SWIGRUNTIME PyObject *
856 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
857 {
858 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
859 if (self) {
860 self->ptr = ptr;
861 self->desc = desc;
862 }
863 return (PyObject *)self;
864 }
865
866 SWIGRUNTIMEINLINE void *
867 PySwigObject_AsVoidPtr(PyObject *self)
868 {
869 return ((PySwigObject *)self)->ptr;
870 }
871
872 SWIGRUNTIMEINLINE const char *
873 PySwigObject_GetDesc(PyObject *self)
874 {
875 return ((PySwigObject *)self)->desc;
876 }
877
878 SWIGRUNTIMEINLINE int
879 PySwigObject_Check(PyObject *op) {
880 return ((op)->ob_type == PySwigObject_type())
881 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
882 }
883
884 /* -----------------------------------------------------------------------------
885 * Implements a simple Swig Packed type, and use it instead of string
886 * ----------------------------------------------------------------------------- */
887
888 typedef struct {
889 PyObject_HEAD
890 void *pack;
891 const char *desc;
892 size_t size;
893 } PySwigPacked;
894
895 SWIGRUNTIME int
896 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
897 {
898 char result[SWIG_BUFFER_SIZE];
899 flags = flags;
900 fputs("<Swig Packed ", fp);
901 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
902 fputs("at ", fp);
903 fputs(result, fp);
904 }
905 fputs(v->desc,fp);
906 fputs(">", fp);
907 return 0;
908 }
909
910 SWIGRUNTIME PyObject *
911 PySwigPacked_repr(PySwigPacked *v)
912 {
913 char result[SWIG_BUFFER_SIZE];
914 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
915 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
916 } else {
917 return PyString_FromFormat("<Swig Packed %s>", v->desc);
918 }
919 }
920
921 SWIGRUNTIME PyObject *
922 PySwigPacked_str(PySwigPacked *v)
923 {
924 char result[SWIG_BUFFER_SIZE];
925 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
926 return PyString_FromFormat("%s%s", result, v->desc);
927 } else {
928 return PyString_FromString(v->desc);
929 }
930 }
931
932 SWIGRUNTIME int
933 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
934 {
935 int c = strcmp(v->desc, w->desc);
936 if (c) {
937 return (c > 0) ? 1 : -1;
938 } else {
939 size_t i = v->size;
940 size_t j = w->size;
941 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
942 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
943 }
944 }
945
946 SWIGRUNTIME void
947 PySwigPacked_dealloc(PySwigPacked *self)
948 {
949 free(self->pack);
950 PyObject_Del(self);
951 }
952
953 SWIGRUNTIME PyTypeObject*
954 PySwigPacked_type(void) {
955 static char pyswigpacked_type__doc__[] =
956 "Swig object carries a C/C++ instance pointer";
957 static PyTypeObject pyswigpacked_type
958 #if !defined(__cplusplus)
959 ;
960 static int type_init = 0;
961 if (!type_init) {
962 PyTypeObject tmp
963 #endif
964 = {
965 PyObject_HEAD_INIT(&PyType_Type)
966 0, /*ob_size*/
967 (char *)"PySwigPacked", /*tp_name*/
968 sizeof(PySwigPacked), /*tp_basicsize*/
969 0, /*tp_itemsize*/
970 /* methods */
971 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
972 (printfunc)PySwigPacked_print, /*tp_print*/
973 (getattrfunc)0, /*tp_getattr*/
974 (setattrfunc)0, /*tp_setattr*/
975 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
976 (reprfunc)PySwigPacked_repr, /*tp_repr*/
977 0, /*tp_as_number*/
978 0, /*tp_as_sequence*/
979 0, /*tp_as_mapping*/
980 (hashfunc)0, /*tp_hash*/
981 (ternaryfunc)0, /*tp_call*/
982 (reprfunc)PySwigPacked_str, /*tp_str*/
983 /* Space for future expansion */
984 0,0,0,0,
985 pyswigpacked_type__doc__, /* Documentation string */
986 #if PY_VERSION_HEX >= 0x02000000
987 0, /* tp_traverse */
988 0, /* tp_clear */
989 #endif
990 #if PY_VERSION_HEX >= 0x02010000
991 0, /* tp_richcompare */
992 0, /* tp_weaklistoffset */
993 #endif
994 #if PY_VERSION_HEX >= 0x02020000
995 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
996 #endif
997 #if PY_VERSION_HEX >= 0x02030000
998 0, /* tp_del */
999 #endif
1000 #ifdef COUNT_ALLOCS
1001 0,0,0,0 /* tp_alloc -> tp_next */
1002 #endif
1003 };
1004 #if !defined(__cplusplus)
1005 pyswigpacked_type = tmp;
1006 type_init = 1;
1007 }
1008 #endif
1009 return &pyswigpacked_type;
1010 }
1011
1012 SWIGRUNTIME PyObject *
1013 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1014 {
1015 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1016 if (self == NULL) {
1017 return NULL;
1018 } else {
1019 void *pack = malloc(size);
1020 if (pack) {
1021 memcpy(pack, ptr, size);
1022 self->pack = pack;
1023 self->desc = desc;
1024 self->size = size;
1025 return (PyObject *) self;
1026 }
1027 return NULL;
1028 }
1029 }
1030
1031 SWIGRUNTIMEINLINE const char *
1032 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1033 {
1034 PySwigPacked *self = (PySwigPacked *)obj;
1035 if (self->size != size) return 0;
1036 memcpy(ptr, self->pack, size);
1037 return self->desc;
1038 }
1039
1040 SWIGRUNTIMEINLINE const char *
1041 PySwigPacked_GetDesc(PyObject *self)
1042 {
1043 return ((PySwigPacked *)self)->desc;
1044 }
1045
1046 SWIGRUNTIMEINLINE int
1047 PySwigPacked_Check(PyObject *op) {
1048 return ((op)->ob_type == PySwigPacked_type())
1049 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1050 }
1051
1052 #else
1053 /* -----------------------------------------------------------------------------
1054 * Use the old Python PyCObject instead of PySwigObject
1055 * ----------------------------------------------------------------------------- */
1056
1057 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1058 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1059 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1060 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1061
1062 #endif
1063
1064 #endif
1065
1066 /* -----------------------------------------------------------------------------
1067 * errors manipulation
1068 * ----------------------------------------------------------------------------- */
1069
1070 SWIGRUNTIME void
1071 SWIG_Python_TypeError(const char *type, PyObject *obj)
1072 {
1073 if (type) {
1074 #if defined(SWIG_COBJECT_TYPES)
1075 if (obj && PySwigObject_Check(obj)) {
1076 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1077 if (otype) {
1078 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1079 type, otype);
1080 return;
1081 }
1082 } else
1083 #endif
1084 {
1085 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1086 if (otype) {
1087 PyObject *str = PyObject_Str(obj);
1088 const char *cstr = str ? PyString_AsString(str) : 0;
1089 if (cstr) {
1090 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1091 type, otype, cstr);
1092 } else {
1093 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1094 type, otype);
1095 }
1096 Py_XDECREF(str);
1097 return;
1098 }
1099 }
1100 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1101 } else {
1102 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1103 }
1104 }
1105
1106 SWIGRUNTIMEINLINE void
1107 SWIG_Python_NullRef(const char *type)
1108 {
1109 if (type) {
1110 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1111 } else {
1112 PyErr_Format(PyExc_TypeError, "null reference was received");
1113 }
1114 }
1115
1116 SWIGRUNTIME int
1117 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1118 {
1119 if (PyErr_Occurred()) {
1120 PyObject *type = 0;
1121 PyObject *value = 0;
1122 PyObject *traceback = 0;
1123 PyErr_Fetch(&type, &value, &traceback);
1124 if (value) {
1125 PyObject *old_str = PyObject_Str(value);
1126 Py_XINCREF(type);
1127 PyErr_Clear();
1128 if (infront) {
1129 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1130 } else {
1131 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1132 }
1133 Py_DECREF(old_str);
1134 }
1135 return 1;
1136 } else {
1137 return 0;
1138 }
1139 }
1140
1141 SWIGRUNTIME int
1142 SWIG_Python_ArgFail(int argnum)
1143 {
1144 if (PyErr_Occurred()) {
1145 /* add information about failing argument */
1146 char mesg[256];
1147 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1148 return SWIG_Python_AddErrMesg(mesg, 1);
1149 } else {
1150 return 0;
1151 }
1152 }
1153
1154
1155 /* -----------------------------------------------------------------------------
1156 * pointers/data manipulation
1157 * ----------------------------------------------------------------------------- */
1158
1159 /* Convert a pointer value */
1160 SWIGRUNTIME int
1161 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1162 swig_cast_info *tc;
1163 const char *c = 0;
1164 static PyObject *SWIG_this = 0;
1165 int newref = 0;
1166 PyObject *pyobj = 0;
1167 void *vptr;
1168
1169 if (!obj) return 0;
1170 if (obj == Py_None) {
1171 *ptr = 0;
1172 return 0;
1173 }
1174
1175 #ifdef SWIG_COBJECT_TYPES
1176 if (!(PySwigObject_Check(obj))) {
1177 if (!SWIG_this)
1178 SWIG_this = PyString_FromString("this");
1179 pyobj = obj;
1180 obj = PyObject_GetAttr(obj,SWIG_this);
1181 newref = 1;
1182 if (!obj) goto type_error;
1183 if (!PySwigObject_Check(obj)) {
1184 Py_DECREF(obj);
1185 goto type_error;
1186 }
1187 }
1188 vptr = PySwigObject_AsVoidPtr(obj);
1189 c = (const char *) PySwigObject_GetDesc(obj);
1190 if (newref) { Py_DECREF(obj); }
1191 goto type_check;
1192 #else
1193 if (!(PyString_Check(obj))) {
1194 if (!SWIG_this)
1195 SWIG_this = PyString_FromString("this");
1196 pyobj = obj;
1197 obj = PyObject_GetAttr(obj,SWIG_this);
1198 newref = 1;
1199 if (!obj) goto type_error;
1200 if (!PyString_Check(obj)) {
1201 Py_DECREF(obj);
1202 goto type_error;
1203 }
1204 }
1205 c = PyString_AsString(obj);
1206 /* Pointer values must start with leading underscore */
1207 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1208 if (newref) { Py_DECREF(obj); }
1209 if (!c) goto type_error;
1210 #endif
1211
1212 type_check:
1213 if (ty) {
1214 tc = SWIG_TypeCheck(c,ty);
1215 if (!tc) goto type_error;
1216 *ptr = SWIG_TypeCast(tc,vptr);
1217 } else {
1218 *ptr = vptr;
1219 }
1220 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1221 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1222 }
1223 return 0;
1224
1225 type_error:
1226 PyErr_Clear();
1227 if (pyobj && !obj) {
1228 obj = pyobj;
1229 if (PyCFunction_Check(obj)) {
1230 /* here we get the method pointer for callbacks */
1231 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1232 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1233 if (c) {
1234 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1235 if (!c) goto type_error;
1236 goto type_check;
1237 }
1238 }
1239 }
1240 if (flags & SWIG_POINTER_EXCEPTION) {
1241 if (ty) {
1242 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1243 } else {
1244 SWIG_Python_TypeError("C/C++ pointer", obj);
1245 }
1246 }
1247 return -1;
1248 }
1249
1250 /* Convert a pointer value, signal an exception on a type mismatch */
1251 SWIGRUNTIME void *
1252 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1253 void *result;
1254 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1255 PyErr_Clear();
1256 if (flags & SWIG_POINTER_EXCEPTION) {
1257 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1258 SWIG_Python_ArgFail(argnum);
1259 }
1260 }
1261 return result;
1262 }
1263
1264 /* Convert a packed value value */
1265 SWIGRUNTIME int
1266 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1267 swig_cast_info *tc;
1268 const char *c = 0;
1269
1270 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1271 c = PySwigPacked_UnpackData(obj, ptr, sz);
1272 #else
1273 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1274 c = PyString_AsString(obj);
1275 /* Pointer values must start with leading underscore */
1276 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1277 #endif
1278 if (!c) goto type_error;
1279 if (ty) {
1280 tc = SWIG_TypeCheck(c,ty);
1281 if (!tc) goto type_error;
1282 }
1283 return 0;
1284
1285 type_error:
1286 PyErr_Clear();
1287 if (flags & SWIG_POINTER_EXCEPTION) {
1288 if (ty) {
1289 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1290 } else {
1291 SWIG_Python_TypeError("C/C++ packed data", obj);
1292 }
1293 }
1294 return -1;
1295 }
1296
1297 /* Create a new array object */
1298 SWIGRUNTIME PyObject *
1299 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1300 PyObject *robj = 0;
1301 if (!type) {
1302 if (!PyErr_Occurred()) {
1303 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1304 }
1305 return robj;
1306 }
1307 if (!ptr) {
1308 Py_INCREF(Py_None);
1309 return Py_None;
1310 }
1311 #ifdef SWIG_COBJECT_TYPES
1312 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1313 #else
1314 {
1315 char result[SWIG_BUFFER_SIZE];
1316 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1317 PyString_FromString(result) : 0;
1318 }
1319 #endif
1320 if (!robj || (robj == Py_None)) return robj;
1321 if (type->clientdata) {
1322 PyObject *inst;
1323 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1324 Py_DECREF(robj);
1325 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1326 Py_DECREF(args);
1327 if (inst) {
1328 if (own) {
1329 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1330 }
1331 robj = inst;
1332 }
1333 }
1334 return robj;
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1339 PyObject *robj = 0;
1340 if (!ptr) {
1341 Py_INCREF(Py_None);
1342 return Py_None;
1343 }
1344 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1345 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1346 #else
1347 {
1348 char result[SWIG_BUFFER_SIZE];
1349 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1350 PyString_FromString(result) : 0;
1351 }
1352 #endif
1353 return robj;
1354 }
1355
1356 /* -----------------------------------------------------------------------------*
1357 * Get type list
1358 * -----------------------------------------------------------------------------*/
1359
1360 #ifdef SWIG_LINK_RUNTIME
1361 void *SWIG_ReturnGlobalTypeList(void *);
1362 #endif
1363
1364 SWIGRUNTIME swig_module_info *
1365 SWIG_Python_GetModule(void) {
1366 static void *type_pointer = (void *)0;
1367 /* first check if module already created */
1368 if (!type_pointer) {
1369 #ifdef SWIG_LINK_RUNTIME
1370 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1371 #else
1372 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1373 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1374 if (PyErr_Occurred()) {
1375 PyErr_Clear();
1376 type_pointer = (void *)0;
1377 }
1378 #endif
1379 }
1380 return (swig_module_info *) type_pointer;
1381 }
1382
1383 #if PY_MAJOR_VERSION < 2
1384 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1385 is copied out of Python/modsupport.c in python version 2.3.4 */
1386 SWIGINTERN int
1387 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1388 {
1389 PyObject *dict;
1390 if (!PyModule_Check(m)) {
1391 PyErr_SetString(PyExc_TypeError,
1392 "PyModule_AddObject() needs module as first arg");
1393 return -1;
1394 }
1395 if (!o) {
1396 PyErr_SetString(PyExc_TypeError,
1397 "PyModule_AddObject() needs non-NULL value");
1398 return -1;
1399 }
1400
1401 dict = PyModule_GetDict(m);
1402 if (dict == NULL) {
1403 /* Internal error -- modules must have a dict! */
1404 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1405 PyModule_GetName(m));
1406 return -1;
1407 }
1408 if (PyDict_SetItemString(dict, name, o))
1409 return -1;
1410 Py_DECREF(o);
1411 return 0;
1412 }
1413 #endif
1414
1415 SWIGRUNTIME void
1416 SWIG_Python_SetModule(swig_module_info *swig_module) {
1417 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1418
1419 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1420 swig_empty_runtime_method_table);
1421 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1422 if (pointer && module) {
1423 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1424 }
1425 }
1426
1427 #ifdef __cplusplus
1428 }
1429 #endif
1430
1431
1432 /* -------- TYPES TABLE (BEGIN) -------- */
1433
1434 #define SWIGTYPE_p_buffer swig_types[0]
1435 #define SWIGTYPE_p_char swig_types[1]
1436 #define SWIGTYPE_p_form_ops_t swig_types[2]
1437 #define SWIGTYPE_p_int swig_types[3]
1438 #define SWIGTYPE_p_long swig_types[4]
1439 #define SWIGTYPE_p_unsigned_char swig_types[5]
1440 #define SWIGTYPE_p_unsigned_int swig_types[6]
1441 #define SWIGTYPE_p_unsigned_long swig_types[7]
1442 #define SWIGTYPE_p_wxANIHandler swig_types[8]
1443 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
1444 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
1445 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
1446 #define SWIGTYPE_p_wxAppTraits swig_types[12]
1447 #define SWIGTYPE_p_wxArrayString swig_types[13]
1448 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
1449 #define SWIGTYPE_p_wxBitmap swig_types[15]
1450 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
1451 #define SWIGTYPE_p_wxButton swig_types[17]
1452 #define SWIGTYPE_p_wxCURHandler swig_types[18]
1453 #define SWIGTYPE_p_wxCaret swig_types[19]
1454 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
1456 #define SWIGTYPE_p_wxColour swig_types[22]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
1458 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
1459 #define SWIGTYPE_p_wxControl swig_types[25]
1460 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
1461 #define SWIGTYPE_p_wxCursor swig_types[27]
1462 #define SWIGTYPE_p_wxDC swig_types[28]
1463 #define SWIGTYPE_p_wxDateEvent swig_types[29]
1464 #define SWIGTYPE_p_wxDateTime swig_types[30]
1465 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
1466 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
1467 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
1468 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
1469 #define SWIGTYPE_p_wxEvent swig_types[35]
1470 #define SWIGTYPE_p_wxEventLoop swig_types[36]
1471 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
1472 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
1473 #define SWIGTYPE_p_wxFSFile swig_types[39]
1474 #define SWIGTYPE_p_wxFileSystem swig_types[40]
1475 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
1476 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
1477 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
1478 #define SWIGTYPE_p_wxFont swig_types[44]
1479 #define SWIGTYPE_p_wxFrame swig_types[45]
1480 #define SWIGTYPE_p_wxGBPosition swig_types[46]
1481 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
1482 #define SWIGTYPE_p_wxGBSpan swig_types[48]
1483 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
1484 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
1485 #define SWIGTYPE_p_wxGridSizer swig_types[51]
1486 #define SWIGTYPE_p_wxICOHandler swig_types[52]
1487 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
1488 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
1489 #define SWIGTYPE_p_wxImage swig_types[55]
1490 #define SWIGTYPE_p_wxImageHandler swig_types[56]
1491 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
1492 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
1493 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
1494 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
1495 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
1496 #define SWIGTYPE_p_wxInputStream swig_types[62]
1497 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
1498 #define SWIGTYPE_p_wxItemContainer swig_types[64]
1499 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1500 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
1501 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
1502 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
1503 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1504 #define SWIGTYPE_p_wxMenu swig_types[70]
1505 #define SWIGTYPE_p_wxMenuBar swig_types[71]
1506 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
1507 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
1508 #define SWIGTYPE_p_wxMenuItem swig_types[74]
1509 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
1510 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
1511 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
1512 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
1513 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
1514 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
1515 #define SWIGTYPE_p_wxObject swig_types[81]
1516 #define SWIGTYPE_p_wxOutputStream swig_types[82]
1517 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
1518 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
1519 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
1520 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
1521 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
1522 #define SWIGTYPE_p_wxPaperSize swig_types[88]
1523 #define SWIGTYPE_p_wxPoint swig_types[89]
1524 #define SWIGTYPE_p_wxPoint2D swig_types[90]
1525 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
1526 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
1527 #define SWIGTYPE_p_wxPyApp swig_types[93]
1528 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
1529 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
1530 #define SWIGTYPE_p_wxPyEvent swig_types[96]
1531 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
1532 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
1533 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
1534 #define SWIGTYPE_p_wxPySizer swig_types[100]
1535 #define SWIGTYPE_p_wxPyValidator swig_types[101]
1536 #define SWIGTYPE_p_wxQuantize swig_types[102]
1537 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
1538 #define SWIGTYPE_p_wxRealPoint swig_types[104]
1539 #define SWIGTYPE_p_wxRect swig_types[105]
1540 #define SWIGTYPE_p_wxRegion swig_types[106]
1541 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
1542 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
1543 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
1544 #define SWIGTYPE_p_wxShowEvent swig_types[110]
1545 #define SWIGTYPE_p_wxSize swig_types[111]
1546 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
1547 #define SWIGTYPE_p_wxSizer swig_types[113]
1548 #define SWIGTYPE_p_wxSizerItem swig_types[114]
1549 #define SWIGTYPE_p_wxStaticBox swig_types[115]
1550 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
1551 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
1552 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
1553 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
1554 #define SWIGTYPE_p_wxToolTip swig_types[120]
1555 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
1556 #define SWIGTYPE_p_wxValidator swig_types[122]
1557 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
1558 #define SWIGTYPE_p_wxWindow swig_types[124]
1559 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
1560 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
1561 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
1562 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
1563 #define SWIGTYPE_ptrdiff_t swig_types[129]
1564 #define SWIGTYPE_std__ptrdiff_t swig_types[130]
1565 #define SWIGTYPE_unsigned_int swig_types[131]
1566 static swig_type_info *swig_types[133];
1567 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
1568 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1569 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1570
1571 /* -------- TYPES TABLE (END) -------- */
1572
1573
1574 /*-----------------------------------------------
1575 @(target):= _core_.so
1576 ------------------------------------------------*/
1577 #define SWIG_init init_core_
1578
1579 #define SWIG_name "_core_"
1580
1581 #include "wx/wxPython/wxPython_int.h"
1582 #include "wx/wxPython/pyclasses.h"
1583
1584
1585 #ifndef wxPyUSE_EXPORT
1586 // Helper functions for dealing with SWIG objects and such. These are
1587 // located here so they know about the SWIG types and functions declared
1588 // in the wrapper code.
1589
1590 #include <wx/hashmap.h>
1591 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1592
1593
1594 // Maintains a hashmap of className to swig_type_info pointers. Given the
1595 // name of a class either looks up the type info in the cache, or scans the
1596 // SWIG tables for it.
1597 extern PyObject* wxPyPtrTypeMap;
1598 static
1599 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1600
1601 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1602
1603 if (typeInfoCache == NULL)
1604 typeInfoCache = new wxPyTypeInfoHashMap;
1605
1606 wxString name(className);
1607 swig_type_info* swigType = (*typeInfoCache)[name];
1608
1609 if (! swigType) {
1610 // it wasn't in the cache, so look it up from SWIG
1611 name.Append(wxT(" *"));
1612 swigType = SWIG_TypeQuery(name.mb_str());
1613
1614 // if it still wasn't found, try looking for a mapped name
1615 if (!swigType) {
1616 PyObject* item;
1617 name = className;
1618
1619 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1620 (char*)(const char*)name.mbc_str())) != NULL) {
1621 name = wxString(PyString_AsString(item), *wxConvCurrent);
1622 name.Append(wxT(" *"));
1623 swigType = SWIG_TypeQuery(name.mb_str());
1624 }
1625 }
1626 if (swigType) {
1627 // and add it to the map if found
1628 (*typeInfoCache)[className] = swigType;
1629 }
1630 }
1631 return swigType;
1632 }
1633
1634
1635 // Check if a class name is a type known to SWIG
1636 bool wxPyCheckSwigType(const wxChar* className) {
1637
1638 swig_type_info* swigType = wxPyFindSwigType(className);
1639 return swigType != NULL;
1640 }
1641
1642
1643 // Given a pointer to a C++ object and a class name, construct a Python proxy
1644 // object for it.
1645 PyObject* wxPyConstructObject(void* ptr,
1646 const wxChar* className,
1647 int setThisOwn) {
1648
1649 swig_type_info* swigType = wxPyFindSwigType(className);
1650 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1651
1652 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1653 }
1654
1655
1656 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1657 // Ensures that the proxy object is of the specified (or derived) type. If
1658 // not able to perform the conversion then a Python exception is set and the
1659 // error should be handled properly in the caller. Returns True on success.
1660 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1661 const wxChar* className) {
1662
1663 swig_type_info* swigType = wxPyFindSwigType(className);
1664 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1665
1666 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1667 }
1668
1669
1670
1671 // Make a SWIGified pointer object suitable for a .this attribute
1672 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1673
1674 PyObject* robj = NULL;
1675
1676 swig_type_info* swigType = wxPyFindSwigType(className);
1677 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
1678
1679 #ifdef SWIG_COBJECT_TYPES
1680 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1681 #else
1682 {
1683 char result[1024];
1684 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1685 PyString_FromString(result) : 0;
1686 }
1687 #endif
1688 return robj;
1689 }
1690
1691
1692 // Python's PyInstance_Check does not return True for instances of new-style
1693 // classes. This should get close enough for both new and old classes but I
1694 // should re-evaluate the need for doing instance checks...
1695 bool wxPyInstance_Check(PyObject* obj) {
1696 return PyObject_HasAttrString(obj, "__class__") != 0;
1697 }
1698
1699
1700 // This one checks if the object is an instance of a SWIG proxy class (it has
1701 // a .this attribute, and the .this attribute is a PySwigObject.)
1702 bool wxPySwigInstance_Check(PyObject* obj) {
1703 static PyObject* this_str = NULL;
1704 if (this_str == NULL)
1705 this_str = PyString_FromString("this");
1706
1707 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1708 if (this_attr) {
1709 bool retval = (PySwigObject_Check(this_attr) != 0);
1710 Py_DECREF(this_attr);
1711 return retval;
1712 }
1713
1714 PyErr_Clear();
1715 return false;
1716 }
1717
1718
1719 // Export a C API in a struct. Other modules will be able to load this from
1720 // the wx._core_ module and will then have safe access to these functions,
1721 // even if they are located in another shared library.
1722 static wxPyCoreAPI API = {
1723
1724 wxPyCheckSwigType,
1725 wxPyConstructObject,
1726 wxPyConvertSwigPtr,
1727 wxPyMakeSwigPtr,
1728
1729 wxPyBeginAllowThreads,
1730 wxPyEndAllowThreads,
1731 wxPyBeginBlockThreads,
1732 wxPyEndBlockThreads,
1733
1734 wxPy_ConvertList,
1735
1736 wxString_in_helper,
1737 Py2wxString,
1738 wx2PyString,
1739
1740 byte_LIST_helper,
1741 int_LIST_helper,
1742 long_LIST_helper,
1743 string_LIST_helper,
1744 wxPoint_LIST_helper,
1745 wxBitmap_LIST_helper,
1746 wxString_LIST_helper,
1747 wxAcceleratorEntry_LIST_helper,
1748
1749 wxSize_helper,
1750 wxPoint_helper,
1751 wxRealPoint_helper,
1752 wxRect_helper,
1753 wxColour_helper,
1754 wxPoint2D_helper,
1755
1756 wxPySimple_typecheck,
1757 wxColour_typecheck,
1758
1759 wxPyCBH_setCallbackInfo,
1760 wxPyCBH_findCallback,
1761 wxPyCBH_callCallback,
1762 wxPyCBH_callCallbackObj,
1763 wxPyCBH_delete,
1764
1765 wxPyMake_wxObject,
1766 wxPyMake_wxSizer,
1767 wxPyPtrTypeMap_Add,
1768 wxPy2int_seq_helper,
1769 wxPy4int_seq_helper,
1770 wxArrayString2PyList_helper,
1771 wxArrayInt2PyList_helper,
1772
1773 wxPyClientData_dtor,
1774 wxPyUserData_dtor,
1775 wxPyOORClientData_dtor,
1776
1777 wxPyCBInputStream_create,
1778 wxPyCBInputStream_copy,
1779
1780 wxPyInstance_Check,
1781 wxPySwigInstance_Check,
1782
1783 wxPyCheckForApp
1784
1785 };
1786
1787 #endif
1788
1789
1790 #if !WXWIN_COMPATIBILITY_2_4
1791 #define wxHIDE_READONLY 0
1792 #endif
1793
1794
1795 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1796 #define SWIG_From_int PyInt_FromLong
1797 /*@@*/
1798
1799 static const wxString wxPyEmptyString(wxEmptyString);
1800 static wxString wxObject_GetClassName(wxObject *self){
1801 return self->GetClassInfo()->GetClassName();
1802 }
1803 static void wxObject_Destroy(wxObject *self){
1804 delete self;
1805 }
1806
1807 #ifndef __WXMAC__
1808 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1809 #endif
1810
1811
1812 #include <limits.h>
1813
1814
1815 SWIGINTERN int
1816 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1817 const char *errmsg)
1818 {
1819 if (value < min_value) {
1820 if (errmsg) {
1821 PyErr_Format(PyExc_OverflowError,
1822 "value %ld is less than '%s' minimum %ld",
1823 value, errmsg, min_value);
1824 }
1825 return 0;
1826 } else if (value > max_value) {
1827 if (errmsg) {
1828 PyErr_Format(PyExc_OverflowError,
1829 "value %ld is greater than '%s' maximum %ld",
1830 value, errmsg, max_value);
1831 }
1832 return 0;
1833 }
1834 return 1;
1835 }
1836
1837
1838 SWIGINTERN int
1839 SWIG_AsVal_long(PyObject* obj, long* val)
1840 {
1841 if (PyNumber_Check(obj)) {
1842 if (val) *val = PyInt_AsLong(obj);
1843 return 1;
1844 }
1845 else {
1846 SWIG_Python_TypeError("number", obj);
1847 }
1848 return 0;
1849 }
1850
1851
1852 #if INT_MAX != LONG_MAX
1853 SWIGINTERN int
1854 SWIG_AsVal_int(PyObject *obj, int *val)
1855 {
1856 const char* errmsg = val ? "int" : (char*)0;
1857 long v;
1858 if (SWIG_AsVal_long(obj, &v)) {
1859 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1860 if (val) *val = static_cast<int >(v);
1861 return 1;
1862 } else {
1863 return 0;
1864 }
1865 } else {
1866 PyErr_Clear();
1867 }
1868 if (val) {
1869 SWIG_type_error(errmsg, obj);
1870 }
1871 return 0;
1872 }
1873 #else
1874 SWIGINTERNINLINE int
1875 SWIG_AsVal_int(PyObject *obj, int *val)
1876 {
1877 return SWIG_AsVal_long(obj,(long*)val);
1878 }
1879 #endif
1880
1881
1882 SWIGINTERNINLINE int
1883 SWIG_As_int(PyObject* obj)
1884 {
1885 int v;
1886 if (!SWIG_AsVal_int(obj, &v)) {
1887 /*
1888 this is needed to make valgrind/purify happier.
1889 */
1890 memset((void*)&v, 0, sizeof(int));
1891 }
1892 return v;
1893 }
1894
1895
1896 SWIGINTERNINLINE int
1897 SWIG_Check_int(PyObject* obj)
1898 {
1899 return SWIG_AsVal_int(obj, (int*)0);
1900 }
1901
1902 static PyObject *wxSize_Get(wxSize *self){
1903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1904 PyObject* tup = PyTuple_New(2);
1905 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1906 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1907 wxPyEndBlockThreads(blocked);
1908 return tup;
1909 }
1910
1911 SWIGINTERN int
1912 SWIG_AsVal_double(PyObject *obj, double* val)
1913 {
1914 if (PyNumber_Check(obj)) {
1915 if (val) *val = PyFloat_AsDouble(obj);
1916 return 1;
1917 }
1918 else {
1919 SWIG_Python_TypeError("number", obj);
1920 }
1921 return 0;
1922 }
1923
1924
1925 SWIGINTERNINLINE double
1926 SWIG_As_double(PyObject* obj)
1927 {
1928 double v;
1929 if (!SWIG_AsVal_double(obj, &v)) {
1930 /*
1931 this is needed to make valgrind/purify happier.
1932 */
1933 memset((void*)&v, 0, sizeof(double));
1934 }
1935 return v;
1936 }
1937
1938
1939 SWIGINTERNINLINE int
1940 SWIG_Check_double(PyObject* obj)
1941 {
1942 return SWIG_AsVal_double(obj, (double*)0);
1943 }
1944
1945
1946 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1947 #define SWIG_From_double PyFloat_FromDouble
1948 /*@@*/
1949
1950 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1951 self->x = x;
1952 self->y = y;
1953 }
1954 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1955 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1956 PyObject* tup = PyTuple_New(2);
1957 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1958 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1959 wxPyEndBlockThreads(blocked);
1960 return tup;
1961 }
1962
1963 SWIGINTERNINLINE long
1964 SWIG_As_long(PyObject* obj)
1965 {
1966 long v;
1967 if (!SWIG_AsVal_long(obj, &v)) {
1968 /*
1969 this is needed to make valgrind/purify happier.
1970 */
1971 memset((void*)&v, 0, sizeof(long));
1972 }
1973 return v;
1974 }
1975
1976
1977 SWIGINTERNINLINE int
1978 SWIG_Check_long(PyObject* obj)
1979 {
1980 return SWIG_AsVal_long(obj, (long*)0);
1981 }
1982
1983 static void wxPoint_Set(wxPoint *self,long x,long y){
1984 self->x = x;
1985 self->y = y;
1986 }
1987 static PyObject *wxPoint_Get(wxPoint *self){
1988 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1989 PyObject* tup = PyTuple_New(2);
1990 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1991 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1992 wxPyEndBlockThreads(blocked);
1993 return tup;
1994 }
1995 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1996 self->x = x;
1997 self->y = y;
1998 self->width = width;
1999 self->height = height;
2000 }
2001 static PyObject *wxRect_Get(wxRect *self){
2002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2003 PyObject* tup = PyTuple_New(4);
2004 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2005 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2006 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2007 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2008 wxPyEndBlockThreads(blocked);
2009 return tup;
2010 }
2011
2012 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2013 wxRegion reg1(*r1);
2014 wxRegion reg2(*r2);
2015 wxRect dest(0,0,0,0);
2016 PyObject* obj;
2017
2018 reg1.Intersect(reg2);
2019 dest = reg1.GetBox();
2020
2021 if (dest != wxRect(0,0,0,0)) {
2022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2023 wxRect* newRect = new wxRect(dest);
2024 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2025 wxPyEndBlockThreads(blocked);
2026 return obj;
2027 }
2028 Py_INCREF(Py_None);
2029 return Py_None;
2030 }
2031
2032
2033 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
2034 {
2035 PyObject* o2;
2036 PyObject* o3;
2037 if (!result) {
2038 result = obj;
2039 } else if (result == Py_None) {
2040 Py_DECREF(result);
2041 result = obj;
2042 } else {
2043 if (!PyTuple_Check(result)) {
2044 o2 = result;
2045 result = PyTuple_New(1);
2046 PyTuple_SET_ITEM(result, 0, o2);
2047 }
2048 o3 = PyTuple_New(1);
2049 PyTuple_SetItem(o3, 0, obj);
2050 o2 = result;
2051 result = PySequence_Concat(o2, o3);
2052 Py_DECREF(o2);
2053 Py_DECREF(o3);
2054 }
2055 return result;
2056 }
2057
2058
2059 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2060 self->m_x = x;
2061 self->m_y = y;
2062 }
2063 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2065 PyObject* tup = PyTuple_New(2);
2066 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2067 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2068 wxPyEndBlockThreads(blocked);
2069 return tup;
2070 }
2071
2072 #include "wx/wxPython/pyistream.h"
2073
2074 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2075 wxInputStream* wxis = wxPyCBInputStream::create(p);
2076 if (wxis)
2077 return new wxPyInputStream(wxis);
2078 else
2079 return NULL;
2080 }
2081
2082 SWIGINTERNINLINE PyObject*
2083 SWIG_From_char(char c)
2084 {
2085 return PyString_FromStringAndSize(&c,1);
2086 }
2087
2088
2089 SWIGINTERNINLINE PyObject*
2090 SWIG_From_unsigned_SS_long(unsigned long value)
2091 {
2092 return (value > LONG_MAX) ?
2093 PyLong_FromUnsignedLong(value)
2094 : PyInt_FromLong(static_cast<long >(value));
2095 }
2096
2097
2098 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2099 SWIGINTERN int
2100 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2101 {
2102 static swig_type_info* pchar_info = 0;
2103 char* vptr = 0;
2104 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2105 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2106 if (cptr) *cptr = vptr;
2107 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2108 return SWIG_OLDOBJ;
2109 } else {
2110 PyErr_Clear();
2111 if (PyString_Check(obj)) {
2112 if (cptr) {
2113 *cptr = PyString_AS_STRING(obj);
2114 if (psize) {
2115 *psize = PyString_GET_SIZE(obj) + 1;
2116 }
2117 }
2118 return SWIG_PYSTR;
2119 }
2120 }
2121 if (cptr) {
2122 SWIG_type_error("char *", obj);
2123 }
2124 return 0;
2125 }
2126
2127
2128 SWIGINTERN int
2129 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2130 {
2131 char* cptr; size_t csize;
2132 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2133 /* in C you can do:
2134
2135 char x[5] = "hello";
2136
2137 ie, assing the array using an extra '0' char.
2138 */
2139 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2140 if (csize <= size) {
2141 if (val) {
2142 if (csize) memcpy(val, cptr, csize);
2143 if (csize < size) memset(val + csize, 0, size - csize);
2144 }
2145 return 1;
2146 }
2147 }
2148 if (val) {
2149 PyErr_Format(PyExc_TypeError,
2150 "a char array of maximum size %lu is expected",
2151 (unsigned long) size);
2152 }
2153 return 0;
2154 }
2155
2156
2157 SWIGINTERN int
2158 SWIG_AsVal_char(PyObject *obj, char *val)
2159 {
2160 const char* errmsg = val ? "char" : (char*)0;
2161 long v;
2162 if (SWIG_AsVal_long(obj, &v)) {
2163 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2164 if (val) *val = static_cast<char >(v);
2165 return 1;
2166 } else {
2167 return 0;
2168 }
2169 } else {
2170 PyErr_Clear();
2171 return SWIG_AsCharArray(obj, val, 1);
2172 }
2173 }
2174
2175
2176 SWIGINTERNINLINE char
2177 SWIG_As_char(PyObject* obj)
2178 {
2179 char v;
2180 if (!SWIG_AsVal_char(obj, &v)) {
2181 /*
2182 this is needed to make valgrind/purify happier.
2183 */
2184 memset((void*)&v, 0, sizeof(char));
2185 }
2186 return v;
2187 }
2188
2189
2190 SWIGINTERNINLINE int
2191 SWIG_Check_char(PyObject* obj)
2192 {
2193 return SWIG_AsVal_char(obj, (char*)0);
2194 }
2195
2196
2197 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2198 #define SWIG_From_long PyInt_FromLong
2199 /*@@*/
2200
2201 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2202 // We use only strings for the streams, not unicode
2203 PyObject* str = PyObject_Str(obj);
2204 if (! str) {
2205 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2206 return;
2207 }
2208 self->Write(PyString_AS_STRING(str),
2209 PyString_GET_SIZE(str));
2210 Py_DECREF(str);
2211 }
2212
2213 #include "wx/wxPython/pyistream.h"
2214
2215
2216 class wxPyFileSystemHandler : public wxFileSystemHandler
2217 {
2218 public:
2219 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2220
2221 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2222 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2223 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2224 DEC_PYCALLBACK_STRING__pure(FindNext);
2225
2226 wxString GetProtocol(const wxString& location) {
2227 return wxFileSystemHandler::GetProtocol(location);
2228 }
2229
2230 wxString GetLeftLocation(const wxString& location) {
2231 return wxFileSystemHandler::GetLeftLocation(location);
2232 }
2233
2234 wxString GetAnchor(const wxString& location) {
2235 return wxFileSystemHandler::GetAnchor(location);
2236 }
2237
2238 wxString GetRightLocation(const wxString& location) {
2239 return wxFileSystemHandler::GetRightLocation(location);
2240 }
2241
2242 wxString GetMimeTypeFromExt(const wxString& location) {
2243 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2244 }
2245
2246 PYPRIVATE;
2247 };
2248
2249
2250 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2251 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2252 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2253 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_bool(PyObject *obj, bool *val)
2258 {
2259 if (obj == Py_True) {
2260 if (val) *val = true;
2261 return 1;
2262 }
2263 if (obj == Py_False) {
2264 if (val) *val = false;
2265 return 1;
2266 }
2267 int res = 0;
2268 if (SWIG_AsVal_int(obj, &res)) {
2269 if (val) *val = res ? true : false;
2270 return 1;
2271 } else {
2272 PyErr_Clear();
2273 }
2274 if (val) {
2275 SWIG_type_error("bool", obj);
2276 }
2277 return 0;
2278 }
2279
2280
2281 SWIGINTERNINLINE bool
2282 SWIG_As_bool(PyObject* obj)
2283 {
2284 bool v;
2285 if (!SWIG_AsVal_bool(obj, &v)) {
2286 /*
2287 this is needed to make valgrind/purify happier.
2288 */
2289 memset((void*)&v, 0, sizeof(bool));
2290 }
2291 return v;
2292 }
2293
2294
2295 SWIGINTERNINLINE int
2296 SWIG_Check_bool(PyObject* obj)
2297 {
2298 return SWIG_AsVal_bool(obj, (bool*)0);
2299 }
2300
2301 static wxString wxFileSystem_URLToFileName(wxString const &url){
2302 wxFileName fname = wxFileSystem::URLToFileName(url);
2303 return fname.GetFullPath();
2304 }
2305
2306 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2307 wxImage& image,
2308 long type) {
2309 wxMemoryFSHandler::AddFile(filename, image, type);
2310 }
2311
2312 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2313 const wxBitmap& bitmap,
2314 long type) {
2315 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2316 }
2317
2318 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2319 PyObject* data) {
2320 if (! PyString_Check(data)) {
2321 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2322 "Expected string object"));
2323 return;
2324 }
2325
2326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2327 void* ptr = (void*)PyString_AsString(data);
2328 size_t size = PyString_Size(data);
2329 wxPyEndBlockThreads(blocked);
2330
2331 wxMemoryFSHandler::AddFile(filename, ptr, size);
2332 }
2333
2334
2335 #include "wx/wxPython/pyistream.h"
2336
2337
2338 SWIGINTERN int
2339 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2340 {
2341 long v = 0;
2342 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2343 SWIG_Python_TypeError("unsigned number", obj);
2344 }
2345 else if (val)
2346 *val = (unsigned long)v;
2347 return 1;
2348 }
2349
2350
2351 SWIGINTERNINLINE int
2352 SWIG_CheckUnsignedLongInRange(unsigned long value,
2353 unsigned long max_value,
2354 const char *errmsg)
2355 {
2356 if (value > max_value) {
2357 if (errmsg) {
2358 PyErr_Format(PyExc_OverflowError,
2359 "value %lu is greater than '%s' minimum %lu",
2360 value, errmsg, max_value);
2361 }
2362 return 0;
2363 }
2364 return 1;
2365 }
2366
2367
2368 SWIGINTERN int
2369 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2370 {
2371 const char* errmsg = val ? "unsigned char" : (char*)0;
2372 unsigned long v;
2373 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2374 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2375 if (val) *val = static_cast<unsigned char >(v);
2376 return 1;
2377 } else {
2378 return 0;
2379 }
2380 } else {
2381 PyErr_Clear();
2382 }
2383 if (val) {
2384 SWIG_type_error(errmsg, obj);
2385 }
2386 return 0;
2387 }
2388
2389
2390 SWIGINTERNINLINE unsigned char
2391 SWIG_As_unsigned_SS_char(PyObject* obj)
2392 {
2393 unsigned char v;
2394 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2395 /*
2396 this is needed to make valgrind/purify happier.
2397 */
2398 memset((void*)&v, 0, sizeof(unsigned char));
2399 }
2400 return v;
2401 }
2402
2403
2404 SWIGINTERNINLINE int
2405 SWIG_Check_unsigned_SS_char(PyObject* obj)
2406 {
2407 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2408 }
2409
2410
2411 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2412 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2413 /*@@*/
2414
2415
2416
2417 SWIGINTERNINLINE unsigned long
2418 SWIG_As_unsigned_SS_long(PyObject* obj)
2419 {
2420 unsigned long v;
2421 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2422 /*
2423 this is needed to make valgrind/purify happier.
2424 */
2425 memset((void*)&v, 0, sizeof(unsigned long));
2426 }
2427 return v;
2428 }
2429
2430
2431 SWIGINTERNINLINE int
2432 SWIG_Check_unsigned_SS_long(PyObject* obj)
2433 {
2434 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2435 }
2436
2437 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2438 wxImageHistogramEntry e = (*self)[key];
2439 return e.value;
2440 }
2441 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2442 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2443 wxImageHistogramEntry e = (*self)[key];
2444 return e.value;
2445 }
2446 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2447 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2448 colour.Green(),
2449 colour.Blue());
2450 wxImageHistogramEntry e = (*self)[key];
2451 return e.value;
2452 }
2453
2454 typedef unsigned char* buffer;
2455
2456
2457 // Pull the nested class out to the top level for SWIG's sake
2458 #define wxImage_RGBValue wxImage::RGBValue
2459 #define wxImage_HSVValue wxImage::HSVValue
2460
2461 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2462 if (width > 0 && height > 0)
2463 return new wxImage(width, height, clear);
2464 else
2465 return new wxImage;
2466 }
2467 static wxImage *new_wxImage(wxBitmap const &bitmap){
2468 return new wxImage(bitmap.ConvertToImage());
2469 }
2470 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2471 if (DATASIZE != width*height*3) {
2472 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2473 return NULL;
2474 }
2475
2476 // Copy the source data so the wxImage can clean it up later
2477 buffer copy = (buffer)malloc(DATASIZE);
2478 if (copy == NULL) {
2479 wxPyBLOCK_THREADS(PyErr_NoMemory());
2480 return NULL;
2481 }
2482 memcpy(copy, data, DATASIZE);
2483 return new wxImage(width, height, copy, false);
2484 }
2485 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2486 if (DATASIZE != width*height*3) {
2487 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2488 return NULL;
2489 }
2490 if (ALPHASIZE != width*height) {
2491 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2492 return NULL;
2493 }
2494
2495 // Copy the source data so the wxImage can clean it up later
2496 buffer dcopy = (buffer)malloc(DATASIZE);
2497 if (dcopy == NULL) {
2498 wxPyBLOCK_THREADS(PyErr_NoMemory());
2499 return NULL;
2500 }
2501 memcpy(dcopy, data, DATASIZE);
2502
2503 buffer acopy = (buffer)malloc(ALPHASIZE);
2504 if (acopy == NULL) {
2505 wxPyBLOCK_THREADS(PyErr_NoMemory());
2506 return NULL;
2507 }
2508 memcpy(acopy, alpha, ALPHASIZE);
2509
2510 return new wxImage(width, height, dcopy, acopy, false);
2511 }
2512 static wxSize wxImage_GetSize(wxImage *self){
2513 wxSize size(self->GetWidth(), self->GetHeight());
2514 return size;
2515 }
2516 static PyObject *wxImage_GetData(wxImage *self){
2517 buffer data = self->GetData();
2518 int len = self->GetWidth() * self->GetHeight() * 3;
2519 PyObject* rv;
2520 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2521 return rv;
2522 }
2523 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2524 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2525 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2526 return;
2527 }
2528 buffer copy = (buffer)malloc(DATASIZE);
2529 if (copy == NULL) {
2530 wxPyBLOCK_THREADS(PyErr_NoMemory());
2531 return;
2532 }
2533 memcpy(copy, data, DATASIZE);
2534 self->SetData(copy, false);
2535 // wxImage takes ownership of copy...
2536 }
2537 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2538 buffer data = self->GetData();
2539 int len = self->GetWidth() * self->GetHeight() * 3;
2540 PyObject* rv;
2541 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2542 return rv;
2543 }
2544 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2545 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2546 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2547 return;
2548 }
2549 self->SetData(data, true);
2550 }
2551 static PyObject *wxImage_GetAlphaData(wxImage *self){
2552 buffer data = self->GetAlpha();
2553 if (! data) {
2554 RETURN_NONE();
2555 } else {
2556 int len = self->GetWidth() * self->GetHeight();
2557 PyObject* rv;
2558 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2559 return rv;
2560 }
2561 }
2562 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2563 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2564 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2565 return;
2566 }
2567 buffer acopy = (buffer)malloc(ALPHASIZE);
2568 if (acopy == NULL) {
2569 wxPyBLOCK_THREADS(PyErr_NoMemory());
2570 return;
2571 }
2572 memcpy(acopy, alpha, ALPHASIZE);
2573 self->SetAlpha(acopy, false);
2574 // wxImage takes ownership of acopy...
2575 }
2576 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2577 buffer data = self->GetAlpha();
2578 int len = self->GetWidth() * self->GetHeight();
2579 PyObject* rv;
2580 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2581 return rv;
2582 }
2583 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2584 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2585 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2586 return;
2587 }
2588 self->SetAlpha(alpha, true);
2589 }
2590 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2591 wxBitmap bitmap(*self, depth);
2592 return bitmap;
2593 }
2594 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2595 wxImage mono = self->ConvertToMono( red, green, blue );
2596 wxBitmap bitmap( mono, 1 );
2597 return bitmap;
2598 }
2599 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2600 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2601 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2602 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2603 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2604 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2605 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2606 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2607 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2608 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2609 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2610 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2611 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2612 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2613 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2614
2615 #include <wx/quantize.h>
2616
2617 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2618 return wxQuantize::Quantize(src, dest,
2619 //NULL, // palette
2620 desiredNoColours,
2621 NULL, // eightBitData
2622 flags);
2623 }
2624 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2625 if (PyCallable_Check(func)) {
2626 self->Connect(id, lastId, eventType,
2627 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2628 new wxPyCallback(func));
2629 }
2630 else if (func == Py_None) {
2631 self->Disconnect(id, lastId, eventType,
2632 (wxObjectEventFunction)
2633 &wxPyCallback::EventThunker);
2634 }
2635 else {
2636 wxPyBLOCK_THREADS(
2637 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2638 }
2639 }
2640 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2641 return self->Disconnect(id, lastId, eventType,
2642 (wxObjectEventFunction)
2643 &wxPyCallback::EventThunker);
2644 }
2645 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2646 if (_self && _self != Py_None) {
2647 self->SetClientObject(new wxPyOORClientData(_self, incref));
2648 }
2649 else {
2650 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2651 if (data) {
2652 self->SetClientObject(NULL); // This will delete it too
2653 }
2654 }
2655 }
2656
2657 #if ! wxUSE_HOTKEY
2658 #define wxEVT_HOTKEY -9999
2659 #endif
2660
2661
2662 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2663 #if wxUSE_UNICODE
2664 return self->GetUnicodeKey();
2665 #else
2666 return 0;
2667 #endif
2668 }
2669
2670 #if UINT_MAX < LONG_MAX
2671 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2672 #define SWIG_From_unsigned_SS_int SWIG_From_long
2673 /*@@*/
2674 #else
2675 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2676 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2677 /*@@*/
2678 #endif
2679
2680
2681 #if UINT_MAX != ULONG_MAX
2682 SWIGINTERN int
2683 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2684 {
2685 const char* errmsg = val ? "unsigned int" : (char*)0;
2686 unsigned long v;
2687 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2688 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2689 if (val) *val = static_cast<unsigned int >(v);
2690 return 1;
2691 }
2692 } else {
2693 PyErr_Clear();
2694 }
2695 if (val) {
2696 SWIG_type_error(errmsg, obj);
2697 }
2698 return 0;
2699 }
2700 #else
2701 SWIGINTERNINLINE unsigned int
2702 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2703 {
2704 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2705 }
2706 #endif
2707
2708
2709 SWIGINTERNINLINE unsigned int
2710 SWIG_As_unsigned_SS_int(PyObject* obj)
2711 {
2712 unsigned int v;
2713 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2714 /*
2715 this is needed to make valgrind/purify happier.
2716 */
2717 memset((void*)&v, 0, sizeof(unsigned int));
2718 }
2719 return v;
2720 }
2721
2722
2723 SWIGINTERNINLINE int
2724 SWIG_Check_unsigned_SS_int(PyObject* obj)
2725 {
2726 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2727 }
2728
2729 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2730 self->m_size = size;
2731 }
2732 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2733 int count = self->GetNumberOfFiles();
2734 wxString* files = self->GetFiles();
2735 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2736 PyObject* list = PyList_New(count);
2737
2738 if (!list) {
2739 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2740 wxPyEndBlockThreads(blocked);
2741 return NULL;
2742 }
2743
2744 for (int i=0; i<count; i++) {
2745 PyList_SetItem(list, i, wx2PyString(files[i]));
2746 }
2747 wxPyEndBlockThreads(blocked);
2748 return list;
2749 }
2750
2751
2752 static wxPyApp *new_wxPyApp(){
2753 wxPythonApp = new wxPyApp();
2754 return wxPythonApp;
2755 }
2756 static int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2757
2758 void wxApp_CleanUp() {
2759 __wxPyCleanup();
2760 }
2761
2762
2763 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2764
2765
2766 SWIGINTERNINLINE int
2767 SWIG_AsCharPtr(PyObject *obj, char **val)
2768 {
2769 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2770 return 1;
2771 }
2772 if (val) {
2773 PyErr_Clear();
2774 SWIG_type_error("char *", obj);
2775 }
2776 return 0;
2777 }
2778
2779
2780 SWIGINTERN PyObject *
2781 SWIG_FromCharPtr(const char* cptr)
2782 {
2783 if (cptr) {
2784 size_t size = strlen(cptr);
2785 if (size > INT_MAX) {
2786 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2787 SWIG_TypeQuery("char *"), 0);
2788 } else {
2789 if (size != 0) {
2790 return PyString_FromStringAndSize(cptr, size);
2791 } else {
2792 return PyString_FromString(cptr);
2793 }
2794 }
2795 }
2796 Py_INCREF(Py_None);
2797 return Py_None;
2798 }
2799
2800
2801 #if 0 // #ifdef __WXMAC__
2802
2803 // A dummy class that raises an exception if used...
2804 class wxEventLoop
2805 {
2806 public:
2807 wxEventLoop() { wxPyRaiseNotImplemented(); }
2808 int Run() { return 0; }
2809 void Exit(int rc = 0) {}
2810 bool Pending() const { return false; }
2811 bool Dispatch() { return false; }
2812 bool IsRunning() const { return false; }
2813 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2814 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2815 };
2816
2817 #else
2818
2819 #include <wx/evtloop.h>
2820
2821 #endif
2822
2823
2824
2825 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2826 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2827 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2828 static PyObject *wxWindow_GetChildren(wxWindow *self){
2829 wxWindowList& list = self->GetChildren();
2830 return wxPy_ConvertList(&list);
2831 }
2832 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2833 #if wxUSE_HOTKEY
2834 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2835 #else
2836 return false;
2837 #endif
2838 }
2839 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2840
2841
2842
2843 return false;
2844
2845 }
2846 static long wxWindow_GetHandle(wxWindow *self){
2847 return wxPyGetWinHandle(self);
2848 }
2849 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2850 self->AssociateHandle((WXWidget)handle);
2851 }
2852 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2853
2854 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2855 return wxWindow::FindWindowById(id, parent);
2856 }
2857
2858 wxWindow* wxFindWindowByName( const wxString& name,
2859 const wxWindow *parent = NULL ) {
2860 return wxWindow::FindWindowByName(name, parent);
2861 }
2862
2863 wxWindow* wxFindWindowByLabel( const wxString& label,
2864 const wxWindow *parent = NULL ) {
2865 return wxWindow::FindWindowByLabel(label, parent);
2866 }
2867
2868
2869 #ifdef __WXMSW__
2870 #include <wx/msw/private.h> // to get wxGetWindowId
2871 #endif
2872
2873
2874 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2875 #ifdef __WXMSW__
2876 WXHWND hWnd = (WXHWND)_hWnd;
2877 long id = wxGetWindowId(hWnd);
2878 wxWindow* win = new wxWindow;
2879 if (parent)
2880 parent->AddChild(win);
2881 win->SetEventHandler(win);
2882 win->SetHWND(hWnd);
2883 win->SetId(id);
2884 win->SubclassWin(hWnd);
2885 win->AdoptAttributesFromHWND();
2886 win->SetupColours();
2887 return win;
2888 #else
2889 wxPyRaiseNotImplemented();
2890 return NULL;
2891 #endif
2892 }
2893
2894
2895 PyObject* GetTopLevelWindows() {
2896 return wxPy_ConvertList(&wxTopLevelWindows);
2897 }
2898
2899
2900 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2901 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2902 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2903
2904 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2905
2906 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2907 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2908 wxMenuItemList& list = self->GetMenuItems();
2909 return wxPy_ConvertList(&list);
2910 }
2911 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2912 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2913 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2914 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2915 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2916 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2917 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
2918 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2919 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2920 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2921 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2922 static int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
2923 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2924 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2925 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2926 static const wxString wxPyControlNameStr(wxControlNameStr);
2927 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2928 if (clientData) {
2929 wxPyClientData* data = new wxPyClientData(clientData);
2930 return self->Append(item, data);
2931 } else
2932 return self->Append(item);
2933 }
2934 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2935 if (clientData) {
2936 wxPyClientData* data = new wxPyClientData(clientData);
2937 return self->Insert(item, pos, data);
2938 } else
2939 return self->Insert(item, pos);
2940 }
2941 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2942 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2943 if (data) {
2944 Py_INCREF(data->m_obj);
2945 return data->m_obj;
2946 } else {
2947 Py_INCREF(Py_None);
2948 return Py_None;
2949 }
2950 }
2951 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2952 wxPyClientData* data = new wxPyClientData(clientData);
2953 self->SetClientObject(n, data);
2954 }
2955
2956
2957 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2958 wxPyUserData* data = NULL;
2959 if ( userData ) {
2960 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2961 data = new wxPyUserData(userData);
2962 wxPyEndBlockThreads(blocked);
2963 }
2964 return new wxSizerItem(window, proportion, flag, border, data);
2965 }
2966 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2967 wxPyUserData* data = NULL;
2968 if ( userData ) {
2969 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2970 data = new wxPyUserData(userData);
2971 wxPyEndBlockThreads(blocked);
2972 }
2973 return new wxSizerItem(width, height, proportion, flag, border, data);
2974 }
2975 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2976 wxPyUserData* data = NULL;
2977 if ( userData ) {
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2979 data = new wxPyUserData(userData);
2980 wxPyEndBlockThreads(blocked);
2981 }
2982 return new wxSizerItem(sizer, proportion, flag, border, data);
2983 }
2984
2985 #include <float.h>
2986 SWIGINTERN int
2987 SWIG_CheckDoubleInRange(double value, double min_value,
2988 double max_value, const char* errmsg)
2989 {
2990 if (value < min_value) {
2991 if (errmsg) {
2992 PyErr_Format(PyExc_OverflowError,
2993 "value %g is less than %s minimum %g",
2994 value, errmsg, min_value);
2995 }
2996 return 0;
2997 } else if (value > max_value) {
2998 if (errmsg) {
2999 PyErr_Format(PyExc_OverflowError,
3000 "value %g is greater than %s maximum %g",
3001 value, errmsg, max_value);
3002 }
3003 return 0;
3004 }
3005 return 1;
3006 }
3007
3008
3009 SWIGINTERN int
3010 SWIG_AsVal_float(PyObject *obj, float *val)
3011 {
3012 const char* errmsg = val ? "float" : (char*)0;
3013 double v;
3014 if (SWIG_AsVal_double(obj, &v)) {
3015 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3016 if (val) *val = static_cast<float >(v);
3017 return 1;
3018 } else {
3019 return 0;
3020 }
3021 } else {
3022 PyErr_Clear();
3023 }
3024 if (val) {
3025 SWIG_type_error(errmsg, obj);
3026 }
3027 return 0;
3028 }
3029
3030
3031 SWIGINTERNINLINE float
3032 SWIG_As_float(PyObject* obj)
3033 {
3034 float v;
3035 if (!SWIG_AsVal_float(obj, &v)) {
3036 /*
3037 this is needed to make valgrind/purify happier.
3038 */
3039 memset((void*)&v, 0, sizeof(float));
3040 }
3041 return v;
3042 }
3043
3044
3045 SWIGINTERNINLINE int
3046 SWIG_Check_float(PyObject* obj)
3047 {
3048 return SWIG_AsVal_float(obj, (float*)0);
3049 }
3050
3051
3052 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
3053 #define SWIG_From_float PyFloat_FromDouble
3054 /*@@*/
3055
3056 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3057 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3058 if (data) {
3059 Py_INCREF(data->m_obj);
3060 return data->m_obj;
3061 } else {
3062 Py_INCREF(Py_None);
3063 return Py_None;
3064 }
3065 }
3066 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3067 wxPyUserData* data = NULL;
3068 if ( userData ) {
3069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3070 data = new wxPyUserData(userData);
3071 wxPyEndBlockThreads(blocked);
3072 }
3073 self->SetUserData(data);
3074 }
3075
3076 // Figure out the type of the sizer item
3077
3078 struct wxPySizerItemInfo {
3079 wxPySizerItemInfo()
3080 : window(NULL), sizer(NULL), gotSize(false),
3081 size(wxDefaultSize), gotPos(false), pos(-1)
3082 {}
3083
3084 wxWindow* window;
3085 wxSizer* sizer;
3086 bool gotSize;
3087 wxSize size;
3088 bool gotPos;
3089 int pos;
3090 };
3091
3092 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3093
3094 wxPySizerItemInfo info;
3095 wxSize size;
3096 wxSize* sizePtr = &size;
3097
3098 // Find out what the type of the item is
3099 // try wxWindow
3100 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3101 PyErr_Clear();
3102 info.window = NULL;
3103
3104 // try wxSizer
3105 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3106 PyErr_Clear();
3107 info.sizer = NULL;
3108
3109 // try wxSize or (w,h)
3110 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3111 info.size = *sizePtr;
3112 info.gotSize = true;
3113 }
3114
3115 // or a single int
3116 if (checkIdx && PyInt_Check(item)) {
3117 info.pos = PyInt_AsLong(item);
3118 info.gotPos = true;
3119 }
3120 }
3121 }
3122
3123 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3124 // no expected type, figure out what kind of error message to generate
3125 if ( !checkSize && !checkIdx )
3126 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3127 else if ( checkSize && !checkIdx )
3128 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3129 else if ( !checkSize && checkIdx)
3130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3131 else
3132 // can this one happen?
3133 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3134 }
3135
3136 return info;
3137 }
3138
3139 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3140 if (!self->GetClientObject())
3141 self->SetClientObject(new wxPyOORClientData(_self));
3142 }
3143 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3144
3145 wxPyUserData* data = NULL;
3146 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3147 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3148 if ( userData && (info.window || info.sizer || info.gotSize) )
3149 data = new wxPyUserData(userData);
3150 if ( info.sizer )
3151 PyObject_SetAttrString(item,"thisown",Py_False);
3152 wxPyEndBlockThreads(blocked);
3153
3154 // Now call the real Add method if a valid item type was found
3155 if ( info.window )
3156 return self->Add(info.window, proportion, flag, border, data);
3157 else if ( info.sizer )
3158 return self->Add(info.sizer, proportion, flag, border, data);
3159 else if (info.gotSize)
3160 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3161 proportion, flag, border, data);
3162 else
3163 return NULL;
3164 }
3165 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3166
3167 wxPyUserData* data = NULL;
3168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3170 if ( userData && (info.window || info.sizer || info.gotSize) )
3171 data = new wxPyUserData(userData);
3172 if ( info.sizer )
3173 PyObject_SetAttrString(item,"thisown",Py_False);
3174 wxPyEndBlockThreads(blocked);
3175
3176 // Now call the real Insert method if a valid item type was found
3177 if ( info.window )
3178 return self->Insert(before, info.window, proportion, flag, border, data);
3179 else if ( info.sizer )
3180 return self->Insert(before, info.sizer, proportion, flag, border, data);
3181 else if (info.gotSize)
3182 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3183 proportion, flag, border, data);
3184 else
3185 return NULL;
3186 }
3187 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3188
3189 wxPyUserData* data = NULL;
3190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3191 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3192 if ( userData && (info.window || info.sizer || info.gotSize) )
3193 data = new wxPyUserData(userData);
3194 if ( info.sizer )
3195 PyObject_SetAttrString(item,"thisown",Py_False);
3196 wxPyEndBlockThreads(blocked);
3197
3198 // Now call the real Prepend method if a valid item type was found
3199 if ( info.window )
3200 return self->Prepend(info.window, proportion, flag, border, data);
3201 else if ( info.sizer )
3202 return self->Prepend(info.sizer, proportion, flag, border, data);
3203 else if (info.gotSize)
3204 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3205 proportion, flag, border, data);
3206 else
3207 return NULL;
3208 }
3209 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3212 wxPyEndBlockThreads(blocked);
3213 if ( info.window )
3214 return self->Remove(info.window);
3215 else if ( info.sizer )
3216 return self->Remove(info.sizer);
3217 else if ( info.gotPos )
3218 return self->Remove(info.pos);
3219 else
3220 return false;
3221 }
3222 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3225 wxPyEndBlockThreads(blocked);
3226 if ( info.window )
3227 return self->Detach(info.window);
3228 else if ( info.sizer )
3229 return self->Detach(info.sizer);
3230 else if ( info.gotPos )
3231 return self->Detach(info.pos);
3232 else
3233 return false;
3234 }
3235 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3237 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3238 wxPyEndBlockThreads(blocked);
3239 if ( info.window )
3240 return self->GetItem(info.window);
3241 else if ( info.sizer )
3242 return self->GetItem(info.sizer);
3243 else if ( info.gotPos )
3244 return self->GetItem(info.pos);
3245 else
3246 return NULL;
3247 }
3248 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3249 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3250 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3251 wxPyEndBlockThreads(blocked);
3252 if ( info.window )
3253 self->SetItemMinSize(info.window, size);
3254 else if ( info.sizer )
3255 self->SetItemMinSize(info.sizer, size);
3256 else if ( info.gotPos )
3257 self->SetItemMinSize(info.pos, size);
3258 }
3259 static PyObject *wxSizer_GetChildren(wxSizer *self){
3260 wxSizerItemList& list = self->GetChildren();
3261 return wxPy_ConvertList(&list);
3262 }
3263 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3265 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3266 wxPyEndBlockThreads(blocked);
3267 if ( info.window )
3268 return self->Show(info.window, show, recursive);
3269 else if ( info.sizer )
3270 return self->Show(info.sizer, show, recursive);
3271 else if ( info.gotPos )
3272 return self->Show(info.pos, show);
3273 else
3274 return false;
3275 }
3276 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3279 wxPyEndBlockThreads(blocked);
3280 if ( info.window )
3281 return self->IsShown(info.window);
3282 else if ( info.sizer )
3283 return self->IsShown(info.sizer);
3284 else if ( info.gotPos )
3285 return self->IsShown(info.pos);
3286 else
3287 return false;
3288 }
3289
3290 // See pyclasses.h
3291 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3292 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3293 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3294
3295
3296
3297
3298 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3299 {
3300 if (source == Py_None) {
3301 **obj = wxGBPosition(-1,-1);
3302 return true;
3303 }
3304 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3305 }
3306
3307 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3308 {
3309 if (source == Py_None) {
3310 **obj = wxGBSpan(-1,-1);
3311 return true;
3312 }
3313 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3314 }
3315
3316
3317 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3318 self->SetRow(row);
3319 self->SetCol(col);
3320 }
3321 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3323 PyObject* tup = PyTuple_New(2);
3324 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3325 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3326 wxPyEndBlockThreads(blocked);
3327 return tup;
3328 }
3329 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3330 self->SetRowspan(rowspan);
3331 self->SetColspan(colspan);
3332 }
3333 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3335 PyObject* tup = PyTuple_New(2);
3336 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3337 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3338 wxPyEndBlockThreads(blocked);
3339 return tup;
3340 }
3341 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3342 wxPyUserData* data = NULL;
3343 if ( userData ) {
3344 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3345 data = new wxPyUserData(userData);
3346 wxPyEndBlockThreads(blocked);
3347 }
3348 return new wxGBSizerItem(window, pos, span, flag, border, data);
3349 }
3350 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3351 wxPyUserData* data = NULL;
3352 if ( userData ) {
3353 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3354 data = new wxPyUserData(userData);
3355 wxPyEndBlockThreads(blocked);
3356 }
3357 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3358 }
3359 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3360 wxPyUserData* data = NULL;
3361 if ( userData ) {
3362 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3363 data = new wxPyUserData(userData);
3364 wxPyEndBlockThreads(blocked);
3365 }
3366 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3367 }
3368 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3369 int row, col;
3370 self->GetEndPos(row, col);
3371 return wxGBPosition(row, col);
3372 }
3373 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3374
3375 wxPyUserData* data = NULL;
3376 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3377 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3378 if ( userData && (info.window || info.sizer || info.gotSize) )
3379 data = new wxPyUserData(userData);
3380 if ( info.sizer )
3381 PyObject_SetAttrString(item,"thisown",Py_False);
3382 wxPyEndBlockThreads(blocked);
3383
3384 // Now call the real Add method if a valid item type was found
3385 if ( info.window )
3386 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3387 else if ( info.sizer )
3388 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3389 else if (info.gotSize)
3390 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3391 pos, span, flag, border, data);
3392 return NULL;
3393 }
3394
3395
3396 #ifdef __cplusplus
3397 extern "C" {
3398 #endif
3399 static int _wrap_EmptyString_set(PyObject *) {
3400 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3401 return 1;
3402 }
3403
3404
3405 static PyObject *_wrap_EmptyString_get(void) {
3406 PyObject *pyobj = NULL;
3407
3408 {
3409 #if wxUSE_UNICODE
3410 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3411 #else
3412 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3413 #endif
3414 }
3415 return pyobj;
3416 }
3417
3418
3419 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3420 PyObject *resultobj = NULL;
3421 wxObject *arg1 = (wxObject *) 0 ;
3422 wxString result;
3423 PyObject * obj0 = 0 ;
3424 char *kwnames[] = {
3425 (char *) "self", NULL
3426 };
3427
3428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3430 if (SWIG_arg_fail(1)) SWIG_fail;
3431 {
3432 PyThreadState* __tstate = wxPyBeginAllowThreads();
3433 result = wxObject_GetClassName(arg1);
3434
3435 wxPyEndAllowThreads(__tstate);
3436 if (PyErr_Occurred()) SWIG_fail;
3437 }
3438 {
3439 #if wxUSE_UNICODE
3440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3441 #else
3442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3443 #endif
3444 }
3445 return resultobj;
3446 fail:
3447 return NULL;
3448 }
3449
3450
3451 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj = NULL;
3453 wxObject *arg1 = (wxObject *) 0 ;
3454 PyObject * obj0 = 0 ;
3455 char *kwnames[] = {
3456 (char *) "self", NULL
3457 };
3458
3459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3461 if (SWIG_arg_fail(1)) SWIG_fail;
3462 {
3463 PyThreadState* __tstate = wxPyBeginAllowThreads();
3464 wxObject_Destroy(arg1);
3465
3466 wxPyEndAllowThreads(__tstate);
3467 if (PyErr_Occurred()) SWIG_fail;
3468 }
3469 Py_INCREF(Py_None); resultobj = Py_None;
3470 return resultobj;
3471 fail:
3472 return NULL;
3473 }
3474
3475
3476 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3477 PyObject *obj;
3478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3479 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3480 Py_INCREF(obj);
3481 return Py_BuildValue((char *)"");
3482 }
3483 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3484 PyObject *resultobj = NULL;
3485 wxSize *arg1 = (wxSize *) 0 ;
3486 int arg2 ;
3487 PyObject * obj0 = 0 ;
3488 PyObject * obj1 = 0 ;
3489 char *kwnames[] = {
3490 (char *) "self",(char *) "x", NULL
3491 };
3492
3493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3495 if (SWIG_arg_fail(1)) SWIG_fail;
3496 {
3497 arg2 = static_cast<int >(SWIG_As_int(obj1));
3498 if (SWIG_arg_fail(2)) SWIG_fail;
3499 }
3500 if (arg1) (arg1)->x = arg2;
3501
3502 Py_INCREF(Py_None); resultobj = Py_None;
3503 return resultobj;
3504 fail:
3505 return NULL;
3506 }
3507
3508
3509 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3510 PyObject *resultobj = NULL;
3511 wxSize *arg1 = (wxSize *) 0 ;
3512 int result;
3513 PyObject * obj0 = 0 ;
3514 char *kwnames[] = {
3515 (char *) "self", NULL
3516 };
3517
3518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3520 if (SWIG_arg_fail(1)) SWIG_fail;
3521 result = (int) ((arg1)->x);
3522
3523 {
3524 resultobj = SWIG_From_int(static_cast<int >(result));
3525 }
3526 return resultobj;
3527 fail:
3528 return NULL;
3529 }
3530
3531
3532 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3533 PyObject *resultobj = NULL;
3534 wxSize *arg1 = (wxSize *) 0 ;
3535 int arg2 ;
3536 PyObject * obj0 = 0 ;
3537 PyObject * obj1 = 0 ;
3538 char *kwnames[] = {
3539 (char *) "self",(char *) "y", NULL
3540 };
3541
3542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3544 if (SWIG_arg_fail(1)) SWIG_fail;
3545 {
3546 arg2 = static_cast<int >(SWIG_As_int(obj1));
3547 if (SWIG_arg_fail(2)) SWIG_fail;
3548 }
3549 if (arg1) (arg1)->y = arg2;
3550
3551 Py_INCREF(Py_None); resultobj = Py_None;
3552 return resultobj;
3553 fail:
3554 return NULL;
3555 }
3556
3557
3558 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3559 PyObject *resultobj = NULL;
3560 wxSize *arg1 = (wxSize *) 0 ;
3561 int result;
3562 PyObject * obj0 = 0 ;
3563 char *kwnames[] = {
3564 (char *) "self", NULL
3565 };
3566
3567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(1)) SWIG_fail;
3570 result = (int) ((arg1)->y);
3571
3572 {
3573 resultobj = SWIG_From_int(static_cast<int >(result));
3574 }
3575 return resultobj;
3576 fail:
3577 return NULL;
3578 }
3579
3580
3581 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3582 PyObject *resultobj = NULL;
3583 int arg1 = (int) 0 ;
3584 int arg2 = (int) 0 ;
3585 wxSize *result;
3586 PyObject * obj0 = 0 ;
3587 PyObject * obj1 = 0 ;
3588 char *kwnames[] = {
3589 (char *) "w",(char *) "h", NULL
3590 };
3591
3592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3593 if (obj0) {
3594 {
3595 arg1 = static_cast<int >(SWIG_As_int(obj0));
3596 if (SWIG_arg_fail(1)) SWIG_fail;
3597 }
3598 }
3599 if (obj1) {
3600 {
3601 arg2 = static_cast<int >(SWIG_As_int(obj1));
3602 if (SWIG_arg_fail(2)) SWIG_fail;
3603 }
3604 }
3605 {
3606 PyThreadState* __tstate = wxPyBeginAllowThreads();
3607 result = (wxSize *)new wxSize(arg1,arg2);
3608
3609 wxPyEndAllowThreads(__tstate);
3610 if (PyErr_Occurred()) SWIG_fail;
3611 }
3612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3613 return resultobj;
3614 fail:
3615 return NULL;
3616 }
3617
3618
3619 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3620 PyObject *resultobj = NULL;
3621 wxSize *arg1 = (wxSize *) 0 ;
3622 PyObject * obj0 = 0 ;
3623 char *kwnames[] = {
3624 (char *) "self", NULL
3625 };
3626
3627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3629 if (SWIG_arg_fail(1)) SWIG_fail;
3630 {
3631 PyThreadState* __tstate = wxPyBeginAllowThreads();
3632 delete arg1;
3633
3634 wxPyEndAllowThreads(__tstate);
3635 if (PyErr_Occurred()) SWIG_fail;
3636 }
3637 Py_INCREF(Py_None); resultobj = Py_None;
3638 return resultobj;
3639 fail:
3640 return NULL;
3641 }
3642
3643
3644 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3645 PyObject *resultobj = NULL;
3646 wxSize *arg1 = (wxSize *) 0 ;
3647 wxSize *arg2 = 0 ;
3648 bool result;
3649 wxSize temp2 ;
3650 PyObject * obj0 = 0 ;
3651 PyObject * obj1 = 0 ;
3652 char *kwnames[] = {
3653 (char *) "self",(char *) "sz", NULL
3654 };
3655
3656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3658 if (SWIG_arg_fail(1)) SWIG_fail;
3659 {
3660 arg2 = &temp2;
3661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3662 }
3663 {
3664 PyThreadState* __tstate = wxPyBeginAllowThreads();
3665 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3666
3667 wxPyEndAllowThreads(__tstate);
3668 if (PyErr_Occurred()) SWIG_fail;
3669 }
3670 {
3671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3672 }
3673 return resultobj;
3674 fail:
3675 return NULL;
3676 }
3677
3678
3679 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3680 PyObject *resultobj = NULL;
3681 wxSize *arg1 = (wxSize *) 0 ;
3682 wxSize *arg2 = 0 ;
3683 bool result;
3684 wxSize temp2 ;
3685 PyObject * obj0 = 0 ;
3686 PyObject * obj1 = 0 ;
3687 char *kwnames[] = {
3688 (char *) "self",(char *) "sz", NULL
3689 };
3690
3691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3693 if (SWIG_arg_fail(1)) SWIG_fail;
3694 {
3695 arg2 = &temp2;
3696 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3697 }
3698 {
3699 PyThreadState* __tstate = wxPyBeginAllowThreads();
3700 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3701
3702 wxPyEndAllowThreads(__tstate);
3703 if (PyErr_Occurred()) SWIG_fail;
3704 }
3705 {
3706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3707 }
3708 return resultobj;
3709 fail:
3710 return NULL;
3711 }
3712
3713
3714 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3715 PyObject *resultobj = NULL;
3716 wxSize *arg1 = (wxSize *) 0 ;
3717 wxSize *arg2 = 0 ;
3718 wxSize result;
3719 wxSize temp2 ;
3720 PyObject * obj0 = 0 ;
3721 PyObject * obj1 = 0 ;
3722 char *kwnames[] = {
3723 (char *) "self",(char *) "sz", NULL
3724 };
3725
3726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3728 if (SWIG_arg_fail(1)) SWIG_fail;
3729 {
3730 arg2 = &temp2;
3731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3732 }
3733 {
3734 PyThreadState* __tstate = wxPyBeginAllowThreads();
3735 result = (arg1)->operator +((wxSize const &)*arg2);
3736
3737 wxPyEndAllowThreads(__tstate);
3738 if (PyErr_Occurred()) SWIG_fail;
3739 }
3740 {
3741 wxSize * resultptr;
3742 resultptr = new wxSize(static_cast<wxSize & >(result));
3743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3744 }
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj = NULL;
3753 wxSize *arg1 = (wxSize *) 0 ;
3754 wxSize *arg2 = 0 ;
3755 wxSize result;
3756 wxSize temp2 ;
3757 PyObject * obj0 = 0 ;
3758 PyObject * obj1 = 0 ;
3759 char *kwnames[] = {
3760 (char *) "self",(char *) "sz", NULL
3761 };
3762
3763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3765 if (SWIG_arg_fail(1)) SWIG_fail;
3766 {
3767 arg2 = &temp2;
3768 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3769 }
3770 {
3771 PyThreadState* __tstate = wxPyBeginAllowThreads();
3772 result = (arg1)->operator -((wxSize const &)*arg2);
3773
3774 wxPyEndAllowThreads(__tstate);
3775 if (PyErr_Occurred()) SWIG_fail;
3776 }
3777 {
3778 wxSize * resultptr;
3779 resultptr = new wxSize(static_cast<wxSize & >(result));
3780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3781 }
3782 return resultobj;
3783 fail:
3784 return NULL;
3785 }
3786
3787
3788 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3789 PyObject *resultobj = NULL;
3790 wxSize *arg1 = (wxSize *) 0 ;
3791 wxSize *arg2 = 0 ;
3792 wxSize temp2 ;
3793 PyObject * obj0 = 0 ;
3794 PyObject * obj1 = 0 ;
3795 char *kwnames[] = {
3796 (char *) "self",(char *) "sz", NULL
3797 };
3798
3799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3801 if (SWIG_arg_fail(1)) SWIG_fail;
3802 {
3803 arg2 = &temp2;
3804 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3805 }
3806 {
3807 PyThreadState* __tstate = wxPyBeginAllowThreads();
3808 (arg1)->IncTo((wxSize const &)*arg2);
3809
3810 wxPyEndAllowThreads(__tstate);
3811 if (PyErr_Occurred()) SWIG_fail;
3812 }
3813 Py_INCREF(Py_None); resultobj = Py_None;
3814 return resultobj;
3815 fail:
3816 return NULL;
3817 }
3818
3819
3820 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3821 PyObject *resultobj = NULL;
3822 wxSize *arg1 = (wxSize *) 0 ;
3823 wxSize *arg2 = 0 ;
3824 wxSize temp2 ;
3825 PyObject * obj0 = 0 ;
3826 PyObject * obj1 = 0 ;
3827 char *kwnames[] = {
3828 (char *) "self",(char *) "sz", NULL
3829 };
3830
3831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3833 if (SWIG_arg_fail(1)) SWIG_fail;
3834 {
3835 arg2 = &temp2;
3836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3837 }
3838 {
3839 PyThreadState* __tstate = wxPyBeginAllowThreads();
3840 (arg1)->DecTo((wxSize const &)*arg2);
3841
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 Py_INCREF(Py_None); resultobj = Py_None;
3846 return resultobj;
3847 fail:
3848 return NULL;
3849 }
3850
3851
3852 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3853 PyObject *resultobj = NULL;
3854 wxSize *arg1 = (wxSize *) 0 ;
3855 int arg2 ;
3856 int arg3 ;
3857 PyObject * obj0 = 0 ;
3858 PyObject * obj1 = 0 ;
3859 PyObject * obj2 = 0 ;
3860 char *kwnames[] = {
3861 (char *) "self",(char *) "w",(char *) "h", NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3866 if (SWIG_arg_fail(1)) SWIG_fail;
3867 {
3868 arg2 = static_cast<int >(SWIG_As_int(obj1));
3869 if (SWIG_arg_fail(2)) SWIG_fail;
3870 }
3871 {
3872 arg3 = static_cast<int >(SWIG_As_int(obj2));
3873 if (SWIG_arg_fail(3)) SWIG_fail;
3874 }
3875 {
3876 PyThreadState* __tstate = wxPyBeginAllowThreads();
3877 (arg1)->Set(arg2,arg3);
3878
3879 wxPyEndAllowThreads(__tstate);
3880 if (PyErr_Occurred()) SWIG_fail;
3881 }
3882 Py_INCREF(Py_None); resultobj = Py_None;
3883 return resultobj;
3884 fail:
3885 return NULL;
3886 }
3887
3888
3889 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3890 PyObject *resultobj = NULL;
3891 wxSize *arg1 = (wxSize *) 0 ;
3892 int arg2 ;
3893 PyObject * obj0 = 0 ;
3894 PyObject * obj1 = 0 ;
3895 char *kwnames[] = {
3896 (char *) "self",(char *) "w", NULL
3897 };
3898
3899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3901 if (SWIG_arg_fail(1)) SWIG_fail;
3902 {
3903 arg2 = static_cast<int >(SWIG_As_int(obj1));
3904 if (SWIG_arg_fail(2)) SWIG_fail;
3905 }
3906 {
3907 PyThreadState* __tstate = wxPyBeginAllowThreads();
3908 (arg1)->SetWidth(arg2);
3909
3910 wxPyEndAllowThreads(__tstate);
3911 if (PyErr_Occurred()) SWIG_fail;
3912 }
3913 Py_INCREF(Py_None); resultobj = Py_None;
3914 return resultobj;
3915 fail:
3916 return NULL;
3917 }
3918
3919
3920 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3921 PyObject *resultobj = NULL;
3922 wxSize *arg1 = (wxSize *) 0 ;
3923 int arg2 ;
3924 PyObject * obj0 = 0 ;
3925 PyObject * obj1 = 0 ;
3926 char *kwnames[] = {
3927 (char *) "self",(char *) "h", NULL
3928 };
3929
3930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3932 if (SWIG_arg_fail(1)) SWIG_fail;
3933 {
3934 arg2 = static_cast<int >(SWIG_As_int(obj1));
3935 if (SWIG_arg_fail(2)) SWIG_fail;
3936 }
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 (arg1)->SetHeight(arg2);
3940
3941 wxPyEndAllowThreads(__tstate);
3942 if (PyErr_Occurred()) SWIG_fail;
3943 }
3944 Py_INCREF(Py_None); resultobj = Py_None;
3945 return resultobj;
3946 fail:
3947 return NULL;
3948 }
3949
3950
3951 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3952 PyObject *resultobj = NULL;
3953 wxSize *arg1 = (wxSize *) 0 ;
3954 int result;
3955 PyObject * obj0 = 0 ;
3956 char *kwnames[] = {
3957 (char *) "self", NULL
3958 };
3959
3960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3962 if (SWIG_arg_fail(1)) SWIG_fail;
3963 {
3964 PyThreadState* __tstate = wxPyBeginAllowThreads();
3965 result = (int)((wxSize const *)arg1)->GetWidth();
3966
3967 wxPyEndAllowThreads(__tstate);
3968 if (PyErr_Occurred()) SWIG_fail;
3969 }
3970 {
3971 resultobj = SWIG_From_int(static_cast<int >(result));
3972 }
3973 return resultobj;
3974 fail:
3975 return NULL;
3976 }
3977
3978
3979 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3980 PyObject *resultobj = NULL;
3981 wxSize *arg1 = (wxSize *) 0 ;
3982 int result;
3983 PyObject * obj0 = 0 ;
3984 char *kwnames[] = {
3985 (char *) "self", NULL
3986 };
3987
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3990 if (SWIG_arg_fail(1)) SWIG_fail;
3991 {
3992 PyThreadState* __tstate = wxPyBeginAllowThreads();
3993 result = (int)((wxSize const *)arg1)->GetHeight();
3994
3995 wxPyEndAllowThreads(__tstate);
3996 if (PyErr_Occurred()) SWIG_fail;
3997 }
3998 {
3999 resultobj = SWIG_From_int(static_cast<int >(result));
4000 }
4001 return resultobj;
4002 fail:
4003 return NULL;
4004 }
4005
4006
4007 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
4008 PyObject *resultobj = NULL;
4009 wxSize *arg1 = (wxSize *) 0 ;
4010 bool result;
4011 PyObject * obj0 = 0 ;
4012 char *kwnames[] = {
4013 (char *) "self", NULL
4014 };
4015
4016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4018 if (SWIG_arg_fail(1)) SWIG_fail;
4019 {
4020 PyThreadState* __tstate = wxPyBeginAllowThreads();
4021 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4022
4023 wxPyEndAllowThreads(__tstate);
4024 if (PyErr_Occurred()) SWIG_fail;
4025 }
4026 {
4027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4028 }
4029 return resultobj;
4030 fail:
4031 return NULL;
4032 }
4033
4034
4035 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4036 PyObject *resultobj = NULL;
4037 wxSize *arg1 = (wxSize *) 0 ;
4038 wxSize *arg2 = 0 ;
4039 wxSize temp2 ;
4040 PyObject * obj0 = 0 ;
4041 PyObject * obj1 = 0 ;
4042 char *kwnames[] = {
4043 (char *) "self",(char *) "size", NULL
4044 };
4045
4046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4048 if (SWIG_arg_fail(1)) SWIG_fail;
4049 {
4050 arg2 = &temp2;
4051 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4052 }
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 (arg1)->SetDefaults((wxSize const &)*arg2);
4056
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 Py_INCREF(Py_None); resultobj = Py_None;
4061 return resultobj;
4062 fail:
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj = NULL;
4069 wxSize *arg1 = (wxSize *) 0 ;
4070 PyObject *result;
4071 PyObject * obj0 = 0 ;
4072 char *kwnames[] = {
4073 (char *) "self", NULL
4074 };
4075
4076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4078 if (SWIG_arg_fail(1)) SWIG_fail;
4079 {
4080 PyThreadState* __tstate = wxPyBeginAllowThreads();
4081 result = (PyObject *)wxSize_Get(arg1);
4082
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 resultobj = result;
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4094 PyObject *obj;
4095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4096 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4097 Py_INCREF(obj);
4098 return Py_BuildValue((char *)"");
4099 }
4100 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj = NULL;
4102 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4103 double arg2 ;
4104 PyObject * obj0 = 0 ;
4105 PyObject * obj1 = 0 ;
4106 char *kwnames[] = {
4107 (char *) "self",(char *) "x", NULL
4108 };
4109
4110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4112 if (SWIG_arg_fail(1)) SWIG_fail;
4113 {
4114 arg2 = static_cast<double >(SWIG_As_double(obj1));
4115 if (SWIG_arg_fail(2)) SWIG_fail;
4116 }
4117 if (arg1) (arg1)->x = arg2;
4118
4119 Py_INCREF(Py_None); resultobj = Py_None;
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj = NULL;
4128 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4129 double result;
4130 PyObject * obj0 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "self", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4137 if (SWIG_arg_fail(1)) SWIG_fail;
4138 result = (double) ((arg1)->x);
4139
4140 {
4141 resultobj = SWIG_From_double(static_cast<double >(result));
4142 }
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj = NULL;
4151 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4152 double arg2 ;
4153 PyObject * obj0 = 0 ;
4154 PyObject * obj1 = 0 ;
4155 char *kwnames[] = {
4156 (char *) "self",(char *) "y", NULL
4157 };
4158
4159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4161 if (SWIG_arg_fail(1)) SWIG_fail;
4162 {
4163 arg2 = static_cast<double >(SWIG_As_double(obj1));
4164 if (SWIG_arg_fail(2)) SWIG_fail;
4165 }
4166 if (arg1) (arg1)->y = arg2;
4167
4168 Py_INCREF(Py_None); resultobj = Py_None;
4169 return resultobj;
4170 fail:
4171 return NULL;
4172 }
4173
4174
4175 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4176 PyObject *resultobj = NULL;
4177 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4178 double result;
4179 PyObject * obj0 = 0 ;
4180 char *kwnames[] = {
4181 (char *) "self", NULL
4182 };
4183
4184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4186 if (SWIG_arg_fail(1)) SWIG_fail;
4187 result = (double) ((arg1)->y);
4188
4189 {
4190 resultobj = SWIG_From_double(static_cast<double >(result));
4191 }
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj = NULL;
4200 double arg1 = (double) 0.0 ;
4201 double arg2 = (double) 0.0 ;
4202 wxRealPoint *result;
4203 PyObject * obj0 = 0 ;
4204 PyObject * obj1 = 0 ;
4205 char *kwnames[] = {
4206 (char *) "x",(char *) "y", NULL
4207 };
4208
4209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4210 if (obj0) {
4211 {
4212 arg1 = static_cast<double >(SWIG_As_double(obj0));
4213 if (SWIG_arg_fail(1)) SWIG_fail;
4214 }
4215 }
4216 if (obj1) {
4217 {
4218 arg2 = static_cast<double >(SWIG_As_double(obj1));
4219 if (SWIG_arg_fail(2)) SWIG_fail;
4220 }
4221 }
4222 {
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4225
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4230 return resultobj;
4231 fail:
4232 return NULL;
4233 }
4234
4235
4236 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4237 PyObject *resultobj = NULL;
4238 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4239 PyObject * obj0 = 0 ;
4240 char *kwnames[] = {
4241 (char *) "self", NULL
4242 };
4243
4244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4246 if (SWIG_arg_fail(1)) SWIG_fail;
4247 {
4248 PyThreadState* __tstate = wxPyBeginAllowThreads();
4249 delete arg1;
4250
4251 wxPyEndAllowThreads(__tstate);
4252 if (PyErr_Occurred()) SWIG_fail;
4253 }
4254 Py_INCREF(Py_None); resultobj = Py_None;
4255 return resultobj;
4256 fail:
4257 return NULL;
4258 }
4259
4260
4261 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4262 PyObject *resultobj = NULL;
4263 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4264 wxRealPoint *arg2 = 0 ;
4265 bool result;
4266 wxRealPoint temp2 ;
4267 PyObject * obj0 = 0 ;
4268 PyObject * obj1 = 0 ;
4269 char *kwnames[] = {
4270 (char *) "self",(char *) "pt", NULL
4271 };
4272
4273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4275 if (SWIG_arg_fail(1)) SWIG_fail;
4276 {
4277 arg2 = &temp2;
4278 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4279 }
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4283
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 {
4288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4289 }
4290 return resultobj;
4291 fail:
4292 return NULL;
4293 }
4294
4295
4296 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4297 PyObject *resultobj = NULL;
4298 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4299 wxRealPoint *arg2 = 0 ;
4300 bool result;
4301 wxRealPoint temp2 ;
4302 PyObject * obj0 = 0 ;
4303 PyObject * obj1 = 0 ;
4304 char *kwnames[] = {
4305 (char *) "self",(char *) "pt", NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4310 if (SWIG_arg_fail(1)) SWIG_fail;
4311 {
4312 arg2 = &temp2;
4313 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4314 }
4315 {
4316 PyThreadState* __tstate = wxPyBeginAllowThreads();
4317 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4318
4319 wxPyEndAllowThreads(__tstate);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 {
4323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4324 }
4325 return resultobj;
4326 fail:
4327 return NULL;
4328 }
4329
4330
4331 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4332 PyObject *resultobj = NULL;
4333 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4334 wxRealPoint *arg2 = 0 ;
4335 wxRealPoint result;
4336 wxRealPoint temp2 ;
4337 PyObject * obj0 = 0 ;
4338 PyObject * obj1 = 0 ;
4339 char *kwnames[] = {
4340 (char *) "self",(char *) "pt", NULL
4341 };
4342
4343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4345 if (SWIG_arg_fail(1)) SWIG_fail;
4346 {
4347 arg2 = &temp2;
4348 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4349 }
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4353
4354 wxPyEndAllowThreads(__tstate);
4355 if (PyErr_Occurred()) SWIG_fail;
4356 }
4357 {
4358 wxRealPoint * resultptr;
4359 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4361 }
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj = NULL;
4370 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4371 wxRealPoint *arg2 = 0 ;
4372 wxRealPoint result;
4373 wxRealPoint temp2 ;
4374 PyObject * obj0 = 0 ;
4375 PyObject * obj1 = 0 ;
4376 char *kwnames[] = {
4377 (char *) "self",(char *) "pt", NULL
4378 };
4379
4380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4382 if (SWIG_arg_fail(1)) SWIG_fail;
4383 {
4384 arg2 = &temp2;
4385 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4386 }
4387 {
4388 PyThreadState* __tstate = wxPyBeginAllowThreads();
4389 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4390
4391 wxPyEndAllowThreads(__tstate);
4392 if (PyErr_Occurred()) SWIG_fail;
4393 }
4394 {
4395 wxRealPoint * resultptr;
4396 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4398 }
4399 return resultobj;
4400 fail:
4401 return NULL;
4402 }
4403
4404
4405 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4406 PyObject *resultobj = NULL;
4407 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4408 double arg2 ;
4409 double arg3 ;
4410 PyObject * obj0 = 0 ;
4411 PyObject * obj1 = 0 ;
4412 PyObject * obj2 = 0 ;
4413 char *kwnames[] = {
4414 (char *) "self",(char *) "x",(char *) "y", NULL
4415 };
4416
4417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4419 if (SWIG_arg_fail(1)) SWIG_fail;
4420 {
4421 arg2 = static_cast<double >(SWIG_As_double(obj1));
4422 if (SWIG_arg_fail(2)) SWIG_fail;
4423 }
4424 {
4425 arg3 = static_cast<double >(SWIG_As_double(obj2));
4426 if (SWIG_arg_fail(3)) SWIG_fail;
4427 }
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 wxRealPoint_Set(arg1,arg2,arg3);
4431
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 Py_INCREF(Py_None); resultobj = Py_None;
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4443 PyObject *resultobj = NULL;
4444 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4445 PyObject *result;
4446 PyObject * obj0 = 0 ;
4447 char *kwnames[] = {
4448 (char *) "self", NULL
4449 };
4450
4451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4453 if (SWIG_arg_fail(1)) SWIG_fail;
4454 {
4455 PyThreadState* __tstate = wxPyBeginAllowThreads();
4456 result = (PyObject *)wxRealPoint_Get(arg1);
4457
4458 wxPyEndAllowThreads(__tstate);
4459 if (PyErr_Occurred()) SWIG_fail;
4460 }
4461 resultobj = result;
4462 return resultobj;
4463 fail:
4464 return NULL;
4465 }
4466
4467
4468 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4469 PyObject *obj;
4470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4471 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4472 Py_INCREF(obj);
4473 return Py_BuildValue((char *)"");
4474 }
4475 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4476 PyObject *resultobj = NULL;
4477 wxPoint *arg1 = (wxPoint *) 0 ;
4478 int arg2 ;
4479 PyObject * obj0 = 0 ;
4480 PyObject * obj1 = 0 ;
4481 char *kwnames[] = {
4482 (char *) "self",(char *) "x", NULL
4483 };
4484
4485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4487 if (SWIG_arg_fail(1)) SWIG_fail;
4488 {
4489 arg2 = static_cast<int >(SWIG_As_int(obj1));
4490 if (SWIG_arg_fail(2)) SWIG_fail;
4491 }
4492 if (arg1) (arg1)->x = arg2;
4493
4494 Py_INCREF(Py_None); resultobj = Py_None;
4495 return resultobj;
4496 fail:
4497 return NULL;
4498 }
4499
4500
4501 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4502 PyObject *resultobj = NULL;
4503 wxPoint *arg1 = (wxPoint *) 0 ;
4504 int result;
4505 PyObject * obj0 = 0 ;
4506 char *kwnames[] = {
4507 (char *) "self", NULL
4508 };
4509
4510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4512 if (SWIG_arg_fail(1)) SWIG_fail;
4513 result = (int) ((arg1)->x);
4514
4515 {
4516 resultobj = SWIG_From_int(static_cast<int >(result));
4517 }
4518 return resultobj;
4519 fail:
4520 return NULL;
4521 }
4522
4523
4524 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4525 PyObject *resultobj = NULL;
4526 wxPoint *arg1 = (wxPoint *) 0 ;
4527 int arg2 ;
4528 PyObject * obj0 = 0 ;
4529 PyObject * obj1 = 0 ;
4530 char *kwnames[] = {
4531 (char *) "self",(char *) "y", NULL
4532 };
4533
4534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4536 if (SWIG_arg_fail(1)) SWIG_fail;
4537 {
4538 arg2 = static_cast<int >(SWIG_As_int(obj1));
4539 if (SWIG_arg_fail(2)) SWIG_fail;
4540 }
4541 if (arg1) (arg1)->y = arg2;
4542
4543 Py_INCREF(Py_None); resultobj = Py_None;
4544 return resultobj;
4545 fail:
4546 return NULL;
4547 }
4548
4549
4550 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4551 PyObject *resultobj = NULL;
4552 wxPoint *arg1 = (wxPoint *) 0 ;
4553 int result;
4554 PyObject * obj0 = 0 ;
4555 char *kwnames[] = {
4556 (char *) "self", NULL
4557 };
4558
4559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4561 if (SWIG_arg_fail(1)) SWIG_fail;
4562 result = (int) ((arg1)->y);
4563
4564 {
4565 resultobj = SWIG_From_int(static_cast<int >(result));
4566 }
4567 return resultobj;
4568 fail:
4569 return NULL;
4570 }
4571
4572
4573 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4574 PyObject *resultobj = NULL;
4575 int arg1 = (int) 0 ;
4576 int arg2 = (int) 0 ;
4577 wxPoint *result;
4578 PyObject * obj0 = 0 ;
4579 PyObject * obj1 = 0 ;
4580 char *kwnames[] = {
4581 (char *) "x",(char *) "y", NULL
4582 };
4583
4584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4585 if (obj0) {
4586 {
4587 arg1 = static_cast<int >(SWIG_As_int(obj0));
4588 if (SWIG_arg_fail(1)) SWIG_fail;
4589 }
4590 }
4591 if (obj1) {
4592 {
4593 arg2 = static_cast<int >(SWIG_As_int(obj1));
4594 if (SWIG_arg_fail(2)) SWIG_fail;
4595 }
4596 }
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (wxPoint *)new wxPoint(arg1,arg2);
4600
4601 wxPyEndAllowThreads(__tstate);
4602 if (PyErr_Occurred()) SWIG_fail;
4603 }
4604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4605 return resultobj;
4606 fail:
4607 return NULL;
4608 }
4609
4610
4611 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4612 PyObject *resultobj = NULL;
4613 wxPoint *arg1 = (wxPoint *) 0 ;
4614 PyObject * obj0 = 0 ;
4615 char *kwnames[] = {
4616 (char *) "self", NULL
4617 };
4618
4619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4621 if (SWIG_arg_fail(1)) SWIG_fail;
4622 {
4623 PyThreadState* __tstate = wxPyBeginAllowThreads();
4624 delete arg1;
4625
4626 wxPyEndAllowThreads(__tstate);
4627 if (PyErr_Occurred()) SWIG_fail;
4628 }
4629 Py_INCREF(Py_None); resultobj = Py_None;
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4637 PyObject *resultobj = NULL;
4638 wxPoint *arg1 = (wxPoint *) 0 ;
4639 wxPoint *arg2 = 0 ;
4640 bool result;
4641 wxPoint temp2 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 char *kwnames[] = {
4645 (char *) "self",(char *) "pt", NULL
4646 };
4647
4648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4650 if (SWIG_arg_fail(1)) SWIG_fail;
4651 {
4652 arg2 = &temp2;
4653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4654 }
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4658
4659 wxPyEndAllowThreads(__tstate);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 {
4663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4664 }
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = NULL;
4673 wxPoint *arg1 = (wxPoint *) 0 ;
4674 wxPoint *arg2 = 0 ;
4675 bool result;
4676 wxPoint temp2 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 char *kwnames[] = {
4680 (char *) "self",(char *) "pt", NULL
4681 };
4682
4683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4685 if (SWIG_arg_fail(1)) SWIG_fail;
4686 {
4687 arg2 = &temp2;
4688 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4689 }
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4693
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 {
4698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4699 }
4700 return resultobj;
4701 fail:
4702 return NULL;
4703 }
4704
4705
4706 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4707 PyObject *resultobj = NULL;
4708 wxPoint *arg1 = (wxPoint *) 0 ;
4709 wxPoint *arg2 = 0 ;
4710 wxPoint result;
4711 wxPoint temp2 ;
4712 PyObject * obj0 = 0 ;
4713 PyObject * obj1 = 0 ;
4714 char *kwnames[] = {
4715 (char *) "self",(char *) "pt", NULL
4716 };
4717
4718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4720 if (SWIG_arg_fail(1)) SWIG_fail;
4721 {
4722 arg2 = &temp2;
4723 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4724 }
4725 {
4726 PyThreadState* __tstate = wxPyBeginAllowThreads();
4727 result = (arg1)->operator +((wxPoint const &)*arg2);
4728
4729 wxPyEndAllowThreads(__tstate);
4730 if (PyErr_Occurred()) SWIG_fail;
4731 }
4732 {
4733 wxPoint * resultptr;
4734 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4735 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4736 }
4737 return resultobj;
4738 fail:
4739 return NULL;
4740 }
4741
4742
4743 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4744 PyObject *resultobj = NULL;
4745 wxPoint *arg1 = (wxPoint *) 0 ;
4746 wxPoint *arg2 = 0 ;
4747 wxPoint result;
4748 wxPoint temp2 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char *kwnames[] = {
4752 (char *) "self",(char *) "pt", NULL
4753 };
4754
4755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4757 if (SWIG_arg_fail(1)) SWIG_fail;
4758 {
4759 arg2 = &temp2;
4760 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4761 }
4762 {
4763 PyThreadState* __tstate = wxPyBeginAllowThreads();
4764 result = (arg1)->operator -((wxPoint const &)*arg2);
4765
4766 wxPyEndAllowThreads(__tstate);
4767 if (PyErr_Occurred()) SWIG_fail;
4768 }
4769 {
4770 wxPoint * resultptr;
4771 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4773 }
4774 return resultobj;
4775 fail:
4776 return NULL;
4777 }
4778
4779
4780 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4781 PyObject *resultobj = NULL;
4782 wxPoint *arg1 = (wxPoint *) 0 ;
4783 wxPoint *arg2 = 0 ;
4784 wxPoint *result;
4785 wxPoint temp2 ;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 char *kwnames[] = {
4789 (char *) "self",(char *) "pt", NULL
4790 };
4791
4792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4794 if (SWIG_arg_fail(1)) SWIG_fail;
4795 {
4796 arg2 = &temp2;
4797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4798 }
4799 {
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 {
4802 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4803 result = (wxPoint *) &_result_ref;
4804 }
4805
4806 wxPyEndAllowThreads(__tstate);
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4810 return resultobj;
4811 fail:
4812 return NULL;
4813 }
4814
4815
4816 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4817 PyObject *resultobj = NULL;
4818 wxPoint *arg1 = (wxPoint *) 0 ;
4819 wxPoint *arg2 = 0 ;
4820 wxPoint *result;
4821 wxPoint temp2 ;
4822 PyObject * obj0 = 0 ;
4823 PyObject * obj1 = 0 ;
4824 char *kwnames[] = {
4825 (char *) "self",(char *) "pt", NULL
4826 };
4827
4828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4830 if (SWIG_arg_fail(1)) SWIG_fail;
4831 {
4832 arg2 = &temp2;
4833 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4834 }
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 {
4838 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4839 result = (wxPoint *) &_result_ref;
4840 }
4841
4842 wxPyEndAllowThreads(__tstate);
4843 if (PyErr_Occurred()) SWIG_fail;
4844 }
4845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4846 return resultobj;
4847 fail:
4848 return NULL;
4849 }
4850
4851
4852 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4853 PyObject *resultobj = NULL;
4854 wxPoint *arg1 = (wxPoint *) 0 ;
4855 long arg2 ;
4856 long arg3 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 PyObject * obj2 = 0 ;
4860 char *kwnames[] = {
4861 (char *) "self",(char *) "x",(char *) "y", NULL
4862 };
4863
4864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4866 if (SWIG_arg_fail(1)) SWIG_fail;
4867 {
4868 arg2 = static_cast<long >(SWIG_As_long(obj1));
4869 if (SWIG_arg_fail(2)) SWIG_fail;
4870 }
4871 {
4872 arg3 = static_cast<long >(SWIG_As_long(obj2));
4873 if (SWIG_arg_fail(3)) SWIG_fail;
4874 }
4875 {
4876 PyThreadState* __tstate = wxPyBeginAllowThreads();
4877 wxPoint_Set(arg1,arg2,arg3);
4878
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 Py_INCREF(Py_None); resultobj = Py_None;
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj = NULL;
4891 wxPoint *arg1 = (wxPoint *) 0 ;
4892 PyObject *result;
4893 PyObject * obj0 = 0 ;
4894 char *kwnames[] = {
4895 (char *) "self", NULL
4896 };
4897
4898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4900 if (SWIG_arg_fail(1)) SWIG_fail;
4901 {
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 result = (PyObject *)wxPoint_Get(arg1);
4904
4905 wxPyEndAllowThreads(__tstate);
4906 if (PyErr_Occurred()) SWIG_fail;
4907 }
4908 resultobj = result;
4909 return resultobj;
4910 fail:
4911 return NULL;
4912 }
4913
4914
4915 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4916 PyObject *obj;
4917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4918 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4919 Py_INCREF(obj);
4920 return Py_BuildValue((char *)"");
4921 }
4922 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj = NULL;
4924 int arg1 = (int) 0 ;
4925 int arg2 = (int) 0 ;
4926 int arg3 = (int) 0 ;
4927 int arg4 = (int) 0 ;
4928 wxRect *result;
4929 PyObject * obj0 = 0 ;
4930 PyObject * obj1 = 0 ;
4931 PyObject * obj2 = 0 ;
4932 PyObject * obj3 = 0 ;
4933 char *kwnames[] = {
4934 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4935 };
4936
4937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4938 if (obj0) {
4939 {
4940 arg1 = static_cast<int >(SWIG_As_int(obj0));
4941 if (SWIG_arg_fail(1)) SWIG_fail;
4942 }
4943 }
4944 if (obj1) {
4945 {
4946 arg2 = static_cast<int >(SWIG_As_int(obj1));
4947 if (SWIG_arg_fail(2)) SWIG_fail;
4948 }
4949 }
4950 if (obj2) {
4951 {
4952 arg3 = static_cast<int >(SWIG_As_int(obj2));
4953 if (SWIG_arg_fail(3)) SWIG_fail;
4954 }
4955 }
4956 if (obj3) {
4957 {
4958 arg4 = static_cast<int >(SWIG_As_int(obj3));
4959 if (SWIG_arg_fail(4)) SWIG_fail;
4960 }
4961 }
4962 {
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4965
4966 wxPyEndAllowThreads(__tstate);
4967 if (PyErr_Occurred()) SWIG_fail;
4968 }
4969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4977 PyObject *resultobj = NULL;
4978 wxPoint *arg1 = 0 ;
4979 wxPoint *arg2 = 0 ;
4980 wxRect *result;
4981 wxPoint temp1 ;
4982 wxPoint temp2 ;
4983 PyObject * obj0 = 0 ;
4984 PyObject * obj1 = 0 ;
4985 char *kwnames[] = {
4986 (char *) "topLeft",(char *) "bottomRight", NULL
4987 };
4988
4989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4990 {
4991 arg1 = &temp1;
4992 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4993 }
4994 {
4995 arg2 = &temp2;
4996 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4997 }
4998 {
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
5001
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5006 return resultobj;
5007 fail:
5008 return NULL;
5009 }
5010
5011
5012 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5013 PyObject *resultobj = NULL;
5014 wxPoint *arg1 = 0 ;
5015 wxSize *arg2 = 0 ;
5016 wxRect *result;
5017 wxPoint temp1 ;
5018 wxSize temp2 ;
5019 PyObject * obj0 = 0 ;
5020 PyObject * obj1 = 0 ;
5021 char *kwnames[] = {
5022 (char *) "pos",(char *) "size", NULL
5023 };
5024
5025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5026 {
5027 arg1 = &temp1;
5028 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5029 }
5030 {
5031 arg2 = &temp2;
5032 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5033 }
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5037
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5042 return resultobj;
5043 fail:
5044 return NULL;
5045 }
5046
5047
5048 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5049 PyObject *resultobj = NULL;
5050 wxSize *arg1 = 0 ;
5051 wxRect *result;
5052 wxSize temp1 ;
5053 PyObject * obj0 = 0 ;
5054 char *kwnames[] = {
5055 (char *) "size", NULL
5056 };
5057
5058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5059 {
5060 arg1 = &temp1;
5061 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5062 }
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5066
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj = NULL;
5079 wxRect *arg1 = (wxRect *) 0 ;
5080 PyObject * obj0 = 0 ;
5081 char *kwnames[] = {
5082 (char *) "self", NULL
5083 };
5084
5085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5087 if (SWIG_arg_fail(1)) SWIG_fail;
5088 {
5089 PyThreadState* __tstate = wxPyBeginAllowThreads();
5090 delete arg1;
5091
5092 wxPyEndAllowThreads(__tstate);
5093 if (PyErr_Occurred()) SWIG_fail;
5094 }
5095 Py_INCREF(Py_None); resultobj = Py_None;
5096 return resultobj;
5097 fail:
5098 return NULL;
5099 }
5100
5101
5102 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5103 PyObject *resultobj = NULL;
5104 wxRect *arg1 = (wxRect *) 0 ;
5105 int result;
5106 PyObject * obj0 = 0 ;
5107 char *kwnames[] = {
5108 (char *) "self", NULL
5109 };
5110
5111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5113 if (SWIG_arg_fail(1)) SWIG_fail;
5114 {
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 result = (int)((wxRect const *)arg1)->GetX();
5117
5118 wxPyEndAllowThreads(__tstate);
5119 if (PyErr_Occurred()) SWIG_fail;
5120 }
5121 {
5122 resultobj = SWIG_From_int(static_cast<int >(result));
5123 }
5124 return resultobj;
5125 fail:
5126 return NULL;
5127 }
5128
5129
5130 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5131 PyObject *resultobj = NULL;
5132 wxRect *arg1 = (wxRect *) 0 ;
5133 int arg2 ;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 char *kwnames[] = {
5137 (char *) "self",(char *) "x", NULL
5138 };
5139
5140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5142 if (SWIG_arg_fail(1)) SWIG_fail;
5143 {
5144 arg2 = static_cast<int >(SWIG_As_int(obj1));
5145 if (SWIG_arg_fail(2)) SWIG_fail;
5146 }
5147 {
5148 PyThreadState* __tstate = wxPyBeginAllowThreads();
5149 (arg1)->SetX(arg2);
5150
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 Py_INCREF(Py_None); resultobj = Py_None;
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj = NULL;
5163 wxRect *arg1 = (wxRect *) 0 ;
5164 int result;
5165 PyObject * obj0 = 0 ;
5166 char *kwnames[] = {
5167 (char *) "self", NULL
5168 };
5169
5170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5172 if (SWIG_arg_fail(1)) SWIG_fail;
5173 {
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = (int)(arg1)->GetY();
5176
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 {
5181 resultobj = SWIG_From_int(static_cast<int >(result));
5182 }
5183 return resultobj;
5184 fail:
5185 return NULL;
5186 }
5187
5188
5189 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5190 PyObject *resultobj = NULL;
5191 wxRect *arg1 = (wxRect *) 0 ;
5192 int arg2 ;
5193 PyObject * obj0 = 0 ;
5194 PyObject * obj1 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self",(char *) "y", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5201 if (SWIG_arg_fail(1)) SWIG_fail;
5202 {
5203 arg2 = static_cast<int >(SWIG_As_int(obj1));
5204 if (SWIG_arg_fail(2)) SWIG_fail;
5205 }
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 (arg1)->SetY(arg2);
5209
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 Py_INCREF(Py_None); resultobj = Py_None;
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = NULL;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 int result;
5224 PyObject * obj0 = 0 ;
5225 char *kwnames[] = {
5226 (char *) "self", NULL
5227 };
5228
5229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5231 if (SWIG_arg_fail(1)) SWIG_fail;
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 result = (int)((wxRect const *)arg1)->GetWidth();
5235
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 {
5240 resultobj = SWIG_From_int(static_cast<int >(result));
5241 }
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5249 PyObject *resultobj = NULL;
5250 wxRect *arg1 = (wxRect *) 0 ;
5251 int arg2 ;
5252 PyObject * obj0 = 0 ;
5253 PyObject * obj1 = 0 ;
5254 char *kwnames[] = {
5255 (char *) "self",(char *) "w", NULL
5256 };
5257
5258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5260 if (SWIG_arg_fail(1)) SWIG_fail;
5261 {
5262 arg2 = static_cast<int >(SWIG_As_int(obj1));
5263 if (SWIG_arg_fail(2)) SWIG_fail;
5264 }
5265 {
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 (arg1)->SetWidth(arg2);
5268
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 Py_INCREF(Py_None); resultobj = Py_None;
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj = NULL;
5281 wxRect *arg1 = (wxRect *) 0 ;
5282 int result;
5283 PyObject * obj0 = 0 ;
5284 char *kwnames[] = {
5285 (char *) "self", NULL
5286 };
5287
5288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5290 if (SWIG_arg_fail(1)) SWIG_fail;
5291 {
5292 PyThreadState* __tstate = wxPyBeginAllowThreads();
5293 result = (int)((wxRect const *)arg1)->GetHeight();
5294
5295 wxPyEndAllowThreads(__tstate);
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 {
5299 resultobj = SWIG_From_int(static_cast<int >(result));
5300 }
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = NULL;
5309 wxRect *arg1 = (wxRect *) 0 ;
5310 int arg2 ;
5311 PyObject * obj0 = 0 ;
5312 PyObject * obj1 = 0 ;
5313 char *kwnames[] = {
5314 (char *) "self",(char *) "h", NULL
5315 };
5316
5317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5319 if (SWIG_arg_fail(1)) SWIG_fail;
5320 {
5321 arg2 = static_cast<int >(SWIG_As_int(obj1));
5322 if (SWIG_arg_fail(2)) SWIG_fail;
5323 }
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 (arg1)->SetHeight(arg2);
5327
5328 wxPyEndAllowThreads(__tstate);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 Py_INCREF(Py_None); resultobj = Py_None;
5332 return resultobj;
5333 fail:
5334 return NULL;
5335 }
5336
5337
5338 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5339 PyObject *resultobj = NULL;
5340 wxRect *arg1 = (wxRect *) 0 ;
5341 wxPoint result;
5342 PyObject * obj0 = 0 ;
5343 char *kwnames[] = {
5344 (char *) "self", NULL
5345 };
5346
5347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5349 if (SWIG_arg_fail(1)) SWIG_fail;
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 result = ((wxRect const *)arg1)->GetPosition();
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 {
5358 wxPoint * resultptr;
5359 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5361 }
5362 return resultobj;
5363 fail:
5364 return NULL;
5365 }
5366
5367
5368 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5369 PyObject *resultobj = NULL;
5370 wxRect *arg1 = (wxRect *) 0 ;
5371 wxPoint *arg2 = 0 ;
5372 wxPoint temp2 ;
5373 PyObject * obj0 = 0 ;
5374 PyObject * obj1 = 0 ;
5375 char *kwnames[] = {
5376 (char *) "self",(char *) "p", NULL
5377 };
5378
5379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5381 if (SWIG_arg_fail(1)) SWIG_fail;
5382 {
5383 arg2 = &temp2;
5384 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5385 }
5386 {
5387 PyThreadState* __tstate = wxPyBeginAllowThreads();
5388 (arg1)->SetPosition((wxPoint const &)*arg2);
5389
5390 wxPyEndAllowThreads(__tstate);
5391 if (PyErr_Occurred()) SWIG_fail;
5392 }
5393 Py_INCREF(Py_None); resultobj = Py_None;
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5401 PyObject *resultobj = NULL;
5402 wxRect *arg1 = (wxRect *) 0 ;
5403 wxSize result;
5404 PyObject * obj0 = 0 ;
5405 char *kwnames[] = {
5406 (char *) "self", NULL
5407 };
5408
5409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5411 if (SWIG_arg_fail(1)) SWIG_fail;
5412 {
5413 PyThreadState* __tstate = wxPyBeginAllowThreads();
5414 result = ((wxRect const *)arg1)->GetSize();
5415
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 wxSize * resultptr;
5421 resultptr = new wxSize(static_cast<wxSize & >(result));
5422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5423 }
5424 return resultobj;
5425 fail:
5426 return NULL;
5427 }
5428
5429
5430 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5431 PyObject *resultobj = NULL;
5432 wxRect *arg1 = (wxRect *) 0 ;
5433 wxSize *arg2 = 0 ;
5434 wxSize temp2 ;
5435 PyObject * obj0 = 0 ;
5436 PyObject * obj1 = 0 ;
5437 char *kwnames[] = {
5438 (char *) "self",(char *) "s", NULL
5439 };
5440
5441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5443 if (SWIG_arg_fail(1)) SWIG_fail;
5444 {
5445 arg2 = &temp2;
5446 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5447 }
5448 {
5449 PyThreadState* __tstate = wxPyBeginAllowThreads();
5450 (arg1)->SetSize((wxSize const &)*arg2);
5451
5452 wxPyEndAllowThreads(__tstate);
5453 if (PyErr_Occurred()) SWIG_fail;
5454 }
5455 Py_INCREF(Py_None); resultobj = Py_None;
5456 return resultobj;
5457 fail:
5458 return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj = NULL;
5464 wxRect *arg1 = (wxRect *) 0 ;
5465 bool result;
5466 PyObject * obj0 = 0 ;
5467 char *kwnames[] = {
5468 (char *) "self", NULL
5469 };
5470
5471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5473 if (SWIG_arg_fail(1)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 result = (bool)((wxRect const *)arg1)->IsEmpty();
5477
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 {
5482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5483 }
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5491 PyObject *resultobj = NULL;
5492 wxRect *arg1 = (wxRect *) 0 ;
5493 wxPoint result;
5494 PyObject * obj0 = 0 ;
5495 char *kwnames[] = {
5496 (char *) "self", NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5501 if (SWIG_arg_fail(1)) SWIG_fail;
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = ((wxRect const *)arg1)->GetTopLeft();
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 {
5510 wxPoint * resultptr;
5511 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5513 }
5514 return resultobj;
5515 fail:
5516 return NULL;
5517 }
5518
5519
5520 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5521 PyObject *resultobj = NULL;
5522 wxRect *arg1 = (wxRect *) 0 ;
5523 wxPoint *arg2 = 0 ;
5524 wxPoint temp2 ;
5525 PyObject * obj0 = 0 ;
5526 PyObject * obj1 = 0 ;
5527 char *kwnames[] = {
5528 (char *) "self",(char *) "p", NULL
5529 };
5530
5531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5533 if (SWIG_arg_fail(1)) SWIG_fail;
5534 {
5535 arg2 = &temp2;
5536 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5537 }
5538 {
5539 PyThreadState* __tstate = wxPyBeginAllowThreads();
5540 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5541
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 Py_INCREF(Py_None); resultobj = Py_None;
5546 return resultobj;
5547 fail:
5548 return NULL;
5549 }
5550
5551
5552 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5553 PyObject *resultobj = NULL;
5554 wxRect *arg1 = (wxRect *) 0 ;
5555 wxPoint result;
5556 PyObject * obj0 = 0 ;
5557 char *kwnames[] = {
5558 (char *) "self", NULL
5559 };
5560
5561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5563 if (SWIG_arg_fail(1)) SWIG_fail;
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = ((wxRect const *)arg1)->GetBottomRight();
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 {
5572 wxPoint * resultptr;
5573 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5575 }
5576 return resultobj;
5577 fail:
5578 return NULL;
5579 }
5580
5581
5582 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5583 PyObject *resultobj = NULL;
5584 wxRect *arg1 = (wxRect *) 0 ;
5585 wxPoint *arg2 = 0 ;
5586 wxPoint temp2 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char *kwnames[] = {
5590 (char *) "self",(char *) "p", NULL
5591 };
5592
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5595 if (SWIG_arg_fail(1)) SWIG_fail;
5596 {
5597 arg2 = &temp2;
5598 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 Py_INCREF(Py_None); resultobj = Py_None;
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj = NULL;
5616 wxRect *arg1 = (wxRect *) 0 ;
5617 int result;
5618 PyObject * obj0 = 0 ;
5619 char *kwnames[] = {
5620 (char *) "self", NULL
5621 };
5622
5623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5625 if (SWIG_arg_fail(1)) SWIG_fail;
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = (int)((wxRect const *)arg1)->GetLeft();
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 {
5634 resultobj = SWIG_From_int(static_cast<int >(result));
5635 }
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj = NULL;
5644 wxRect *arg1 = (wxRect *) 0 ;
5645 int result;
5646 PyObject * obj0 = 0 ;
5647 char *kwnames[] = {
5648 (char *) "self", NULL
5649 };
5650
5651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5653 if (SWIG_arg_fail(1)) SWIG_fail;
5654 {
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 result = (int)((wxRect const *)arg1)->GetTop();
5657
5658 wxPyEndAllowThreads(__tstate);
5659 if (PyErr_Occurred()) SWIG_fail;
5660 }
5661 {
5662 resultobj = SWIG_From_int(static_cast<int >(result));
5663 }
5664 return resultobj;
5665 fail:
5666 return NULL;
5667 }
5668
5669
5670 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5671 PyObject *resultobj = NULL;
5672 wxRect *arg1 = (wxRect *) 0 ;
5673 int result;
5674 PyObject * obj0 = 0 ;
5675 char *kwnames[] = {
5676 (char *) "self", NULL
5677 };
5678
5679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5681 if (SWIG_arg_fail(1)) SWIG_fail;
5682 {
5683 PyThreadState* __tstate = wxPyBeginAllowThreads();
5684 result = (int)((wxRect const *)arg1)->GetBottom();
5685
5686 wxPyEndAllowThreads(__tstate);
5687 if (PyErr_Occurred()) SWIG_fail;
5688 }
5689 {
5690 resultobj = SWIG_From_int(static_cast<int >(result));
5691 }
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj = NULL;
5700 wxRect *arg1 = (wxRect *) 0 ;
5701 int result;
5702 PyObject * obj0 = 0 ;
5703 char *kwnames[] = {
5704 (char *) "self", NULL
5705 };
5706
5707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5709 if (SWIG_arg_fail(1)) SWIG_fail;
5710 {
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 result = (int)((wxRect const *)arg1)->GetRight();
5713
5714 wxPyEndAllowThreads(__tstate);
5715 if (PyErr_Occurred()) SWIG_fail;
5716 }
5717 {
5718 resultobj = SWIG_From_int(static_cast<int >(result));
5719 }
5720 return resultobj;
5721 fail:
5722 return NULL;
5723 }
5724
5725
5726 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5727 PyObject *resultobj = NULL;
5728 wxRect *arg1 = (wxRect *) 0 ;
5729 int arg2 ;
5730 PyObject * obj0 = 0 ;
5731 PyObject * obj1 = 0 ;
5732 char *kwnames[] = {
5733 (char *) "self",(char *) "left", NULL
5734 };
5735
5736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5738 if (SWIG_arg_fail(1)) SWIG_fail;
5739 {
5740 arg2 = static_cast<int >(SWIG_As_int(obj1));
5741 if (SWIG_arg_fail(2)) SWIG_fail;
5742 }
5743 {
5744 PyThreadState* __tstate = wxPyBeginAllowThreads();
5745 (arg1)->SetLeft(arg2);
5746
5747 wxPyEndAllowThreads(__tstate);
5748 if (PyErr_Occurred()) SWIG_fail;
5749 }
5750 Py_INCREF(Py_None); resultobj = Py_None;
5751 return resultobj;
5752 fail:
5753 return NULL;
5754 }
5755
5756
5757 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5758 PyObject *resultobj = NULL;
5759 wxRect *arg1 = (wxRect *) 0 ;
5760 int arg2 ;
5761 PyObject * obj0 = 0 ;
5762 PyObject * obj1 = 0 ;
5763 char *kwnames[] = {
5764 (char *) "self",(char *) "right", NULL
5765 };
5766
5767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5769 if (SWIG_arg_fail(1)) SWIG_fail;
5770 {
5771 arg2 = static_cast<int >(SWIG_As_int(obj1));
5772 if (SWIG_arg_fail(2)) SWIG_fail;
5773 }
5774 {
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 (arg1)->SetRight(arg2);
5777
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 Py_INCREF(Py_None); resultobj = Py_None;
5782 return resultobj;
5783 fail:
5784 return NULL;
5785 }
5786
5787
5788 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5789 PyObject *resultobj = NULL;
5790 wxRect *arg1 = (wxRect *) 0 ;
5791 int arg2 ;
5792 PyObject * obj0 = 0 ;
5793 PyObject * obj1 = 0 ;
5794 char *kwnames[] = {
5795 (char *) "self",(char *) "top", NULL
5796 };
5797
5798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5800 if (SWIG_arg_fail(1)) SWIG_fail;
5801 {
5802 arg2 = static_cast<int >(SWIG_As_int(obj1));
5803 if (SWIG_arg_fail(2)) SWIG_fail;
5804 }
5805 {
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 (arg1)->SetTop(arg2);
5808
5809 wxPyEndAllowThreads(__tstate);
5810 if (PyErr_Occurred()) SWIG_fail;
5811 }
5812 Py_INCREF(Py_None); resultobj = Py_None;
5813 return resultobj;
5814 fail:
5815 return NULL;
5816 }
5817
5818
5819 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5820 PyObject *resultobj = NULL;
5821 wxRect *arg1 = (wxRect *) 0 ;
5822 int arg2 ;
5823 PyObject * obj0 = 0 ;
5824 PyObject * obj1 = 0 ;
5825 char *kwnames[] = {
5826 (char *) "self",(char *) "bottom", NULL
5827 };
5828
5829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5831 if (SWIG_arg_fail(1)) SWIG_fail;
5832 {
5833 arg2 = static_cast<int >(SWIG_As_int(obj1));
5834 if (SWIG_arg_fail(2)) SWIG_fail;
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 (arg1)->SetBottom(arg2);
5839
5840 wxPyEndAllowThreads(__tstate);
5841 if (PyErr_Occurred()) SWIG_fail;
5842 }
5843 Py_INCREF(Py_None); resultobj = Py_None;
5844 return resultobj;
5845 fail:
5846 return NULL;
5847 }
5848
5849
5850 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5851 PyObject *resultobj = NULL;
5852 wxRect *arg1 = (wxRect *) 0 ;
5853 int arg2 ;
5854 int arg3 ;
5855 wxRect *result;
5856 PyObject * obj0 = 0 ;
5857 PyObject * obj1 = 0 ;
5858 PyObject * obj2 = 0 ;
5859 char *kwnames[] = {
5860 (char *) "self",(char *) "dx",(char *) "dy", NULL
5861 };
5862
5863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5865 if (SWIG_arg_fail(1)) SWIG_fail;
5866 {
5867 arg2 = static_cast<int >(SWIG_As_int(obj1));
5868 if (SWIG_arg_fail(2)) SWIG_fail;
5869 }
5870 {
5871 arg3 = static_cast<int >(SWIG_As_int(obj2));
5872 if (SWIG_arg_fail(3)) SWIG_fail;
5873 }
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 {
5877 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5878 result = (wxRect *) &_result_ref;
5879 }
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5885 return resultobj;
5886 fail:
5887 return NULL;
5888 }
5889
5890
5891 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5892 PyObject *resultobj = NULL;
5893 wxRect *arg1 = (wxRect *) 0 ;
5894 int arg2 ;
5895 int arg3 ;
5896 wxRect *result;
5897 PyObject * obj0 = 0 ;
5898 PyObject * obj1 = 0 ;
5899 PyObject * obj2 = 0 ;
5900 char *kwnames[] = {
5901 (char *) "self",(char *) "dx",(char *) "dy", NULL
5902 };
5903
5904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5906 if (SWIG_arg_fail(1)) SWIG_fail;
5907 {
5908 arg2 = static_cast<int >(SWIG_As_int(obj1));
5909 if (SWIG_arg_fail(2)) SWIG_fail;
5910 }
5911 {
5912 arg3 = static_cast<int >(SWIG_As_int(obj2));
5913 if (SWIG_arg_fail(3)) SWIG_fail;
5914 }
5915 {
5916 PyThreadState* __tstate = wxPyBeginAllowThreads();
5917 {
5918 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5919 result = (wxRect *) &_result_ref;
5920 }
5921
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj = NULL;
5934 wxRect *arg1 = (wxRect *) 0 ;
5935 int arg2 ;
5936 int arg3 ;
5937 PyObject * obj0 = 0 ;
5938 PyObject * obj1 = 0 ;
5939 PyObject * obj2 = 0 ;
5940 char *kwnames[] = {
5941 (char *) "self",(char *) "dx",(char *) "dy", NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5946 if (SWIG_arg_fail(1)) SWIG_fail;
5947 {
5948 arg2 = static_cast<int >(SWIG_As_int(obj1));
5949 if (SWIG_arg_fail(2)) SWIG_fail;
5950 }
5951 {
5952 arg3 = static_cast<int >(SWIG_As_int(obj2));
5953 if (SWIG_arg_fail(3)) SWIG_fail;
5954 }
5955 {
5956 PyThreadState* __tstate = wxPyBeginAllowThreads();
5957 (arg1)->Offset(arg2,arg3);
5958
5959 wxPyEndAllowThreads(__tstate);
5960 if (PyErr_Occurred()) SWIG_fail;
5961 }
5962 Py_INCREF(Py_None); resultobj = Py_None;
5963 return resultobj;
5964 fail:
5965 return NULL;
5966 }
5967
5968
5969 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5970 PyObject *resultobj = NULL;
5971 wxRect *arg1 = (wxRect *) 0 ;
5972 wxPoint *arg2 = 0 ;
5973 wxPoint temp2 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 char *kwnames[] = {
5977 (char *) "self",(char *) "pt", NULL
5978 };
5979
5980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5982 if (SWIG_arg_fail(1)) SWIG_fail;
5983 {
5984 arg2 = &temp2;
5985 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5986 }
5987 {
5988 PyThreadState* __tstate = wxPyBeginAllowThreads();
5989 (arg1)->Offset((wxPoint const &)*arg2);
5990
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 Py_INCREF(Py_None); resultobj = Py_None;
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = NULL;
6003 wxRect *arg1 = (wxRect *) 0 ;
6004 wxRect *arg2 = 0 ;
6005 wxRect result;
6006 wxRect temp2 ;
6007 PyObject * obj0 = 0 ;
6008 PyObject * obj1 = 0 ;
6009 char *kwnames[] = {
6010 (char *) "self",(char *) "rect", NULL
6011 };
6012
6013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6015 if (SWIG_arg_fail(1)) SWIG_fail;
6016 {
6017 arg2 = &temp2;
6018 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6019 }
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = (arg1)->Intersect((wxRect const &)*arg2);
6023
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 {
6028 wxRect * resultptr;
6029 resultptr = new wxRect(static_cast<wxRect & >(result));
6030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6031 }
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj = NULL;
6040 wxRect *arg1 = (wxRect *) 0 ;
6041 wxRect *arg2 = 0 ;
6042 wxRect result;
6043 wxRect temp2 ;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 char *kwnames[] = {
6047 (char *) "self",(char *) "rect", NULL
6048 };
6049
6050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6052 if (SWIG_arg_fail(1)) SWIG_fail;
6053 {
6054 arg2 = &temp2;
6055 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6056 }
6057 {
6058 PyThreadState* __tstate = wxPyBeginAllowThreads();
6059 result = (arg1)->Union((wxRect const &)*arg2);
6060
6061 wxPyEndAllowThreads(__tstate);
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 {
6065 wxRect * resultptr;
6066 resultptr = new wxRect(static_cast<wxRect & >(result));
6067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6068 }
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj = NULL;
6077 wxRect *arg1 = (wxRect *) 0 ;
6078 wxRect *arg2 = 0 ;
6079 wxRect result;
6080 wxRect temp2 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "self",(char *) "rect", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 {
6091 arg2 = &temp2;
6092 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 wxRect * resultptr;
6103 resultptr = new wxRect(static_cast<wxRect & >(result));
6104 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6105 }
6106 return resultobj;
6107 fail:
6108 return NULL;
6109 }
6110
6111
6112 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6113 PyObject *resultobj = NULL;
6114 wxRect *arg1 = (wxRect *) 0 ;
6115 wxRect *arg2 = 0 ;
6116 wxRect *result;
6117 wxRect temp2 ;
6118 PyObject * obj0 = 0 ;
6119 PyObject * obj1 = 0 ;
6120 char *kwnames[] = {
6121 (char *) "self",(char *) "rect", NULL
6122 };
6123
6124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6126 if (SWIG_arg_fail(1)) SWIG_fail;
6127 {
6128 arg2 = &temp2;
6129 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6130 }
6131 {
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 {
6134 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6135 result = (wxRect *) &_result_ref;
6136 }
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj = NULL;
6150 wxRect *arg1 = (wxRect *) 0 ;
6151 wxRect *arg2 = 0 ;
6152 bool result;
6153 wxRect temp2 ;
6154 PyObject * obj0 = 0 ;
6155 PyObject * obj1 = 0 ;
6156 char *kwnames[] = {
6157 (char *) "self",(char *) "rect", NULL
6158 };
6159
6160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6162 if (SWIG_arg_fail(1)) SWIG_fail;
6163 {
6164 arg2 = &temp2;
6165 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6166 }
6167 {
6168 PyThreadState* __tstate = wxPyBeginAllowThreads();
6169 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6170
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 {
6175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6176 }
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = NULL;
6185 wxRect *arg1 = (wxRect *) 0 ;
6186 wxRect *arg2 = 0 ;
6187 bool result;
6188 wxRect temp2 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "self",(char *) "rect", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6197 if (SWIG_arg_fail(1)) SWIG_fail;
6198 {
6199 arg2 = &temp2;
6200 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6201 }
6202 {
6203 PyThreadState* __tstate = wxPyBeginAllowThreads();
6204 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6205
6206 wxPyEndAllowThreads(__tstate);
6207 if (PyErr_Occurred()) SWIG_fail;
6208 }
6209 {
6210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6211 }
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6219 PyObject *resultobj = NULL;
6220 wxRect *arg1 = (wxRect *) 0 ;
6221 int arg2 ;
6222 int arg3 ;
6223 bool result;
6224 PyObject * obj0 = 0 ;
6225 PyObject * obj1 = 0 ;
6226 PyObject * obj2 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "self",(char *) "x",(char *) "y", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6233 if (SWIG_arg_fail(1)) SWIG_fail;
6234 {
6235 arg2 = static_cast<int >(SWIG_As_int(obj1));
6236 if (SWIG_arg_fail(2)) SWIG_fail;
6237 }
6238 {
6239 arg3 = static_cast<int >(SWIG_As_int(obj2));
6240 if (SWIG_arg_fail(3)) SWIG_fail;
6241 }
6242 {
6243 PyThreadState* __tstate = wxPyBeginAllowThreads();
6244 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6245
6246 wxPyEndAllowThreads(__tstate);
6247 if (PyErr_Occurred()) SWIG_fail;
6248 }
6249 {
6250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6251 }
6252 return resultobj;
6253 fail:
6254 return NULL;
6255 }
6256
6257
6258 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6259 PyObject *resultobj = NULL;
6260 wxRect *arg1 = (wxRect *) 0 ;
6261 wxPoint *arg2 = 0 ;
6262 bool result;
6263 wxPoint temp2 ;
6264 PyObject * obj0 = 0 ;
6265 PyObject * obj1 = 0 ;
6266 char *kwnames[] = {
6267 (char *) "self",(char *) "pt", NULL
6268 };
6269
6270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6272 if (SWIG_arg_fail(1)) SWIG_fail;
6273 {
6274 arg2 = &temp2;
6275 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6276 }
6277 {
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6280
6281 wxPyEndAllowThreads(__tstate);
6282 if (PyErr_Occurred()) SWIG_fail;
6283 }
6284 {
6285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6286 }
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj = NULL;
6295 wxRect *arg1 = (wxRect *) 0 ;
6296 wxRect *arg2 = 0 ;
6297 bool result;
6298 wxRect temp2 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char *kwnames[] = {
6302 (char *) "self",(char *) "rect", NULL
6303 };
6304
6305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 {
6309 arg2 = &temp2;
6310 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6311 }
6312 {
6313 PyThreadState* __tstate = wxPyBeginAllowThreads();
6314 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6315
6316 wxPyEndAllowThreads(__tstate);
6317 if (PyErr_Occurred()) SWIG_fail;
6318 }
6319 {
6320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6321 }
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 static PyObject *_wrap_Rect_CenterIn(PyObject *, PyObject *args, PyObject *kwargs) {
6329 PyObject *resultobj = NULL;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 wxRect *arg2 = 0 ;
6332 int arg3 = (int) wxBOTH ;
6333 wxRect result;
6334 wxRect temp2 ;
6335 PyObject * obj0 = 0 ;
6336 PyObject * obj1 = 0 ;
6337 PyObject * obj2 = 0 ;
6338 char *kwnames[] = {
6339 (char *) "self",(char *) "r",(char *) "dir", NULL
6340 };
6341
6342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) goto fail;
6343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6344 if (SWIG_arg_fail(1)) SWIG_fail;
6345 {
6346 arg2 = &temp2;
6347 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6348 }
6349 if (obj2) {
6350 {
6351 arg3 = static_cast<int >(SWIG_As_int(obj2));
6352 if (SWIG_arg_fail(3)) SWIG_fail;
6353 }
6354 }
6355 {
6356 PyThreadState* __tstate = wxPyBeginAllowThreads();
6357 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
6358
6359 wxPyEndAllowThreads(__tstate);
6360 if (PyErr_Occurred()) SWIG_fail;
6361 }
6362 {
6363 wxRect * resultptr;
6364 resultptr = new wxRect(static_cast<wxRect & >(result));
6365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6366 }
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6374 PyObject *resultobj = NULL;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 int arg2 ;
6377 PyObject * obj0 = 0 ;
6378 PyObject * obj1 = 0 ;
6379 char *kwnames[] = {
6380 (char *) "self",(char *) "x", NULL
6381 };
6382
6383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6385 if (SWIG_arg_fail(1)) SWIG_fail;
6386 {
6387 arg2 = static_cast<int >(SWIG_As_int(obj1));
6388 if (SWIG_arg_fail(2)) SWIG_fail;
6389 }
6390 if (arg1) (arg1)->x = arg2;
6391
6392 Py_INCREF(Py_None); resultobj = Py_None;
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj = NULL;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 int result;
6403 PyObject * obj0 = 0 ;
6404 char *kwnames[] = {
6405 (char *) "self", NULL
6406 };
6407
6408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6410 if (SWIG_arg_fail(1)) SWIG_fail;
6411 result = (int) ((arg1)->x);
6412
6413 {
6414 resultobj = SWIG_From_int(static_cast<int >(result));
6415 }
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj = NULL;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 int arg2 ;
6426 PyObject * obj0 = 0 ;
6427 PyObject * obj1 = 0 ;
6428 char *kwnames[] = {
6429 (char *) "self",(char *) "y", NULL
6430 };
6431
6432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6434 if (SWIG_arg_fail(1)) SWIG_fail;
6435 {
6436 arg2 = static_cast<int >(SWIG_As_int(obj1));
6437 if (SWIG_arg_fail(2)) SWIG_fail;
6438 }
6439 if (arg1) (arg1)->y = arg2;
6440
6441 Py_INCREF(Py_None); resultobj = Py_None;
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6449 PyObject *resultobj = NULL;
6450 wxRect *arg1 = (wxRect *) 0 ;
6451 int result;
6452 PyObject * obj0 = 0 ;
6453 char *kwnames[] = {
6454 (char *) "self", NULL
6455 };
6456
6457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6459 if (SWIG_arg_fail(1)) SWIG_fail;
6460 result = (int) ((arg1)->y);
6461
6462 {
6463 resultobj = SWIG_From_int(static_cast<int >(result));
6464 }
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj = NULL;
6473 wxRect *arg1 = (wxRect *) 0 ;
6474 int arg2 ;
6475 PyObject * obj0 = 0 ;
6476 PyObject * obj1 = 0 ;
6477 char *kwnames[] = {
6478 (char *) "self",(char *) "width", NULL
6479 };
6480
6481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6483 if (SWIG_arg_fail(1)) SWIG_fail;
6484 {
6485 arg2 = static_cast<int >(SWIG_As_int(obj1));
6486 if (SWIG_arg_fail(2)) SWIG_fail;
6487 }
6488 if (arg1) (arg1)->width = arg2;
6489
6490 Py_INCREF(Py_None); resultobj = Py_None;
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj = NULL;
6499 wxRect *arg1 = (wxRect *) 0 ;
6500 int result;
6501 PyObject * obj0 = 0 ;
6502 char *kwnames[] = {
6503 (char *) "self", NULL
6504 };
6505
6506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6508 if (SWIG_arg_fail(1)) SWIG_fail;
6509 result = (int) ((arg1)->width);
6510
6511 {
6512 resultobj = SWIG_From_int(static_cast<int >(result));
6513 }
6514 return resultobj;
6515 fail:
6516 return NULL;
6517 }
6518
6519
6520 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6521 PyObject *resultobj = NULL;
6522 wxRect *arg1 = (wxRect *) 0 ;
6523 int arg2 ;
6524 PyObject * obj0 = 0 ;
6525 PyObject * obj1 = 0 ;
6526 char *kwnames[] = {
6527 (char *) "self",(char *) "height", NULL
6528 };
6529
6530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6532 if (SWIG_arg_fail(1)) SWIG_fail;
6533 {
6534 arg2 = static_cast<int >(SWIG_As_int(obj1));
6535 if (SWIG_arg_fail(2)) SWIG_fail;
6536 }
6537 if (arg1) (arg1)->height = arg2;
6538
6539 Py_INCREF(Py_None); resultobj = Py_None;
6540 return resultobj;
6541 fail:
6542 return NULL;
6543 }
6544
6545
6546 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6547 PyObject *resultobj = NULL;
6548 wxRect *arg1 = (wxRect *) 0 ;
6549 int result;
6550 PyObject * obj0 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "self", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6557 if (SWIG_arg_fail(1)) SWIG_fail;
6558 result = (int) ((arg1)->height);
6559
6560 {
6561 resultobj = SWIG_From_int(static_cast<int >(result));
6562 }
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj = NULL;
6571 wxRect *arg1 = (wxRect *) 0 ;
6572 int arg2 = (int) 0 ;
6573 int arg3 = (int) 0 ;
6574 int arg4 = (int) 0 ;
6575 int arg5 = (int) 0 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 PyObject * obj2 = 0 ;
6579 PyObject * obj3 = 0 ;
6580 PyObject * obj4 = 0 ;
6581 char *kwnames[] = {
6582 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6583 };
6584
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6587 if (SWIG_arg_fail(1)) SWIG_fail;
6588 if (obj1) {
6589 {
6590 arg2 = static_cast<int >(SWIG_As_int(obj1));
6591 if (SWIG_arg_fail(2)) SWIG_fail;
6592 }
6593 }
6594 if (obj2) {
6595 {
6596 arg3 = static_cast<int >(SWIG_As_int(obj2));
6597 if (SWIG_arg_fail(3)) SWIG_fail;
6598 }
6599 }
6600 if (obj3) {
6601 {
6602 arg4 = static_cast<int >(SWIG_As_int(obj3));
6603 if (SWIG_arg_fail(4)) SWIG_fail;
6604 }
6605 }
6606 if (obj4) {
6607 {
6608 arg5 = static_cast<int >(SWIG_As_int(obj4));
6609 if (SWIG_arg_fail(5)) SWIG_fail;
6610 }
6611 }
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6615
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 Py_INCREF(Py_None); resultobj = Py_None;
6620 return resultobj;
6621 fail:
6622 return NULL;
6623 }
6624
6625
6626 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6627 PyObject *resultobj = NULL;
6628 wxRect *arg1 = (wxRect *) 0 ;
6629 PyObject *result;
6630 PyObject * obj0 = 0 ;
6631 char *kwnames[] = {
6632 (char *) "self", NULL
6633 };
6634
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 result = (PyObject *)wxRect_Get(arg1);
6641
6642 wxPyEndAllowThreads(__tstate);
6643 if (PyErr_Occurred()) SWIG_fail;
6644 }
6645 resultobj = result;
6646 return resultobj;
6647 fail:
6648 return NULL;
6649 }
6650
6651
6652 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6653 PyObject *obj;
6654 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6655 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6656 Py_INCREF(obj);
6657 return Py_BuildValue((char *)"");
6658 }
6659 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6660 PyObject *resultobj = NULL;
6661 wxRect *arg1 = (wxRect *) 0 ;
6662 wxRect *arg2 = (wxRect *) 0 ;
6663 PyObject *result;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 char *kwnames[] = {
6667 (char *) "r1",(char *) "r2", NULL
6668 };
6669
6670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6672 if (SWIG_arg_fail(1)) SWIG_fail;
6673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(2)) SWIG_fail;
6675 {
6676 if (!wxPyCheckForApp()) SWIG_fail;
6677 PyThreadState* __tstate = wxPyBeginAllowThreads();
6678 result = (PyObject *)wxIntersectRect(arg1,arg2);
6679
6680 wxPyEndAllowThreads(__tstate);
6681 if (PyErr_Occurred()) SWIG_fail;
6682 }
6683 resultobj = result;
6684 return resultobj;
6685 fail:
6686 return NULL;
6687 }
6688
6689
6690 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6691 PyObject *resultobj = NULL;
6692 double arg1 = (double) 0.0 ;
6693 double arg2 = (double) 0.0 ;
6694 wxPoint2D *result;
6695 PyObject * obj0 = 0 ;
6696 PyObject * obj1 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "x",(char *) "y", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6702 if (obj0) {
6703 {
6704 arg1 = static_cast<double >(SWIG_As_double(obj0));
6705 if (SWIG_arg_fail(1)) SWIG_fail;
6706 }
6707 }
6708 if (obj1) {
6709 {
6710 arg2 = static_cast<double >(SWIG_As_double(obj1));
6711 if (SWIG_arg_fail(2)) SWIG_fail;
6712 }
6713 }
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6717
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = NULL;
6730 wxPoint2D *arg1 = 0 ;
6731 wxPoint2D *result;
6732 wxPoint2D temp1 ;
6733 PyObject * obj0 = 0 ;
6734 char *kwnames[] = {
6735 (char *) "pt", NULL
6736 };
6737
6738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6739 {
6740 arg1 = &temp1;
6741 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6746
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6758 PyObject *resultobj = NULL;
6759 wxPoint *arg1 = 0 ;
6760 wxPoint2D *result;
6761 wxPoint temp1 ;
6762 PyObject * obj0 = 0 ;
6763 char *kwnames[] = {
6764 (char *) "pt", NULL
6765 };
6766
6767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6768 {
6769 arg1 = &temp1;
6770 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6771 }
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6775
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6780 return resultobj;
6781 fail:
6782 return NULL;
6783 }
6784
6785
6786 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6787 PyObject *resultobj = NULL;
6788 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6789 int *arg2 = (int *) 0 ;
6790 int *arg3 = (int *) 0 ;
6791 int temp2 ;
6792 int res2 = 0 ;
6793 int temp3 ;
6794 int res3 = 0 ;
6795 PyObject * obj0 = 0 ;
6796 char *kwnames[] = {
6797 (char *) "self", NULL
6798 };
6799
6800 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6801 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6804 if (SWIG_arg_fail(1)) SWIG_fail;
6805 {
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6808
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 Py_INCREF(Py_None); resultobj = Py_None;
6813 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6814 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6815 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6816 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj = NULL;
6825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6826 int *arg2 = (int *) 0 ;
6827 int *arg3 = (int *) 0 ;
6828 int temp2 ;
6829 int res2 = 0 ;
6830 int temp3 ;
6831 int res3 = 0 ;
6832 PyObject * obj0 = 0 ;
6833 char *kwnames[] = {
6834 (char *) "self", NULL
6835 };
6836
6837 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6838 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6841 if (SWIG_arg_fail(1)) SWIG_fail;
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 Py_INCREF(Py_None); resultobj = Py_None;
6850 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6851 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6852 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6853 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6861 PyObject *resultobj = NULL;
6862 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6863 double result;
6864 PyObject * obj0 = 0 ;
6865 char *kwnames[] = {
6866 (char *) "self", NULL
6867 };
6868
6869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6871 if (SWIG_arg_fail(1)) SWIG_fail;
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6875
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 {
6880 resultobj = SWIG_From_double(static_cast<double >(result));
6881 }
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6889 PyObject *resultobj = NULL;
6890 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6891 double result;
6892 PyObject * obj0 = 0 ;
6893 char *kwnames[] = {
6894 (char *) "self", NULL
6895 };
6896
6897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6899 if (SWIG_arg_fail(1)) SWIG_fail;
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6903
6904 wxPyEndAllowThreads(__tstate);
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 {
6908 resultobj = SWIG_From_double(static_cast<double >(result));
6909 }
6910 return resultobj;
6911 fail:
6912 return NULL;
6913 }
6914
6915
6916 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6917 PyObject *resultobj = NULL;
6918 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6919 double arg2 ;
6920 PyObject * obj0 = 0 ;
6921 PyObject * obj1 = 0 ;
6922 char *kwnames[] = {
6923 (char *) "self",(char *) "length", NULL
6924 };
6925
6926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6928 if (SWIG_arg_fail(1)) SWIG_fail;
6929 {
6930 arg2 = static_cast<double >(SWIG_As_double(obj1));
6931 if (SWIG_arg_fail(2)) SWIG_fail;
6932 }
6933 {
6934 PyThreadState* __tstate = wxPyBeginAllowThreads();
6935 (arg1)->SetVectorLength(arg2);
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 Py_INCREF(Py_None); resultobj = Py_None;
6941 return resultobj;
6942 fail:
6943 return NULL;
6944 }
6945
6946
6947 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6948 PyObject *resultobj = NULL;
6949 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6950 double arg2 ;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self",(char *) "degrees", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 arg2 = static_cast<double >(SWIG_As_double(obj1));
6962 if (SWIG_arg_fail(2)) SWIG_fail;
6963 }
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 (arg1)->SetVectorAngle(arg2);
6967
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 Py_INCREF(Py_None); resultobj = Py_None;
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = NULL;
6980 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6981 wxPoint2D *arg2 = 0 ;
6982 double result;
6983 wxPoint2D temp2 ;
6984 PyObject * obj0 = 0 ;
6985 PyObject * obj1 = 0 ;
6986 char *kwnames[] = {
6987 (char *) "self",(char *) "pt", NULL
6988 };
6989
6990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6992 if (SWIG_arg_fail(1)) SWIG_fail;
6993 {
6994 arg2 = &temp2;
6995 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6996 }
6997 {
6998 PyThreadState* __tstate = wxPyBeginAllowThreads();
6999 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
7000
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 {
7005 resultobj = SWIG_From_double(static_cast<double >(result));
7006 }
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
7014 PyObject *resultobj = NULL;
7015 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7016 wxPoint2D *arg2 = 0 ;
7017 double result;
7018 wxPoint2D temp2 ;
7019 PyObject * obj0 = 0 ;
7020 PyObject * obj1 = 0 ;
7021 char *kwnames[] = {
7022 (char *) "self",(char *) "pt", NULL
7023 };
7024
7025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
7026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7027 if (SWIG_arg_fail(1)) SWIG_fail;
7028 {
7029 arg2 = &temp2;
7030 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7031 }
7032 {
7033 PyThreadState* __tstate = wxPyBeginAllowThreads();
7034 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
7035
7036 wxPyEndAllowThreads(__tstate);
7037 if (PyErr_Occurred()) SWIG_fail;
7038 }
7039 {
7040 resultobj = SWIG_From_double(static_cast<double >(result));
7041 }
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj = NULL;
7050 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7051 wxPoint2D *arg2 = 0 ;
7052 double result;
7053 wxPoint2D temp2 ;
7054 PyObject * obj0 = 0 ;
7055 PyObject * obj1 = 0 ;
7056 char *kwnames[] = {
7057 (char *) "self",(char *) "vec", NULL
7058 };
7059
7060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7062 if (SWIG_arg_fail(1)) SWIG_fail;
7063 {
7064 arg2 = &temp2;
7065 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7066 }
7067 {
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7070
7071 wxPyEndAllowThreads(__tstate);
7072 if (PyErr_Occurred()) SWIG_fail;
7073 }
7074 {
7075 resultobj = SWIG_From_double(static_cast<double >(result));
7076 }
7077 return resultobj;
7078 fail:
7079 return NULL;
7080 }
7081
7082
7083 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj = NULL;
7085 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7086 wxPoint2D *arg2 = 0 ;
7087 double result;
7088 wxPoint2D temp2 ;
7089 PyObject * obj0 = 0 ;
7090 PyObject * obj1 = 0 ;
7091 char *kwnames[] = {
7092 (char *) "self",(char *) "vec", NULL
7093 };
7094
7095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7097 if (SWIG_arg_fail(1)) SWIG_fail;
7098 {
7099 arg2 = &temp2;
7100 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7101 }
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7105
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 resultobj = SWIG_From_double(static_cast<double >(result));
7111 }
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj = NULL;
7120 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7121 wxPoint2D result;
7122 PyObject * obj0 = 0 ;
7123 char *kwnames[] = {
7124 (char *) "self", NULL
7125 };
7126
7127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7129 if (SWIG_arg_fail(1)) SWIG_fail;
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (arg1)->operator -();
7133
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 {
7138 wxPoint2D * resultptr;
7139 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7140 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7141 }
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = NULL;
7150 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7151 wxPoint2D *arg2 = 0 ;
7152 wxPoint2D *result;
7153 wxPoint2D temp2 ;
7154 PyObject * obj0 = 0 ;
7155 PyObject * obj1 = 0 ;
7156 char *kwnames[] = {
7157 (char *) "self",(char *) "pt", NULL
7158 };
7159
7160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7162 if (SWIG_arg_fail(1)) SWIG_fail;
7163 {
7164 arg2 = &temp2;
7165 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7166 }
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 {
7170 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7171 result = (wxPoint2D *) &_result_ref;
7172 }
7173
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = NULL;
7186 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7187 wxPoint2D *arg2 = 0 ;
7188 wxPoint2D *result;
7189 wxPoint2D temp2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char *kwnames[] = {
7193 (char *) "self",(char *) "pt", NULL
7194 };
7195
7196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7198 if (SWIG_arg_fail(1)) SWIG_fail;
7199 {
7200 arg2 = &temp2;
7201 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7202 }
7203 {
7204 PyThreadState* __tstate = wxPyBeginAllowThreads();
7205 {
7206 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7207 result = (wxPoint2D *) &_result_ref;
7208 }
7209
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = NULL;
7222 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7223 wxPoint2D *arg2 = 0 ;
7224 wxPoint2D *result;
7225 wxPoint2D temp2 ;
7226 PyObject * obj0 = 0 ;
7227 PyObject * obj1 = 0 ;
7228 char *kwnames[] = {
7229 (char *) "self",(char *) "pt", NULL
7230 };
7231
7232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7234 if (SWIG_arg_fail(1)) SWIG_fail;
7235 {
7236 arg2 = &temp2;
7237 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7238 }
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 {
7242 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7243 result = (wxPoint2D *) &_result_ref;
7244 }
7245
7246 wxPyEndAllowThreads(__tstate);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = NULL;
7258 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7259 wxPoint2D *arg2 = 0 ;
7260 wxPoint2D *result;
7261 wxPoint2D temp2 ;
7262 PyObject * obj0 = 0 ;
7263 PyObject * obj1 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self",(char *) "pt", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 {
7272 arg2 = &temp2;
7273 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7274 }
7275 {
7276 PyThreadState* __tstate = wxPyBeginAllowThreads();
7277 {
7278 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7279 result = (wxPoint2D *) &_result_ref;
7280 }
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj = NULL;
7294 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7295 wxPoint2D *arg2 = 0 ;
7296 bool result;
7297 wxPoint2D temp2 ;
7298 PyObject * obj0 = 0 ;
7299 PyObject * obj1 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "self",(char *) "pt", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7306 if (SWIG_arg_fail(1)) SWIG_fail;
7307 {
7308 arg2 = &temp2;
7309 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7310 }
7311 {
7312 PyThreadState* __tstate = wxPyBeginAllowThreads();
7313 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7314
7315 wxPyEndAllowThreads(__tstate);
7316 if (PyErr_Occurred()) SWIG_fail;
7317 }
7318 {
7319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7320 }
7321 return resultobj;
7322 fail:
7323 return NULL;
7324 }
7325
7326
7327 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7328 PyObject *resultobj = NULL;
7329 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7330 wxPoint2D *arg2 = 0 ;
7331 bool result;
7332 wxPoint2D temp2 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self",(char *) "pt", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 {
7343 arg2 = &temp2;
7344 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7345 }
7346 {
7347 PyThreadState* __tstate = wxPyBeginAllowThreads();
7348 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7349
7350 wxPyEndAllowThreads(__tstate);
7351 if (PyErr_Occurred()) SWIG_fail;
7352 }
7353 {
7354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7355 }
7356 return resultobj;
7357 fail:
7358 return NULL;
7359 }
7360
7361
7362 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7363 PyObject *resultobj = NULL;
7364 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7365 double arg2 ;
7366 PyObject * obj0 = 0 ;
7367 PyObject * obj1 = 0 ;
7368 char *kwnames[] = {
7369 (char *) "self",(char *) "m_x", NULL
7370 };
7371
7372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7374 if (SWIG_arg_fail(1)) SWIG_fail;
7375 {
7376 arg2 = static_cast<double >(SWIG_As_double(obj1));
7377 if (SWIG_arg_fail(2)) SWIG_fail;
7378 }
7379 if (arg1) (arg1)->m_x = arg2;
7380
7381 Py_INCREF(Py_None); resultobj = Py_None;
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = NULL;
7390 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7391 double result;
7392 PyObject * obj0 = 0 ;
7393 char *kwnames[] = {
7394 (char *) "self", NULL
7395 };
7396
7397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7399 if (SWIG_arg_fail(1)) SWIG_fail;
7400 result = (double) ((arg1)->m_x);
7401
7402 {
7403 resultobj = SWIG_From_double(static_cast<double >(result));
7404 }
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7412 PyObject *resultobj = NULL;
7413 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7414 double arg2 ;
7415 PyObject * obj0 = 0 ;
7416 PyObject * obj1 = 0 ;
7417 char *kwnames[] = {
7418 (char *) "self",(char *) "m_y", NULL
7419 };
7420
7421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7423 if (SWIG_arg_fail(1)) SWIG_fail;
7424 {
7425 arg2 = static_cast<double >(SWIG_As_double(obj1));
7426 if (SWIG_arg_fail(2)) SWIG_fail;
7427 }
7428 if (arg1) (arg1)->m_y = arg2;
7429
7430 Py_INCREF(Py_None); resultobj = Py_None;
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj = NULL;
7439 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7440 double result;
7441 PyObject * obj0 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 result = (double) ((arg1)->m_y);
7450
7451 {
7452 resultobj = SWIG_From_double(static_cast<double >(result));
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj = NULL;
7462 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7463 double arg2 = (double) 0 ;
7464 double arg3 = (double) 0 ;
7465 PyObject * obj0 = 0 ;
7466 PyObject * obj1 = 0 ;
7467 PyObject * obj2 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self",(char *) "x",(char *) "y", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 if (obj1) {
7476 {
7477 arg2 = static_cast<double >(SWIG_As_double(obj1));
7478 if (SWIG_arg_fail(2)) SWIG_fail;
7479 }
7480 }
7481 if (obj2) {
7482 {
7483 arg3 = static_cast<double >(SWIG_As_double(obj2));
7484 if (SWIG_arg_fail(3)) SWIG_fail;
7485 }
7486 }
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 wxPoint2D_Set(arg1,arg2,arg3);
7490
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 Py_INCREF(Py_None); resultobj = Py_None;
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj = NULL;
7503 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7504 PyObject *result;
7505 PyObject * obj0 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (PyObject *)wxPoint2D_Get(arg1);
7516
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 resultobj = result;
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7528 PyObject *obj;
7529 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7530 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7531 Py_INCREF(obj);
7532 return Py_BuildValue((char *)"");
7533 }
7534 static int _wrap_DefaultPosition_set(PyObject *) {
7535 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7536 return 1;
7537 }
7538
7539
7540 static PyObject *_wrap_DefaultPosition_get(void) {
7541 PyObject *pyobj = NULL;
7542
7543 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7544 return pyobj;
7545 }
7546
7547
7548 static int _wrap_DefaultSize_set(PyObject *) {
7549 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7550 return 1;
7551 }
7552
7553
7554 static PyObject *_wrap_DefaultSize_get(void) {
7555 PyObject *pyobj = NULL;
7556
7557 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7558 return pyobj;
7559 }
7560
7561
7562 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj = NULL;
7564 PyObject *arg1 = (PyObject *) 0 ;
7565 wxPyInputStream *result;
7566 PyObject * obj0 = 0 ;
7567 char *kwnames[] = {
7568 (char *) "p", NULL
7569 };
7570
7571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7572 arg1 = obj0;
7573 {
7574 PyThreadState* __tstate = wxPyBeginAllowThreads();
7575 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7576
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj = NULL;
7589 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7590 PyObject * obj0 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 PyThreadState* __tstate = wxPyBeginAllowThreads();
7600 delete arg1;
7601
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 Py_INCREF(Py_None); resultobj = Py_None;
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = NULL;
7614 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7615 PyObject * obj0 = 0 ;
7616 char *kwnames[] = {
7617 (char *) "self", NULL
7618 };
7619
7620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7622 if (SWIG_arg_fail(1)) SWIG_fail;
7623 {
7624 PyThreadState* __tstate = wxPyBeginAllowThreads();
7625 (arg1)->close();
7626
7627 wxPyEndAllowThreads(__tstate);
7628 if (PyErr_Occurred()) SWIG_fail;
7629 }
7630 Py_INCREF(Py_None); resultobj = Py_None;
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7638 PyObject *resultobj = NULL;
7639 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7640 PyObject * obj0 = 0 ;
7641 char *kwnames[] = {
7642 (char *) "self", NULL
7643 };
7644
7645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7647 if (SWIG_arg_fail(1)) SWIG_fail;
7648 {
7649 PyThreadState* __tstate = wxPyBeginAllowThreads();
7650 (arg1)->flush();
7651
7652 wxPyEndAllowThreads(__tstate);
7653 if (PyErr_Occurred()) SWIG_fail;
7654 }
7655 Py_INCREF(Py_None); resultobj = Py_None;
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = NULL;
7664 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7665 bool result;
7666 PyObject * obj0 = 0 ;
7667 char *kwnames[] = {
7668 (char *) "self", NULL
7669 };
7670
7671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7673 if (SWIG_arg_fail(1)) SWIG_fail;
7674 {
7675 PyThreadState* __tstate = wxPyBeginAllowThreads();
7676 result = (bool)(arg1)->eof();
7677
7678 wxPyEndAllowThreads(__tstate);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 {
7682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj = NULL;
7692 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7693 int arg2 = (int) -1 ;
7694 PyObject *result;
7695 PyObject * obj0 = 0 ;
7696 PyObject * obj1 = 0 ;
7697 char *kwnames[] = {
7698 (char *) "self",(char *) "size", NULL
7699 };
7700
7701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7703 if (SWIG_arg_fail(1)) SWIG_fail;
7704 if (obj1) {
7705 {
7706 arg2 = static_cast<int >(SWIG_As_int(obj1));
7707 if (SWIG_arg_fail(2)) SWIG_fail;
7708 }
7709 }
7710 {
7711 PyThreadState* __tstate = wxPyBeginAllowThreads();
7712 result = (PyObject *)(arg1)->read(arg2);
7713
7714 wxPyEndAllowThreads(__tstate);
7715 if (PyErr_Occurred()) SWIG_fail;
7716 }
7717 resultobj = result;
7718 return resultobj;
7719 fail:
7720 return NULL;
7721 }
7722
7723
7724 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7725 PyObject *resultobj = NULL;
7726 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7727 int arg2 = (int) -1 ;
7728 PyObject *result;
7729 PyObject * obj0 = 0 ;
7730 PyObject * obj1 = 0 ;
7731 char *kwnames[] = {
7732 (char *) "self",(char *) "size", NULL
7733 };
7734
7735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7737 if (SWIG_arg_fail(1)) SWIG_fail;
7738 if (obj1) {
7739 {
7740 arg2 = static_cast<int >(SWIG_As_int(obj1));
7741 if (SWIG_arg_fail(2)) SWIG_fail;
7742 }
7743 }
7744 {
7745 PyThreadState* __tstate = wxPyBeginAllowThreads();
7746 result = (PyObject *)(arg1)->readline(arg2);
7747
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 resultobj = result;
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj = NULL;
7760 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7761 int arg2 = (int) -1 ;
7762 PyObject *result;
7763 PyObject * obj0 = 0 ;
7764 PyObject * obj1 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self",(char *) "sizehint", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 if (obj1) {
7773 {
7774 arg2 = static_cast<int >(SWIG_As_int(obj1));
7775 if (SWIG_arg_fail(2)) SWIG_fail;
7776 }
7777 }
7778 {
7779 PyThreadState* __tstate = wxPyBeginAllowThreads();
7780 result = (PyObject *)(arg1)->readlines(arg2);
7781
7782 wxPyEndAllowThreads(__tstate);
7783 if (PyErr_Occurred()) SWIG_fail;
7784 }
7785 resultobj = result;
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7793 PyObject *resultobj = NULL;
7794 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7795 int arg2 ;
7796 int arg3 = (int) 0 ;
7797 PyObject * obj0 = 0 ;
7798 PyObject * obj1 = 0 ;
7799 PyObject * obj2 = 0 ;
7800 char *kwnames[] = {
7801 (char *) "self",(char *) "offset",(char *) "whence", NULL
7802 };
7803
7804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7806 if (SWIG_arg_fail(1)) SWIG_fail;
7807 {
7808 arg2 = static_cast<int >(SWIG_As_int(obj1));
7809 if (SWIG_arg_fail(2)) SWIG_fail;
7810 }
7811 if (obj2) {
7812 {
7813 arg3 = static_cast<int >(SWIG_As_int(obj2));
7814 if (SWIG_arg_fail(3)) SWIG_fail;
7815 }
7816 }
7817 {
7818 PyThreadState* __tstate = wxPyBeginAllowThreads();
7819 (arg1)->seek(arg2,arg3);
7820
7821 wxPyEndAllowThreads(__tstate);
7822 if (PyErr_Occurred()) SWIG_fail;
7823 }
7824 Py_INCREF(Py_None); resultobj = Py_None;
7825 return resultobj;
7826 fail:
7827 return NULL;
7828 }
7829
7830
7831 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7832 PyObject *resultobj = NULL;
7833 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7834 int result;
7835 PyObject * obj0 = 0 ;
7836 char *kwnames[] = {
7837 (char *) "self", NULL
7838 };
7839
7840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7842 if (SWIG_arg_fail(1)) SWIG_fail;
7843 {
7844 PyThreadState* __tstate = wxPyBeginAllowThreads();
7845 result = (int)(arg1)->tell();
7846
7847 wxPyEndAllowThreads(__tstate);
7848 if (PyErr_Occurred()) SWIG_fail;
7849 }
7850 {
7851 resultobj = SWIG_From_int(static_cast<int >(result));
7852 }
7853 return resultobj;
7854 fail:
7855 return NULL;
7856 }
7857
7858
7859 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7860 PyObject *resultobj = NULL;
7861 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7862 char result;
7863 PyObject * obj0 = 0 ;
7864 char *kwnames[] = {
7865 (char *) "self", NULL
7866 };
7867
7868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7870 if (SWIG_arg_fail(1)) SWIG_fail;
7871 {
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 result = (char)(arg1)->Peek();
7874
7875 wxPyEndAllowThreads(__tstate);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 {
7879 resultobj = SWIG_From_char(static_cast<char >(result));
7880 }
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj = NULL;
7889 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7890 char result;
7891 PyObject * obj0 = 0 ;
7892 char *kwnames[] = {
7893 (char *) "self", NULL
7894 };
7895
7896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(1)) SWIG_fail;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (char)(arg1)->GetC();
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 {
7907 resultobj = SWIG_From_char(static_cast<char >(result));
7908 }
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7916 PyObject *resultobj = NULL;
7917 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7918 size_t result;
7919 PyObject * obj0 = 0 ;
7920 char *kwnames[] = {
7921 (char *) "self", NULL
7922 };
7923
7924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7926 if (SWIG_arg_fail(1)) SWIG_fail;
7927 {
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 result = (size_t)(arg1)->LastRead();
7930
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 {
7935 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7936 }
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7944 PyObject *resultobj = NULL;
7945 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7946 bool result;
7947 PyObject * obj0 = 0 ;
7948 char *kwnames[] = {
7949 (char *) "self", NULL
7950 };
7951
7952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7954 if (SWIG_arg_fail(1)) SWIG_fail;
7955 {
7956 PyThreadState* __tstate = wxPyBeginAllowThreads();
7957 result = (bool)(arg1)->CanRead();
7958
7959 wxPyEndAllowThreads(__tstate);
7960 if (PyErr_Occurred()) SWIG_fail;
7961 }
7962 {
7963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7964 }
7965 return resultobj;
7966 fail:
7967 return NULL;
7968 }
7969
7970
7971 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7972 PyObject *resultobj = NULL;
7973 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7974 bool result;
7975 PyObject * obj0 = 0 ;
7976 char *kwnames[] = {
7977 (char *) "self", NULL
7978 };
7979
7980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7982 if (SWIG_arg_fail(1)) SWIG_fail;
7983 {
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 result = (bool)(arg1)->Eof();
7986
7987 wxPyEndAllowThreads(__tstate);
7988 if (PyErr_Occurred()) SWIG_fail;
7989 }
7990 {
7991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7992 }
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
8000 PyObject *resultobj = NULL;
8001 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8002 char arg2 ;
8003 bool result;
8004 PyObject * obj0 = 0 ;
8005 PyObject * obj1 = 0 ;
8006 char *kwnames[] = {
8007 (char *) "self",(char *) "c", NULL
8008 };
8009
8010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
8011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8012 if (SWIG_arg_fail(1)) SWIG_fail;
8013 {
8014 arg2 = static_cast<char >(SWIG_As_char(obj1));
8015 if (SWIG_arg_fail(2)) SWIG_fail;
8016 }
8017 {
8018 PyThreadState* __tstate = wxPyBeginAllowThreads();
8019 result = (bool)(arg1)->Ungetch(arg2);
8020
8021 wxPyEndAllowThreads(__tstate);
8022 if (PyErr_Occurred()) SWIG_fail;
8023 }
8024 {
8025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8026 }
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = NULL;
8035 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8036 long arg2 ;
8037 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
8038 long result;
8039 PyObject * obj0 = 0 ;
8040 PyObject * obj1 = 0 ;
8041 PyObject * obj2 = 0 ;
8042 char *kwnames[] = {
8043 (char *) "self",(char *) "pos",(char *) "mode", NULL
8044 };
8045
8046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
8047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8048 if (SWIG_arg_fail(1)) SWIG_fail;
8049 {
8050 arg2 = static_cast<long >(SWIG_As_long(obj1));
8051 if (SWIG_arg_fail(2)) SWIG_fail;
8052 }
8053 if (obj2) {
8054 {
8055 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8056 if (SWIG_arg_fail(3)) SWIG_fail;
8057 }
8058 }
8059 {
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 result = (long)(arg1)->SeekI(arg2,arg3);
8062
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 {
8067 resultobj = SWIG_From_long(static_cast<long >(result));
8068 }
8069 return resultobj;
8070 fail:
8071 return NULL;
8072 }
8073
8074
8075 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8076 PyObject *resultobj = NULL;
8077 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8078 long result;
8079 PyObject * obj0 = 0 ;
8080 char *kwnames[] = {
8081 (char *) "self", NULL
8082 };
8083
8084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8086 if (SWIG_arg_fail(1)) SWIG_fail;
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 result = (long)(arg1)->TellI();
8090
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 {
8095 resultobj = SWIG_From_long(static_cast<long >(result));
8096 }
8097 return resultobj;
8098 fail:
8099 return NULL;
8100 }
8101
8102
8103 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8104 PyObject *obj;
8105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8106 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8107 Py_INCREF(obj);
8108 return Py_BuildValue((char *)"");
8109 }
8110 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj = NULL;
8112 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8113 PyObject *arg2 = (PyObject *) 0 ;
8114 PyObject * obj0 = 0 ;
8115 PyObject * obj1 = 0 ;
8116 char *kwnames[] = {
8117 (char *) "self",(char *) "obj", NULL
8118 };
8119
8120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8122 if (SWIG_arg_fail(1)) SWIG_fail;
8123 arg2 = obj1;
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 wxOutputStream_write(arg1,arg2);
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 Py_INCREF(Py_None); resultobj = Py_None;
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8139 PyObject *obj;
8140 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8141 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8142 Py_INCREF(obj);
8143 return Py_BuildValue((char *)"");
8144 }
8145 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = NULL;
8147 wxInputStream *arg1 = (wxInputStream *) 0 ;
8148 wxString *arg2 = 0 ;
8149 wxString *arg3 = 0 ;
8150 wxString *arg4 = 0 ;
8151 wxDateTime arg5 ;
8152 wxFSFile *result;
8153 wxPyInputStream *temp1 ;
8154 bool temp2 = false ;
8155 bool temp3 = false ;
8156 bool temp4 = false ;
8157 PyObject * obj0 = 0 ;
8158 PyObject * obj1 = 0 ;
8159 PyObject * obj2 = 0 ;
8160 PyObject * obj3 = 0 ;
8161 PyObject * obj4 = 0 ;
8162 char *kwnames[] = {
8163 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8164 };
8165
8166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8167 {
8168 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8169 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8170 } else {
8171 PyErr_Clear(); // clear the failure of the wxPyConvert above
8172 arg1 = wxPyCBInputStream_create(obj0, true);
8173 if (arg1 == NULL) {
8174 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8175 SWIG_fail;
8176 }
8177 }
8178 }
8179 {
8180 arg2 = wxString_in_helper(obj1);
8181 if (arg2 == NULL) SWIG_fail;
8182 temp2 = true;
8183 }
8184 {
8185 arg3 = wxString_in_helper(obj2);
8186 if (arg3 == NULL) SWIG_fail;
8187 temp3 = true;
8188 }
8189 {
8190 arg4 = wxString_in_helper(obj3);
8191 if (arg4 == NULL) SWIG_fail;
8192 temp4 = true;
8193 }
8194 {
8195 wxDateTime * argp;
8196 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8197 if (SWIG_arg_fail(5)) SWIG_fail;
8198 if (argp == NULL) {
8199 SWIG_null_ref("wxDateTime");
8200 }
8201 if (SWIG_arg_fail(5)) SWIG_fail;
8202 arg5 = *argp;
8203 }
8204 {
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8207
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 {
8212 resultobj = wxPyMake_wxObject(result, (bool)1);
8213 }
8214 {
8215 if (temp2)
8216 delete arg2;
8217 }
8218 {
8219 if (temp3)
8220 delete arg3;
8221 }
8222 {
8223 if (temp4)
8224 delete arg4;
8225 }
8226 return resultobj;
8227 fail:
8228 {
8229 if (temp2)
8230 delete arg2;
8231 }
8232 {
8233 if (temp3)
8234 delete arg3;
8235 }
8236 {
8237 if (temp4)
8238 delete arg4;
8239 }
8240 return NULL;
8241 }
8242
8243
8244 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj = NULL;
8246 wxFSFile *arg1 = (wxFSFile *) 0 ;
8247 PyObject * obj0 = 0 ;
8248 char *kwnames[] = {
8249 (char *) "self", NULL
8250 };
8251
8252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8254 if (SWIG_arg_fail(1)) SWIG_fail;
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 delete arg1;
8258
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 Py_INCREF(Py_None); resultobj = Py_None;
8263 return resultobj;
8264 fail:
8265 return NULL;
8266 }
8267
8268
8269 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8270 PyObject *resultobj = NULL;
8271 wxFSFile *arg1 = (wxFSFile *) 0 ;
8272 wxInputStream *result;
8273 PyObject * obj0 = 0 ;
8274 char *kwnames[] = {
8275 (char *) "self", NULL
8276 };
8277
8278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(1)) SWIG_fail;
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (wxInputStream *)(arg1)->GetStream();
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 {
8289 wxPyInputStream * _ptr = NULL;
8290
8291 if (result) {
8292 _ptr = new wxPyInputStream(result);
8293 }
8294 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8295 }
8296 return resultobj;
8297 fail:
8298 return NULL;
8299 }
8300
8301
8302 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8303 PyObject *resultobj = NULL;
8304 wxFSFile *arg1 = (wxFSFile *) 0 ;
8305 wxString *result;
8306 PyObject * obj0 = 0 ;
8307 char *kwnames[] = {
8308 (char *) "self", NULL
8309 };
8310
8311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8313 if (SWIG_arg_fail(1)) SWIG_fail;
8314 {
8315 PyThreadState* __tstate = wxPyBeginAllowThreads();
8316 {
8317 wxString const &_result_ref = (arg1)->GetMimeType();
8318 result = (wxString *) &_result_ref;
8319 }
8320
8321 wxPyEndAllowThreads(__tstate);
8322 if (PyErr_Occurred()) SWIG_fail;
8323 }
8324 {
8325 #if wxUSE_UNICODE
8326 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8327 #else
8328 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8329 #endif
8330 }
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj = NULL;
8339 wxFSFile *arg1 = (wxFSFile *) 0 ;
8340 wxString *result;
8341 PyObject * obj0 = 0 ;
8342 char *kwnames[] = {
8343 (char *) "self", NULL
8344 };
8345
8346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8348 if (SWIG_arg_fail(1)) SWIG_fail;
8349 {
8350 PyThreadState* __tstate = wxPyBeginAllowThreads();
8351 {
8352 wxString const &_result_ref = (arg1)->GetLocation();
8353 result = (wxString *) &_result_ref;
8354 }
8355
8356 wxPyEndAllowThreads(__tstate);
8357 if (PyErr_Occurred()) SWIG_fail;
8358 }
8359 {
8360 #if wxUSE_UNICODE
8361 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8362 #else
8363 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8364 #endif
8365 }
8366 return resultobj;
8367 fail:
8368 return NULL;
8369 }
8370
8371
8372 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8373 PyObject *resultobj = NULL;
8374 wxFSFile *arg1 = (wxFSFile *) 0 ;
8375 wxString *result;
8376 PyObject * obj0 = 0 ;
8377 char *kwnames[] = {
8378 (char *) "self", NULL
8379 };
8380
8381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8383 if (SWIG_arg_fail(1)) SWIG_fail;
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 {
8387 wxString const &_result_ref = (arg1)->GetAnchor();
8388 result = (wxString *) &_result_ref;
8389 }
8390
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 {
8395 #if wxUSE_UNICODE
8396 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8397 #else
8398 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8399 #endif
8400 }
8401 return resultobj;
8402 fail:
8403 return NULL;
8404 }
8405
8406
8407 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8408 PyObject *resultobj = NULL;
8409 wxFSFile *arg1 = (wxFSFile *) 0 ;
8410 wxDateTime result;
8411 PyObject * obj0 = 0 ;
8412 char *kwnames[] = {
8413 (char *) "self", NULL
8414 };
8415
8416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8418 if (SWIG_arg_fail(1)) SWIG_fail;
8419 {
8420 PyThreadState* __tstate = wxPyBeginAllowThreads();
8421 result = (arg1)->GetModificationTime();
8422
8423 wxPyEndAllowThreads(__tstate);
8424 if (PyErr_Occurred()) SWIG_fail;
8425 }
8426 {
8427 wxDateTime * resultptr;
8428 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8429 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8430 }
8431 return resultobj;
8432 fail:
8433 return NULL;
8434 }
8435
8436
8437 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8438 PyObject *obj;
8439 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8440 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8441 Py_INCREF(obj);
8442 return Py_BuildValue((char *)"");
8443 }
8444 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8445 PyObject *obj;
8446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8447 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8448 Py_INCREF(obj);
8449 return Py_BuildValue((char *)"");
8450 }
8451 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8452 PyObject *resultobj = NULL;
8453 wxPyFileSystemHandler *result;
8454 char *kwnames[] = {
8455 NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8462
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8467 return resultobj;
8468 fail:
8469 return NULL;
8470 }
8471
8472
8473 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8474 PyObject *resultobj = NULL;
8475 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8476 PyObject *arg2 = (PyObject *) 0 ;
8477 PyObject *arg3 = (PyObject *) 0 ;
8478 PyObject * obj0 = 0 ;
8479 PyObject * obj1 = 0 ;
8480 PyObject * obj2 = 0 ;
8481 char *kwnames[] = {
8482 (char *) "self",(char *) "self",(char *) "_class", NULL
8483 };
8484
8485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8487 if (SWIG_arg_fail(1)) SWIG_fail;
8488 arg2 = obj1;
8489 arg3 = obj2;
8490 {
8491 PyThreadState* __tstate = wxPyBeginAllowThreads();
8492 (arg1)->_setCallbackInfo(arg2,arg3);
8493
8494 wxPyEndAllowThreads(__tstate);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 Py_INCREF(Py_None); resultobj = Py_None;
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8505 PyObject *resultobj = NULL;
8506 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8507 wxString *arg2 = 0 ;
8508 bool result;
8509 bool temp2 = false ;
8510 PyObject * obj0 = 0 ;
8511 PyObject * obj1 = 0 ;
8512 char *kwnames[] = {
8513 (char *) "self",(char *) "location", NULL
8514 };
8515
8516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8518 if (SWIG_arg_fail(1)) SWIG_fail;
8519 {
8520 arg2 = wxString_in_helper(obj1);
8521 if (arg2 == NULL) SWIG_fail;
8522 temp2 = true;
8523 }
8524 {
8525 PyThreadState* __tstate = wxPyBeginAllowThreads();
8526 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8527
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 {
8532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8533 }
8534 {
8535 if (temp2)
8536 delete arg2;
8537 }
8538 return resultobj;
8539 fail:
8540 {
8541 if (temp2)
8542 delete arg2;
8543 }
8544 return NULL;
8545 }
8546
8547
8548 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8549 PyObject *resultobj = NULL;
8550 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8551 wxFileSystem *arg2 = 0 ;
8552 wxString *arg3 = 0 ;
8553 wxFSFile *result;
8554 bool temp3 = false ;
8555 PyObject * obj0 = 0 ;
8556 PyObject * obj1 = 0 ;
8557 PyObject * obj2 = 0 ;
8558 char *kwnames[] = {
8559 (char *) "self",(char *) "fs",(char *) "location", NULL
8560 };
8561
8562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8564 if (SWIG_arg_fail(1)) SWIG_fail;
8565 {
8566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8567 if (SWIG_arg_fail(2)) SWIG_fail;
8568 if (arg2 == NULL) {
8569 SWIG_null_ref("wxFileSystem");
8570 }
8571 if (SWIG_arg_fail(2)) SWIG_fail;
8572 }
8573 {
8574 arg3 = wxString_in_helper(obj2);
8575 if (arg3 == NULL) SWIG_fail;
8576 temp3 = true;
8577 }
8578 {
8579 PyThreadState* __tstate = wxPyBeginAllowThreads();
8580 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8581
8582 wxPyEndAllowThreads(__tstate);
8583 if (PyErr_Occurred()) SWIG_fail;
8584 }
8585 {
8586 resultobj = wxPyMake_wxObject(result, (bool)1);
8587 }
8588 {
8589 if (temp3)
8590 delete arg3;
8591 }
8592 return resultobj;
8593 fail:
8594 {
8595 if (temp3)
8596 delete arg3;
8597 }
8598 return NULL;
8599 }
8600
8601
8602 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8603 PyObject *resultobj = NULL;
8604 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8605 wxString *arg2 = 0 ;
8606 int arg3 = (int) 0 ;
8607 wxString result;
8608 bool temp2 = false ;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 PyObject * obj2 = 0 ;
8612 char *kwnames[] = {
8613 (char *) "self",(char *) "spec",(char *) "flags", NULL
8614 };
8615
8616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8618 if (SWIG_arg_fail(1)) SWIG_fail;
8619 {
8620 arg2 = wxString_in_helper(obj1);
8621 if (arg2 == NULL) SWIG_fail;
8622 temp2 = true;
8623 }
8624 if (obj2) {
8625 {
8626 arg3 = static_cast<int >(SWIG_As_int(obj2));
8627 if (SWIG_arg_fail(3)) SWIG_fail;
8628 }
8629 }
8630 {
8631 PyThreadState* __tstate = wxPyBeginAllowThreads();
8632 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8633
8634 wxPyEndAllowThreads(__tstate);
8635 if (PyErr_Occurred()) SWIG_fail;
8636 }
8637 {
8638 #if wxUSE_UNICODE
8639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8640 #else
8641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8642 #endif
8643 }
8644 {
8645 if (temp2)
8646 delete arg2;
8647 }
8648 return resultobj;
8649 fail:
8650 {
8651 if (temp2)
8652 delete arg2;
8653 }
8654 return NULL;
8655 }
8656
8657
8658 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8659 PyObject *resultobj = NULL;
8660 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8661 wxString result;
8662 PyObject * obj0 = 0 ;
8663 char *kwnames[] = {
8664 (char *) "self", NULL
8665 };
8666
8667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8669 if (SWIG_arg_fail(1)) SWIG_fail;
8670 {
8671 PyThreadState* __tstate = wxPyBeginAllowThreads();
8672 result = (arg1)->FindNext();
8673
8674 wxPyEndAllowThreads(__tstate);
8675 if (PyErr_Occurred()) SWIG_fail;
8676 }
8677 {
8678 #if wxUSE_UNICODE
8679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8680 #else
8681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8682 #endif
8683 }
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8691 PyObject *resultobj = NULL;
8692 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8693 wxString *arg2 = 0 ;
8694 wxString result;
8695 bool temp2 = false ;
8696 PyObject * obj0 = 0 ;
8697 PyObject * obj1 = 0 ;
8698 char *kwnames[] = {
8699 (char *) "self",(char *) "location", NULL
8700 };
8701
8702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8704 if (SWIG_arg_fail(1)) SWIG_fail;
8705 {
8706 arg2 = wxString_in_helper(obj1);
8707 if (arg2 == NULL) SWIG_fail;
8708 temp2 = true;
8709 }
8710 {
8711 PyThreadState* __tstate = wxPyBeginAllowThreads();
8712 result = (arg1)->GetProtocol((wxString const &)*arg2);
8713
8714 wxPyEndAllowThreads(__tstate);
8715 if (PyErr_Occurred()) SWIG_fail;
8716 }
8717 {
8718 #if wxUSE_UNICODE
8719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8720 #else
8721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8722 #endif
8723 }
8724 {
8725 if (temp2)
8726 delete arg2;
8727 }
8728 return resultobj;
8729 fail:
8730 {
8731 if (temp2)
8732 delete arg2;
8733 }
8734 return NULL;
8735 }
8736
8737
8738 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8739 PyObject *resultobj = NULL;
8740 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8741 wxString *arg2 = 0 ;
8742 wxString result;
8743 bool temp2 = false ;
8744 PyObject * obj0 = 0 ;
8745 PyObject * obj1 = 0 ;
8746 char *kwnames[] = {
8747 (char *) "self",(char *) "location", NULL
8748 };
8749
8750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8752 if (SWIG_arg_fail(1)) SWIG_fail;
8753 {
8754 arg2 = wxString_in_helper(obj1);
8755 if (arg2 == NULL) SWIG_fail;
8756 temp2 = true;
8757 }
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8761
8762 wxPyEndAllowThreads(__tstate);
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 {
8766 #if wxUSE_UNICODE
8767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8768 #else
8769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8770 #endif
8771 }
8772 {
8773 if (temp2)
8774 delete arg2;
8775 }
8776 return resultobj;
8777 fail:
8778 {
8779 if (temp2)
8780 delete arg2;
8781 }
8782 return NULL;
8783 }
8784
8785
8786 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj = NULL;
8788 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8789 wxString *arg2 = 0 ;
8790 wxString result;
8791 bool temp2 = false ;
8792 PyObject * obj0 = 0 ;
8793 PyObject * obj1 = 0 ;
8794 char *kwnames[] = {
8795 (char *) "self",(char *) "location", NULL
8796 };
8797
8798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8800 if (SWIG_arg_fail(1)) SWIG_fail;
8801 {
8802 arg2 = wxString_in_helper(obj1);
8803 if (arg2 == NULL) SWIG_fail;
8804 temp2 = true;
8805 }
8806 {
8807 PyThreadState* __tstate = wxPyBeginAllowThreads();
8808 result = (arg1)->GetAnchor((wxString const &)*arg2);
8809
8810 wxPyEndAllowThreads(__tstate);
8811 if (PyErr_Occurred()) SWIG_fail;
8812 }
8813 {
8814 #if wxUSE_UNICODE
8815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8816 #else
8817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8818 #endif
8819 }
8820 {
8821 if (temp2)
8822 delete arg2;
8823 }
8824 return resultobj;
8825 fail:
8826 {
8827 if (temp2)
8828 delete arg2;
8829 }
8830 return NULL;
8831 }
8832
8833
8834 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8835 PyObject *resultobj = NULL;
8836 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8837 wxString *arg2 = 0 ;
8838 wxString result;
8839 bool temp2 = false ;
8840 PyObject * obj0 = 0 ;
8841 PyObject * obj1 = 0 ;
8842 char *kwnames[] = {
8843 (char *) "self",(char *) "location", NULL
8844 };
8845
8846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8848 if (SWIG_arg_fail(1)) SWIG_fail;
8849 {
8850 arg2 = wxString_in_helper(obj1);
8851 if (arg2 == NULL) SWIG_fail;
8852 temp2 = true;
8853 }
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 {
8862 #if wxUSE_UNICODE
8863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8864 #else
8865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8866 #endif
8867 }
8868 {
8869 if (temp2)
8870 delete arg2;
8871 }
8872 return resultobj;
8873 fail:
8874 {
8875 if (temp2)
8876 delete arg2;
8877 }
8878 return NULL;
8879 }
8880
8881
8882 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8883 PyObject *resultobj = NULL;
8884 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8885 wxString *arg2 = 0 ;
8886 wxString result;
8887 bool temp2 = false ;
8888 PyObject * obj0 = 0 ;
8889 PyObject * obj1 = 0 ;
8890 char *kwnames[] = {
8891 (char *) "self",(char *) "location", NULL
8892 };
8893
8894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8896 if (SWIG_arg_fail(1)) SWIG_fail;
8897 {
8898 arg2 = wxString_in_helper(obj1);
8899 if (arg2 == NULL) SWIG_fail;
8900 temp2 = true;
8901 }
8902 {
8903 PyThreadState* __tstate = wxPyBeginAllowThreads();
8904 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8905
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 {
8910 #if wxUSE_UNICODE
8911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8912 #else
8913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8914 #endif
8915 }
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return resultobj;
8921 fail:
8922 {
8923 if (temp2)
8924 delete arg2;
8925 }
8926 return NULL;
8927 }
8928
8929
8930 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8931 PyObject *obj;
8932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8933 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8934 Py_INCREF(obj);
8935 return Py_BuildValue((char *)"");
8936 }
8937 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8938 PyObject *resultobj = NULL;
8939 wxFileSystem *result;
8940 char *kwnames[] = {
8941 NULL
8942 };
8943
8944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8945 {
8946 PyThreadState* __tstate = wxPyBeginAllowThreads();
8947 result = (wxFileSystem *)new wxFileSystem();
8948
8949 wxPyEndAllowThreads(__tstate);
8950 if (PyErr_Occurred()) SWIG_fail;
8951 }
8952 {
8953 resultobj = wxPyMake_wxObject(result, (bool)1);
8954 }
8955 return resultobj;
8956 fail:
8957 return NULL;
8958 }
8959
8960
8961 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8962 PyObject *resultobj = NULL;
8963 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8964 PyObject * obj0 = 0 ;
8965 char *kwnames[] = {
8966 (char *) "self", NULL
8967 };
8968
8969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8971 if (SWIG_arg_fail(1)) SWIG_fail;
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 delete arg1;
8975
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 Py_INCREF(Py_None); resultobj = Py_None;
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8987 PyObject *resultobj = NULL;
8988 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8989 wxString *arg2 = 0 ;
8990 bool arg3 = (bool) false ;
8991 bool temp2 = false ;
8992 PyObject * obj0 = 0 ;
8993 PyObject * obj1 = 0 ;
8994 PyObject * obj2 = 0 ;
8995 char *kwnames[] = {
8996 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8997 };
8998
8999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
9000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9001 if (SWIG_arg_fail(1)) SWIG_fail;
9002 {
9003 arg2 = wxString_in_helper(obj1);
9004 if (arg2 == NULL) SWIG_fail;
9005 temp2 = true;
9006 }
9007 if (obj2) {
9008 {
9009 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9010 if (SWIG_arg_fail(3)) SWIG_fail;
9011 }
9012 }
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
9016
9017 wxPyEndAllowThreads(__tstate);
9018 if (PyErr_Occurred()) SWIG_fail;
9019 }
9020 Py_INCREF(Py_None); resultobj = Py_None;
9021 {
9022 if (temp2)
9023 delete arg2;
9024 }
9025 return resultobj;
9026 fail:
9027 {
9028 if (temp2)
9029 delete arg2;
9030 }
9031 return NULL;
9032 }
9033
9034
9035 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
9036 PyObject *resultobj = NULL;
9037 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9038 wxString result;
9039 PyObject * obj0 = 0 ;
9040 char *kwnames[] = {
9041 (char *) "self", NULL
9042 };
9043
9044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
9045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9046 if (SWIG_arg_fail(1)) SWIG_fail;
9047 {
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 result = (arg1)->GetPath();
9050
9051 wxPyEndAllowThreads(__tstate);
9052 if (PyErr_Occurred()) SWIG_fail;
9053 }
9054 {
9055 #if wxUSE_UNICODE
9056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9057 #else
9058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9059 #endif
9060 }
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
9067 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9068 PyObject *resultobj = NULL;
9069 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9070 wxString *arg2 = 0 ;
9071 wxFSFile *result;
9072 bool temp2 = false ;
9073 PyObject * obj0 = 0 ;
9074 PyObject * obj1 = 0 ;
9075 char *kwnames[] = {
9076 (char *) "self",(char *) "location", NULL
9077 };
9078
9079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9081 if (SWIG_arg_fail(1)) SWIG_fail;
9082 {
9083 arg2 = wxString_in_helper(obj1);
9084 if (arg2 == NULL) SWIG_fail;
9085 temp2 = true;
9086 }
9087 {
9088 PyThreadState* __tstate = wxPyBeginAllowThreads();
9089 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9090
9091 wxPyEndAllowThreads(__tstate);
9092 if (PyErr_Occurred()) SWIG_fail;
9093 }
9094 {
9095 resultobj = wxPyMake_wxObject(result, (bool)1);
9096 }
9097 {
9098 if (temp2)
9099 delete arg2;
9100 }
9101 return resultobj;
9102 fail:
9103 {
9104 if (temp2)
9105 delete arg2;
9106 }
9107 return NULL;
9108 }
9109
9110
9111 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj = NULL;
9113 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9114 wxString *arg2 = 0 ;
9115 int arg3 = (int) 0 ;
9116 wxString result;
9117 bool temp2 = false ;
9118 PyObject * obj0 = 0 ;
9119 PyObject * obj1 = 0 ;
9120 PyObject * obj2 = 0 ;
9121 char *kwnames[] = {
9122 (char *) "self",(char *) "spec",(char *) "flags", NULL
9123 };
9124
9125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9127 if (SWIG_arg_fail(1)) SWIG_fail;
9128 {
9129 arg2 = wxString_in_helper(obj1);
9130 if (arg2 == NULL) SWIG_fail;
9131 temp2 = true;
9132 }
9133 if (obj2) {
9134 {
9135 arg3 = static_cast<int >(SWIG_As_int(obj2));
9136 if (SWIG_arg_fail(3)) SWIG_fail;
9137 }
9138 }
9139 {
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9142
9143 wxPyEndAllowThreads(__tstate);
9144 if (PyErr_Occurred()) SWIG_fail;
9145 }
9146 {
9147 #if wxUSE_UNICODE
9148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9149 #else
9150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9151 #endif
9152 }
9153 {
9154 if (temp2)
9155 delete arg2;
9156 }
9157 return resultobj;
9158 fail:
9159 {
9160 if (temp2)
9161 delete arg2;
9162 }
9163 return NULL;
9164 }
9165
9166
9167 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj = NULL;
9169 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9170 wxString result;
9171 PyObject * obj0 = 0 ;
9172 char *kwnames[] = {
9173 (char *) "self", NULL
9174 };
9175
9176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9178 if (SWIG_arg_fail(1)) SWIG_fail;
9179 {
9180 PyThreadState* __tstate = wxPyBeginAllowThreads();
9181 result = (arg1)->FindNext();
9182
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 {
9187 #if wxUSE_UNICODE
9188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9189 #else
9190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9191 #endif
9192 }
9193 return resultobj;
9194 fail:
9195 return NULL;
9196 }
9197
9198
9199 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9200 PyObject *resultobj = NULL;
9201 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9202 PyObject * obj0 = 0 ;
9203 char *kwnames[] = {
9204 (char *) "handler", NULL
9205 };
9206
9207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9209 if (SWIG_arg_fail(1)) SWIG_fail;
9210 {
9211 PyThreadState* __tstate = wxPyBeginAllowThreads();
9212 wxFileSystem::AddHandler(arg1);
9213
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 Py_INCREF(Py_None); resultobj = Py_None;
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj = NULL;
9226 char *kwnames[] = {
9227 NULL
9228 };
9229
9230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 wxFileSystem::CleanUpHandlers();
9234
9235 wxPyEndAllowThreads(__tstate);
9236 if (PyErr_Occurred()) SWIG_fail;
9237 }
9238 Py_INCREF(Py_None); resultobj = Py_None;
9239 return resultobj;
9240 fail:
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj = NULL;
9247 wxString *arg1 = 0 ;
9248 wxString result;
9249 bool temp1 = false ;
9250 PyObject * obj0 = 0 ;
9251 char *kwnames[] = {
9252 (char *) "filename", NULL
9253 };
9254
9255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9256 {
9257 arg1 = wxString_in_helper(obj0);
9258 if (arg1 == NULL) SWIG_fail;
9259 temp1 = true;
9260 }
9261 {
9262 PyThreadState* __tstate = wxPyBeginAllowThreads();
9263 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9264
9265 wxPyEndAllowThreads(__tstate);
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 {
9269 #if wxUSE_UNICODE
9270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9271 #else
9272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9273 #endif
9274 }
9275 {
9276 if (temp1)
9277 delete arg1;
9278 }
9279 return resultobj;
9280 fail:
9281 {
9282 if (temp1)
9283 delete arg1;
9284 }
9285 return NULL;
9286 }
9287
9288
9289 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj = NULL;
9291 wxString *arg1 = 0 ;
9292 wxString result;
9293 bool temp1 = false ;
9294 PyObject * obj0 = 0 ;
9295 char *kwnames[] = {
9296 (char *) "url", NULL
9297 };
9298
9299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9300 {
9301 arg1 = wxString_in_helper(obj0);
9302 if (arg1 == NULL) SWIG_fail;
9303 temp1 = true;
9304 }
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9308
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 {
9313 #if wxUSE_UNICODE
9314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9315 #else
9316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9317 #endif
9318 }
9319 {
9320 if (temp1)
9321 delete arg1;
9322 }
9323 return resultobj;
9324 fail:
9325 {
9326 if (temp1)
9327 delete arg1;
9328 }
9329 return NULL;
9330 }
9331
9332
9333 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9334 PyObject *obj;
9335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9336 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9337 Py_INCREF(obj);
9338 return Py_BuildValue((char *)"");
9339 }
9340 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj = NULL;
9342 wxInternetFSHandler *result;
9343 char *kwnames[] = {
9344 NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9351
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9356 return resultobj;
9357 fail:
9358 return NULL;
9359 }
9360
9361
9362 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9363 PyObject *resultobj = NULL;
9364 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9365 wxString *arg2 = 0 ;
9366 bool result;
9367 bool temp2 = false ;
9368 PyObject * obj0 = 0 ;
9369 PyObject * obj1 = 0 ;
9370 char *kwnames[] = {
9371 (char *) "self",(char *) "location", NULL
9372 };
9373
9374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9376 if (SWIG_arg_fail(1)) SWIG_fail;
9377 {
9378 arg2 = wxString_in_helper(obj1);
9379 if (arg2 == NULL) SWIG_fail;
9380 temp2 = true;
9381 }
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9385
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 {
9390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9391 }
9392 {
9393 if (temp2)
9394 delete arg2;
9395 }
9396 return resultobj;
9397 fail:
9398 {
9399 if (temp2)
9400 delete arg2;
9401 }
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj = NULL;
9408 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9409 wxFileSystem *arg2 = 0 ;
9410 wxString *arg3 = 0 ;
9411 wxFSFile *result;
9412 bool temp3 = false ;
9413 PyObject * obj0 = 0 ;
9414 PyObject * obj1 = 0 ;
9415 PyObject * obj2 = 0 ;
9416 char *kwnames[] = {
9417 (char *) "self",(char *) "fs",(char *) "location", NULL
9418 };
9419
9420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9422 if (SWIG_arg_fail(1)) SWIG_fail;
9423 {
9424 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9425 if (SWIG_arg_fail(2)) SWIG_fail;
9426 if (arg2 == NULL) {
9427 SWIG_null_ref("wxFileSystem");
9428 }
9429 if (SWIG_arg_fail(2)) SWIG_fail;
9430 }
9431 {
9432 arg3 = wxString_in_helper(obj2);
9433 if (arg3 == NULL) SWIG_fail;
9434 temp3 = true;
9435 }
9436 {
9437 PyThreadState* __tstate = wxPyBeginAllowThreads();
9438 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9439
9440 wxPyEndAllowThreads(__tstate);
9441 if (PyErr_Occurred()) SWIG_fail;
9442 }
9443 {
9444 resultobj = wxPyMake_wxObject(result, (bool)1);
9445 }
9446 {
9447 if (temp3)
9448 delete arg3;
9449 }
9450 return resultobj;
9451 fail:
9452 {
9453 if (temp3)
9454 delete arg3;
9455 }
9456 return NULL;
9457 }
9458
9459
9460 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9461 PyObject *obj;
9462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9463 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9464 Py_INCREF(obj);
9465 return Py_BuildValue((char *)"");
9466 }
9467 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9468 PyObject *resultobj = NULL;
9469 wxZipFSHandler *result;
9470 char *kwnames[] = {
9471 NULL
9472 };
9473
9474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (wxZipFSHandler *)new wxZipFSHandler();
9478
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = NULL;
9491 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9492 wxString *arg2 = 0 ;
9493 bool result;
9494 bool temp2 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 char *kwnames[] = {
9498 (char *) "self",(char *) "location", NULL
9499 };
9500
9501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9503 if (SWIG_arg_fail(1)) SWIG_fail;
9504 {
9505 arg2 = wxString_in_helper(obj1);
9506 if (arg2 == NULL) SWIG_fail;
9507 temp2 = true;
9508 }
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9512
9513 wxPyEndAllowThreads(__tstate);
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 {
9517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9518 }
9519 {
9520 if (temp2)
9521 delete arg2;
9522 }
9523 return resultobj;
9524 fail:
9525 {
9526 if (temp2)
9527 delete arg2;
9528 }
9529 return NULL;
9530 }
9531
9532
9533 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9534 PyObject *resultobj = NULL;
9535 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9536 wxFileSystem *arg2 = 0 ;
9537 wxString *arg3 = 0 ;
9538 wxFSFile *result;
9539 bool temp3 = false ;
9540 PyObject * obj0 = 0 ;
9541 PyObject * obj1 = 0 ;
9542 PyObject * obj2 = 0 ;
9543 char *kwnames[] = {
9544 (char *) "self",(char *) "fs",(char *) "location", NULL
9545 };
9546
9547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9549 if (SWIG_arg_fail(1)) SWIG_fail;
9550 {
9551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9552 if (SWIG_arg_fail(2)) SWIG_fail;
9553 if (arg2 == NULL) {
9554 SWIG_null_ref("wxFileSystem");
9555 }
9556 if (SWIG_arg_fail(2)) SWIG_fail;
9557 }
9558 {
9559 arg3 = wxString_in_helper(obj2);
9560 if (arg3 == NULL) SWIG_fail;
9561 temp3 = true;
9562 }
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9566
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 {
9571 resultobj = wxPyMake_wxObject(result, (bool)1);
9572 }
9573 {
9574 if (temp3)
9575 delete arg3;
9576 }
9577 return resultobj;
9578 fail:
9579 {
9580 if (temp3)
9581 delete arg3;
9582 }
9583 return NULL;
9584 }
9585
9586
9587 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = NULL;
9589 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9590 wxString *arg2 = 0 ;
9591 int arg3 = (int) 0 ;
9592 wxString result;
9593 bool temp2 = false ;
9594 PyObject * obj0 = 0 ;
9595 PyObject * obj1 = 0 ;
9596 PyObject * obj2 = 0 ;
9597 char *kwnames[] = {
9598 (char *) "self",(char *) "spec",(char *) "flags", NULL
9599 };
9600
9601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9603 if (SWIG_arg_fail(1)) SWIG_fail;
9604 {
9605 arg2 = wxString_in_helper(obj1);
9606 if (arg2 == NULL) SWIG_fail;
9607 temp2 = true;
9608 }
9609 if (obj2) {
9610 {
9611 arg3 = static_cast<int >(SWIG_As_int(obj2));
9612 if (SWIG_arg_fail(3)) SWIG_fail;
9613 }
9614 }
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9618
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 {
9623 #if wxUSE_UNICODE
9624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9625 #else
9626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9627 #endif
9628 }
9629 {
9630 if (temp2)
9631 delete arg2;
9632 }
9633 return resultobj;
9634 fail:
9635 {
9636 if (temp2)
9637 delete arg2;
9638 }
9639 return NULL;
9640 }
9641
9642
9643 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9644 PyObject *resultobj = NULL;
9645 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9646 wxString result;
9647 PyObject * obj0 = 0 ;
9648 char *kwnames[] = {
9649 (char *) "self", NULL
9650 };
9651
9652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9654 if (SWIG_arg_fail(1)) SWIG_fail;
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (arg1)->FindNext();
9658
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 {
9663 #if wxUSE_UNICODE
9664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9665 #else
9666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9667 #endif
9668 }
9669 return resultobj;
9670 fail:
9671 return NULL;
9672 }
9673
9674
9675 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9676 PyObject *obj;
9677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9678 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9679 Py_INCREF(obj);
9680 return Py_BuildValue((char *)"");
9681 }
9682 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9683 PyObject *resultobj = NULL;
9684 wxString *arg1 = 0 ;
9685 wxImage *arg2 = 0 ;
9686 long arg3 ;
9687 bool temp1 = false ;
9688 PyObject * obj0 = 0 ;
9689 PyObject * obj1 = 0 ;
9690 PyObject * obj2 = 0 ;
9691 char *kwnames[] = {
9692 (char *) "filename",(char *) "image",(char *) "type", NULL
9693 };
9694
9695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9696 {
9697 arg1 = wxString_in_helper(obj0);
9698 if (arg1 == NULL) SWIG_fail;
9699 temp1 = true;
9700 }
9701 {
9702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9703 if (SWIG_arg_fail(2)) SWIG_fail;
9704 if (arg2 == NULL) {
9705 SWIG_null_ref("wxImage");
9706 }
9707 if (SWIG_arg_fail(2)) SWIG_fail;
9708 }
9709 {
9710 arg3 = static_cast<long >(SWIG_As_long(obj2));
9711 if (SWIG_arg_fail(3)) SWIG_fail;
9712 }
9713 {
9714 PyThreadState* __tstate = wxPyBeginAllowThreads();
9715 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9716
9717 wxPyEndAllowThreads(__tstate);
9718 if (PyErr_Occurred()) SWIG_fail;
9719 }
9720 Py_INCREF(Py_None); resultobj = Py_None;
9721 {
9722 if (temp1)
9723 delete arg1;
9724 }
9725 return resultobj;
9726 fail:
9727 {
9728 if (temp1)
9729 delete arg1;
9730 }
9731 return NULL;
9732 }
9733
9734
9735 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj = NULL;
9737 wxString *arg1 = 0 ;
9738 wxBitmap *arg2 = 0 ;
9739 long arg3 ;
9740 bool temp1 = false ;
9741 PyObject * obj0 = 0 ;
9742 PyObject * obj1 = 0 ;
9743 PyObject * obj2 = 0 ;
9744 char *kwnames[] = {
9745 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9746 };
9747
9748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9749 {
9750 arg1 = wxString_in_helper(obj0);
9751 if (arg1 == NULL) SWIG_fail;
9752 temp1 = true;
9753 }
9754 {
9755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9756 if (SWIG_arg_fail(2)) SWIG_fail;
9757 if (arg2 == NULL) {
9758 SWIG_null_ref("wxBitmap");
9759 }
9760 if (SWIG_arg_fail(2)) SWIG_fail;
9761 }
9762 {
9763 arg3 = static_cast<long >(SWIG_As_long(obj2));
9764 if (SWIG_arg_fail(3)) SWIG_fail;
9765 }
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9769
9770 wxPyEndAllowThreads(__tstate);
9771 if (PyErr_Occurred()) SWIG_fail;
9772 }
9773 Py_INCREF(Py_None); resultobj = Py_None;
9774 {
9775 if (temp1)
9776 delete arg1;
9777 }
9778 return resultobj;
9779 fail:
9780 {
9781 if (temp1)
9782 delete arg1;
9783 }
9784 return NULL;
9785 }
9786
9787
9788 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9789 PyObject *resultobj = NULL;
9790 wxString *arg1 = 0 ;
9791 PyObject *arg2 = (PyObject *) 0 ;
9792 bool temp1 = false ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 char *kwnames[] = {
9796 (char *) "filename",(char *) "data", NULL
9797 };
9798
9799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9800 {
9801 arg1 = wxString_in_helper(obj0);
9802 if (arg1 == NULL) SWIG_fail;
9803 temp1 = true;
9804 }
9805 arg2 = obj1;
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9809
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 Py_INCREF(Py_None); resultobj = Py_None;
9814 {
9815 if (temp1)
9816 delete arg1;
9817 }
9818 return resultobj;
9819 fail:
9820 {
9821 if (temp1)
9822 delete arg1;
9823 }
9824 return NULL;
9825 }
9826
9827
9828 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9829 PyObject *resultobj = NULL;
9830 wxMemoryFSHandler *result;
9831 char *kwnames[] = {
9832 NULL
9833 };
9834
9835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj = NULL;
9852 wxString *arg1 = 0 ;
9853 bool temp1 = false ;
9854 PyObject * obj0 = 0 ;
9855 char *kwnames[] = {
9856 (char *) "filename", NULL
9857 };
9858
9859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9860 {
9861 arg1 = wxString_in_helper(obj0);
9862 if (arg1 == NULL) SWIG_fail;
9863 temp1 = true;
9864 }
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9868
9869 wxPyEndAllowThreads(__tstate);
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 Py_INCREF(Py_None); resultobj = Py_None;
9873 {
9874 if (temp1)
9875 delete arg1;
9876 }
9877 return resultobj;
9878 fail:
9879 {
9880 if (temp1)
9881 delete arg1;
9882 }
9883 return NULL;
9884 }
9885
9886
9887 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9888 PyObject *resultobj = NULL;
9889 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9890 wxString *arg2 = 0 ;
9891 bool result;
9892 bool temp2 = false ;
9893 PyObject * obj0 = 0 ;
9894 PyObject * obj1 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "self",(char *) "location", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9901 if (SWIG_arg_fail(1)) SWIG_fail;
9902 {
9903 arg2 = wxString_in_helper(obj1);
9904 if (arg2 == NULL) SWIG_fail;
9905 temp2 = true;
9906 }
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 {
9915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9916 }
9917 {
9918 if (temp2)
9919 delete arg2;
9920 }
9921 return resultobj;
9922 fail:
9923 {
9924 if (temp2)
9925 delete arg2;
9926 }
9927 return NULL;
9928 }
9929
9930
9931 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9932 PyObject *resultobj = NULL;
9933 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9934 wxFileSystem *arg2 = 0 ;
9935 wxString *arg3 = 0 ;
9936 wxFSFile *result;
9937 bool temp3 = false ;
9938 PyObject * obj0 = 0 ;
9939 PyObject * obj1 = 0 ;
9940 PyObject * obj2 = 0 ;
9941 char *kwnames[] = {
9942 (char *) "self",(char *) "fs",(char *) "location", NULL
9943 };
9944
9945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9947 if (SWIG_arg_fail(1)) SWIG_fail;
9948 {
9949 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9950 if (SWIG_arg_fail(2)) SWIG_fail;
9951 if (arg2 == NULL) {
9952 SWIG_null_ref("wxFileSystem");
9953 }
9954 if (SWIG_arg_fail(2)) SWIG_fail;
9955 }
9956 {
9957 arg3 = wxString_in_helper(obj2);
9958 if (arg3 == NULL) SWIG_fail;
9959 temp3 = true;
9960 }
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9964
9965 wxPyEndAllowThreads(__tstate);
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 {
9969 resultobj = wxPyMake_wxObject(result, (bool)1);
9970 }
9971 {
9972 if (temp3)
9973 delete arg3;
9974 }
9975 return resultobj;
9976 fail:
9977 {
9978 if (temp3)
9979 delete arg3;
9980 }
9981 return NULL;
9982 }
9983
9984
9985 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj = NULL;
9987 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9988 wxString *arg2 = 0 ;
9989 int arg3 = (int) 0 ;
9990 wxString result;
9991 bool temp2 = false ;
9992 PyObject * obj0 = 0 ;
9993 PyObject * obj1 = 0 ;
9994 PyObject * obj2 = 0 ;
9995 char *kwnames[] = {
9996 (char *) "self",(char *) "spec",(char *) "flags", NULL
9997 };
9998
9999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
10000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10001 if (SWIG_arg_fail(1)) SWIG_fail;
10002 {
10003 arg2 = wxString_in_helper(obj1);
10004 if (arg2 == NULL) SWIG_fail;
10005 temp2 = true;
10006 }
10007 if (obj2) {
10008 {
10009 arg3 = static_cast<int >(SWIG_As_int(obj2));
10010 if (SWIG_arg_fail(3)) SWIG_fail;
10011 }
10012 }
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 {
10021 #if wxUSE_UNICODE
10022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10023 #else
10024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10025 #endif
10026 }
10027 {
10028 if (temp2)
10029 delete arg2;
10030 }
10031 return resultobj;
10032 fail:
10033 {
10034 if (temp2)
10035 delete arg2;
10036 }
10037 return NULL;
10038 }
10039
10040
10041 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
10042 PyObject *resultobj = NULL;
10043 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
10044 wxString result;
10045 PyObject * obj0 = 0 ;
10046 char *kwnames[] = {
10047 (char *) "self", NULL
10048 };
10049
10050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
10051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10052 if (SWIG_arg_fail(1)) SWIG_fail;
10053 {
10054 PyThreadState* __tstate = wxPyBeginAllowThreads();
10055 result = (arg1)->FindNext();
10056
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 {
10061 #if wxUSE_UNICODE
10062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10063 #else
10064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10065 #endif
10066 }
10067 return resultobj;
10068 fail:
10069 return NULL;
10070 }
10071
10072
10073 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10074 PyObject *obj;
10075 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10076 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10077 Py_INCREF(obj);
10078 return Py_BuildValue((char *)"");
10079 }
10080 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj = NULL;
10082 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10083 wxString result;
10084 PyObject * obj0 = 0 ;
10085 char *kwnames[] = {
10086 (char *) "self", NULL
10087 };
10088
10089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10091 if (SWIG_arg_fail(1)) SWIG_fail;
10092 {
10093 PyThreadState* __tstate = wxPyBeginAllowThreads();
10094 result = (arg1)->GetName();
10095
10096 wxPyEndAllowThreads(__tstate);
10097 if (PyErr_Occurred()) SWIG_fail;
10098 }
10099 {
10100 #if wxUSE_UNICODE
10101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10102 #else
10103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10104 #endif
10105 }
10106 return resultobj;
10107 fail:
10108 return NULL;
10109 }
10110
10111
10112 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10113 PyObject *resultobj = NULL;
10114 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10115 wxString result;
10116 PyObject * obj0 = 0 ;
10117 char *kwnames[] = {
10118 (char *) "self", NULL
10119 };
10120
10121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10123 if (SWIG_arg_fail(1)) SWIG_fail;
10124 {
10125 PyThreadState* __tstate = wxPyBeginAllowThreads();
10126 result = (arg1)->GetExtension();
10127
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 {
10132 #if wxUSE_UNICODE
10133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10134 #else
10135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10136 #endif
10137 }
10138 return resultobj;
10139 fail:
10140 return NULL;
10141 }
10142
10143
10144 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10145 PyObject *resultobj = NULL;
10146 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10147 long result;
10148 PyObject * obj0 = 0 ;
10149 char *kwnames[] = {
10150 (char *) "self", NULL
10151 };
10152
10153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10155 if (SWIG_arg_fail(1)) SWIG_fail;
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 result = (long)(arg1)->GetType();
10159
10160 wxPyEndAllowThreads(__tstate);
10161 if (PyErr_Occurred()) SWIG_fail;
10162 }
10163 {
10164 resultobj = SWIG_From_long(static_cast<long >(result));
10165 }
10166 return resultobj;
10167 fail:
10168 return NULL;
10169 }
10170
10171
10172 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10173 PyObject *resultobj = NULL;
10174 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10175 wxString result;
10176 PyObject * obj0 = 0 ;
10177 char *kwnames[] = {
10178 (char *) "self", NULL
10179 };
10180
10181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10183 if (SWIG_arg_fail(1)) SWIG_fail;
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 result = (arg1)->GetMimeType();
10187
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 {
10192 #if wxUSE_UNICODE
10193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10194 #else
10195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10196 #endif
10197 }
10198 return resultobj;
10199 fail:
10200 return NULL;
10201 }
10202
10203
10204 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10205 PyObject *resultobj = NULL;
10206 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10207 wxString *arg2 = 0 ;
10208 bool result;
10209 bool temp2 = false ;
10210 PyObject * obj0 = 0 ;
10211 PyObject * obj1 = 0 ;
10212 char *kwnames[] = {
10213 (char *) "self",(char *) "name", NULL
10214 };
10215
10216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10218 if (SWIG_arg_fail(1)) SWIG_fail;
10219 {
10220 arg2 = wxString_in_helper(obj1);
10221 if (arg2 == NULL) SWIG_fail;
10222 temp2 = true;
10223 }
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10227
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 {
10232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10233 }
10234 {
10235 if (temp2)
10236 delete arg2;
10237 }
10238 return resultobj;
10239 fail:
10240 {
10241 if (temp2)
10242 delete arg2;
10243 }
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj = NULL;
10250 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10251 wxString *arg2 = 0 ;
10252 bool temp2 = false ;
10253 PyObject * obj0 = 0 ;
10254 PyObject * obj1 = 0 ;
10255 char *kwnames[] = {
10256 (char *) "self",(char *) "name", NULL
10257 };
10258
10259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10261 if (SWIG_arg_fail(1)) SWIG_fail;
10262 {
10263 arg2 = wxString_in_helper(obj1);
10264 if (arg2 == NULL) SWIG_fail;
10265 temp2 = true;
10266 }
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 (arg1)->SetName((wxString const &)*arg2);
10270
10271 wxPyEndAllowThreads(__tstate);
10272 if (PyErr_Occurred()) SWIG_fail;
10273 }
10274 Py_INCREF(Py_None); resultobj = Py_None;
10275 {
10276 if (temp2)
10277 delete arg2;
10278 }
10279 return resultobj;
10280 fail:
10281 {
10282 if (temp2)
10283 delete arg2;
10284 }
10285 return NULL;
10286 }
10287
10288
10289 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10290 PyObject *resultobj = NULL;
10291 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10292 wxString *arg2 = 0 ;
10293 bool temp2 = false ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char *kwnames[] = {
10297 (char *) "self",(char *) "extension", NULL
10298 };
10299
10300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10302 if (SWIG_arg_fail(1)) SWIG_fail;
10303 {
10304 arg2 = wxString_in_helper(obj1);
10305 if (arg2 == NULL) SWIG_fail;
10306 temp2 = true;
10307 }
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 (arg1)->SetExtension((wxString const &)*arg2);
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 Py_INCREF(Py_None); resultobj = Py_None;
10316 {
10317 if (temp2)
10318 delete arg2;
10319 }
10320 return resultobj;
10321 fail:
10322 {
10323 if (temp2)
10324 delete arg2;
10325 }
10326 return NULL;
10327 }
10328
10329
10330 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10331 PyObject *resultobj = NULL;
10332 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10333 long arg2 ;
10334 PyObject * obj0 = 0 ;
10335 PyObject * obj1 = 0 ;
10336 char *kwnames[] = {
10337 (char *) "self",(char *) "type", NULL
10338 };
10339
10340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10342 if (SWIG_arg_fail(1)) SWIG_fail;
10343 {
10344 arg2 = static_cast<long >(SWIG_As_long(obj1));
10345 if (SWIG_arg_fail(2)) SWIG_fail;
10346 }
10347 {
10348 PyThreadState* __tstate = wxPyBeginAllowThreads();
10349 (arg1)->SetType(arg2);
10350
10351 wxPyEndAllowThreads(__tstate);
10352 if (PyErr_Occurred()) SWIG_fail;
10353 }
10354 Py_INCREF(Py_None); resultobj = Py_None;
10355 return resultobj;
10356 fail:
10357 return NULL;
10358 }
10359
10360
10361 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10362 PyObject *resultobj = NULL;
10363 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10364 wxString *arg2 = 0 ;
10365 bool temp2 = false ;
10366 PyObject * obj0 = 0 ;
10367 PyObject * obj1 = 0 ;
10368 char *kwnames[] = {
10369 (char *) "self",(char *) "mimetype", NULL
10370 };
10371
10372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10374 if (SWIG_arg_fail(1)) SWIG_fail;
10375 {
10376 arg2 = wxString_in_helper(obj1);
10377 if (arg2 == NULL) SWIG_fail;
10378 temp2 = true;
10379 }
10380 {
10381 PyThreadState* __tstate = wxPyBeginAllowThreads();
10382 (arg1)->SetMimeType((wxString const &)*arg2);
10383
10384 wxPyEndAllowThreads(__tstate);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 Py_INCREF(Py_None); resultobj = Py_None;
10388 {
10389 if (temp2)
10390 delete arg2;
10391 }
10392 return resultobj;
10393 fail:
10394 {
10395 if (temp2)
10396 delete arg2;
10397 }
10398 return NULL;
10399 }
10400
10401
10402 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10403 PyObject *obj;
10404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10405 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10406 Py_INCREF(obj);
10407 return Py_BuildValue((char *)"");
10408 }
10409 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10410 PyObject *resultobj = NULL;
10411 wxPyImageHandler *result;
10412 char *kwnames[] = {
10413 NULL
10414 };
10415
10416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10417 {
10418 PyThreadState* __tstate = wxPyBeginAllowThreads();
10419 result = (wxPyImageHandler *)new wxPyImageHandler();
10420
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10425 return resultobj;
10426 fail:
10427 return NULL;
10428 }
10429
10430
10431 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10432 PyObject *resultobj = NULL;
10433 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10434 PyObject *arg2 = (PyObject *) 0 ;
10435 PyObject * obj0 = 0 ;
10436 PyObject * obj1 = 0 ;
10437 char *kwnames[] = {
10438 (char *) "self",(char *) "self", NULL
10439 };
10440
10441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10443 if (SWIG_arg_fail(1)) SWIG_fail;
10444 arg2 = obj1;
10445 {
10446 PyThreadState* __tstate = wxPyBeginAllowThreads();
10447 (arg1)->_SetSelf(arg2);
10448
10449 wxPyEndAllowThreads(__tstate);
10450 if (PyErr_Occurred()) SWIG_fail;
10451 }
10452 Py_INCREF(Py_None); resultobj = Py_None;
10453 return resultobj;
10454 fail:
10455 return NULL;
10456 }
10457
10458
10459 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10460 PyObject *obj;
10461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10462 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10463 Py_INCREF(obj);
10464 return Py_BuildValue((char *)"");
10465 }
10466 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj = NULL;
10468 wxImageHistogram *result;
10469 char *kwnames[] = {
10470 NULL
10471 };
10472
10473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10474 {
10475 PyThreadState* __tstate = wxPyBeginAllowThreads();
10476 result = (wxImageHistogram *)new wxImageHistogram();
10477
10478 wxPyEndAllowThreads(__tstate);
10479 if (PyErr_Occurred()) SWIG_fail;
10480 }
10481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10482 return resultobj;
10483 fail:
10484 return NULL;
10485 }
10486
10487
10488 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10489 PyObject *resultobj = NULL;
10490 byte arg1 ;
10491 byte arg2 ;
10492 byte arg3 ;
10493 unsigned long result;
10494 PyObject * obj0 = 0 ;
10495 PyObject * obj1 = 0 ;
10496 PyObject * obj2 = 0 ;
10497 char *kwnames[] = {
10498 (char *) "r",(char *) "g",(char *) "b", NULL
10499 };
10500
10501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10502 {
10503 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10504 if (SWIG_arg_fail(1)) SWIG_fail;
10505 }
10506 {
10507 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10508 if (SWIG_arg_fail(2)) SWIG_fail;
10509 }
10510 {
10511 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10512 if (SWIG_arg_fail(3)) SWIG_fail;
10513 }
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 {
10522 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10523 }
10524 return resultobj;
10525 fail:
10526 return NULL;
10527 }
10528
10529
10530 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10531 PyObject *resultobj = NULL;
10532 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10533 byte *arg2 = (byte *) 0 ;
10534 byte *arg3 = (byte *) 0 ;
10535 byte *arg4 = (byte *) 0 ;
10536 byte arg5 = (byte) 1 ;
10537 byte arg6 = (byte) 0 ;
10538 byte arg7 = (byte) 0 ;
10539 bool result;
10540 byte temp2 ;
10541 int res2 = 0 ;
10542 byte temp3 ;
10543 int res3 = 0 ;
10544 byte temp4 ;
10545 int res4 = 0 ;
10546 PyObject * obj0 = 0 ;
10547 PyObject * obj1 = 0 ;
10548 PyObject * obj2 = 0 ;
10549 PyObject * obj3 = 0 ;
10550 char *kwnames[] = {
10551 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10552 };
10553
10554 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10555 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10556 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10559 if (SWIG_arg_fail(1)) SWIG_fail;
10560 if (obj1) {
10561 {
10562 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10563 if (SWIG_arg_fail(5)) SWIG_fail;
10564 }
10565 }
10566 if (obj2) {
10567 {
10568 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10569 if (SWIG_arg_fail(6)) SWIG_fail;
10570 }
10571 }
10572 if (obj3) {
10573 {
10574 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10575 if (SWIG_arg_fail(7)) SWIG_fail;
10576 }
10577 }
10578 {
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10581
10582 wxPyEndAllowThreads(__tstate);
10583 if (PyErr_Occurred()) SWIG_fail;
10584 }
10585 {
10586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10587 }
10588 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10589 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10590 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10591 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10592 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10593 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj = NULL;
10602 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10603 unsigned long arg2 ;
10604 unsigned long result;
10605 PyObject * obj0 = 0 ;
10606 PyObject * obj1 = 0 ;
10607 char *kwnames[] = {
10608 (char *) "self",(char *) "key", NULL
10609 };
10610
10611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10613 if (SWIG_arg_fail(1)) SWIG_fail;
10614 {
10615 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10616 if (SWIG_arg_fail(2)) SWIG_fail;
10617 }
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10621
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 {
10626 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10627 }
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10635 PyObject *resultobj = NULL;
10636 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10637 byte arg2 ;
10638 byte arg3 ;
10639 byte arg4 ;
10640 unsigned long result;
10641 PyObject * obj0 = 0 ;
10642 PyObject * obj1 = 0 ;
10643 PyObject * obj2 = 0 ;
10644 PyObject * obj3 = 0 ;
10645 char *kwnames[] = {
10646 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10647 };
10648
10649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10651 if (SWIG_arg_fail(1)) SWIG_fail;
10652 {
10653 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10654 if (SWIG_arg_fail(2)) SWIG_fail;
10655 }
10656 {
10657 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10658 if (SWIG_arg_fail(3)) SWIG_fail;
10659 }
10660 {
10661 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10662 if (SWIG_arg_fail(4)) SWIG_fail;
10663 }
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10667
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 {
10672 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10673 }
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj = NULL;
10682 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10683 wxColour *arg2 = 0 ;
10684 unsigned long result;
10685 wxColour temp2 ;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 char *kwnames[] = {
10689 (char *) "self",(char *) "colour", NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10694 if (SWIG_arg_fail(1)) SWIG_fail;
10695 {
10696 arg2 = &temp2;
10697 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10698 }
10699 {
10700 PyThreadState* __tstate = wxPyBeginAllowThreads();
10701 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10702
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 {
10707 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10708 }
10709 return resultobj;
10710 fail:
10711 return NULL;
10712 }
10713
10714
10715 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10716 PyObject *obj;
10717 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10718 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10719 Py_INCREF(obj);
10720 return Py_BuildValue((char *)"");
10721 }
10722 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10723 PyObject *resultobj = NULL;
10724 byte arg1 = (byte) 0 ;
10725 byte arg2 = (byte) 0 ;
10726 byte arg3 = (byte) 0 ;
10727 wxImage_RGBValue *result;
10728 PyObject * obj0 = 0 ;
10729 PyObject * obj1 = 0 ;
10730 PyObject * obj2 = 0 ;
10731 char *kwnames[] = {
10732 (char *) "r",(char *) "g",(char *) "b", NULL
10733 };
10734
10735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10736 if (obj0) {
10737 {
10738 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10739 if (SWIG_arg_fail(1)) SWIG_fail;
10740 }
10741 }
10742 if (obj1) {
10743 {
10744 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10745 if (SWIG_arg_fail(2)) SWIG_fail;
10746 }
10747 }
10748 if (obj2) {
10749 {
10750 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10751 if (SWIG_arg_fail(3)) SWIG_fail;
10752 }
10753 }
10754 {
10755 PyThreadState* __tstate = wxPyBeginAllowThreads();
10756 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10757
10758 wxPyEndAllowThreads(__tstate);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10762 return resultobj;
10763 fail:
10764 return NULL;
10765 }
10766
10767
10768 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10769 PyObject *resultobj = NULL;
10770 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10771 byte arg2 ;
10772 PyObject * obj0 = 0 ;
10773 PyObject * obj1 = 0 ;
10774 char *kwnames[] = {
10775 (char *) "self",(char *) "red", NULL
10776 };
10777
10778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10780 if (SWIG_arg_fail(1)) SWIG_fail;
10781 {
10782 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10783 if (SWIG_arg_fail(2)) SWIG_fail;
10784 }
10785 if (arg1) (arg1)->red = arg2;
10786
10787 Py_INCREF(Py_None); resultobj = Py_None;
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj = NULL;
10796 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10797 byte result;
10798 PyObject * obj0 = 0 ;
10799 char *kwnames[] = {
10800 (char *) "self", NULL
10801 };
10802
10803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10805 if (SWIG_arg_fail(1)) SWIG_fail;
10806 result = (byte) ((arg1)->red);
10807
10808 {
10809 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10810 }
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj = NULL;
10819 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10820 byte arg2 ;
10821 PyObject * obj0 = 0 ;
10822 PyObject * obj1 = 0 ;
10823 char *kwnames[] = {
10824 (char *) "self",(char *) "green", NULL
10825 };
10826
10827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10829 if (SWIG_arg_fail(1)) SWIG_fail;
10830 {
10831 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10832 if (SWIG_arg_fail(2)) SWIG_fail;
10833 }
10834 if (arg1) (arg1)->green = arg2;
10835
10836 Py_INCREF(Py_None); resultobj = Py_None;
10837 return resultobj;
10838 fail:
10839 return NULL;
10840 }
10841
10842
10843 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10844 PyObject *resultobj = NULL;
10845 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10846 byte result;
10847 PyObject * obj0 = 0 ;
10848 char *kwnames[] = {
10849 (char *) "self", NULL
10850 };
10851
10852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10854 if (SWIG_arg_fail(1)) SWIG_fail;
10855 result = (byte) ((arg1)->green);
10856
10857 {
10858 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10859 }
10860 return resultobj;
10861 fail:
10862 return NULL;
10863 }
10864
10865
10866 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10867 PyObject *resultobj = NULL;
10868 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10869 byte arg2 ;
10870 PyObject * obj0 = 0 ;
10871 PyObject * obj1 = 0 ;
10872 char *kwnames[] = {
10873 (char *) "self",(char *) "blue", NULL
10874 };
10875
10876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10878 if (SWIG_arg_fail(1)) SWIG_fail;
10879 {
10880 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10881 if (SWIG_arg_fail(2)) SWIG_fail;
10882 }
10883 if (arg1) (arg1)->blue = arg2;
10884
10885 Py_INCREF(Py_None); resultobj = Py_None;
10886 return resultobj;
10887 fail:
10888 return NULL;
10889 }
10890
10891
10892 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10893 PyObject *resultobj = NULL;
10894 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10895 byte result;
10896 PyObject * obj0 = 0 ;
10897 char *kwnames[] = {
10898 (char *) "self", NULL
10899 };
10900
10901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10903 if (SWIG_arg_fail(1)) SWIG_fail;
10904 result = (byte) ((arg1)->blue);
10905
10906 {
10907 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10908 }
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10916 PyObject *obj;
10917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10918 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10919 Py_INCREF(obj);
10920 return Py_BuildValue((char *)"");
10921 }
10922 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10923 PyObject *resultobj = NULL;
10924 double arg1 = (double) 0.0 ;
10925 double arg2 = (double) 0.0 ;
10926 double arg3 = (double) 0.0 ;
10927 wxImage_HSVValue *result;
10928 PyObject * obj0 = 0 ;
10929 PyObject * obj1 = 0 ;
10930 PyObject * obj2 = 0 ;
10931 char *kwnames[] = {
10932 (char *) "h",(char *) "s",(char *) "v", NULL
10933 };
10934
10935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10936 if (obj0) {
10937 {
10938 arg1 = static_cast<double >(SWIG_As_double(obj0));
10939 if (SWIG_arg_fail(1)) SWIG_fail;
10940 }
10941 }
10942 if (obj1) {
10943 {
10944 arg2 = static_cast<double >(SWIG_As_double(obj1));
10945 if (SWIG_arg_fail(2)) SWIG_fail;
10946 }
10947 }
10948 if (obj2) {
10949 {
10950 arg3 = static_cast<double >(SWIG_As_double(obj2));
10951 if (SWIG_arg_fail(3)) SWIG_fail;
10952 }
10953 }
10954 {
10955 PyThreadState* __tstate = wxPyBeginAllowThreads();
10956 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10957
10958 wxPyEndAllowThreads(__tstate);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10969 PyObject *resultobj = NULL;
10970 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10971 double arg2 ;
10972 PyObject * obj0 = 0 ;
10973 PyObject * obj1 = 0 ;
10974 char *kwnames[] = {
10975 (char *) "self",(char *) "hue", NULL
10976 };
10977
10978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10980 if (SWIG_arg_fail(1)) SWIG_fail;
10981 {
10982 arg2 = static_cast<double >(SWIG_As_double(obj1));
10983 if (SWIG_arg_fail(2)) SWIG_fail;
10984 }
10985 if (arg1) (arg1)->hue = arg2;
10986
10987 Py_INCREF(Py_None); resultobj = Py_None;
10988 return resultobj;
10989 fail:
10990 return NULL;
10991 }
10992
10993
10994 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10995 PyObject *resultobj = NULL;
10996 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10997 double result;
10998 PyObject * obj0 = 0 ;
10999 char *kwnames[] = {
11000 (char *) "self", NULL
11001 };
11002
11003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
11004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11005 if (SWIG_arg_fail(1)) SWIG_fail;
11006 result = (double) ((arg1)->hue);
11007
11008 {
11009 resultobj = SWIG_From_double(static_cast<double >(result));
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj = NULL;
11019 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11020 double arg2 ;
11021 PyObject * obj0 = 0 ;
11022 PyObject * obj1 = 0 ;
11023 char *kwnames[] = {
11024 (char *) "self",(char *) "saturation", NULL
11025 };
11026
11027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
11028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11029 if (SWIG_arg_fail(1)) SWIG_fail;
11030 {
11031 arg2 = static_cast<double >(SWIG_As_double(obj1));
11032 if (SWIG_arg_fail(2)) SWIG_fail;
11033 }
11034 if (arg1) (arg1)->saturation = arg2;
11035
11036 Py_INCREF(Py_None); resultobj = Py_None;
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj = NULL;
11045 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11046 double result;
11047 PyObject * obj0 = 0 ;
11048 char *kwnames[] = {
11049 (char *) "self", NULL
11050 };
11051
11052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
11053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11054 if (SWIG_arg_fail(1)) SWIG_fail;
11055 result = (double) ((arg1)->saturation);
11056
11057 {
11058 resultobj = SWIG_From_double(static_cast<double >(result));
11059 }
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj = NULL;
11068 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11069 double arg2 ;
11070 PyObject * obj0 = 0 ;
11071 PyObject * obj1 = 0 ;
11072 char *kwnames[] = {
11073 (char *) "self",(char *) "value", NULL
11074 };
11075
11076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11078 if (SWIG_arg_fail(1)) SWIG_fail;
11079 {
11080 arg2 = static_cast<double >(SWIG_As_double(obj1));
11081 if (SWIG_arg_fail(2)) SWIG_fail;
11082 }
11083 if (arg1) (arg1)->value = arg2;
11084
11085 Py_INCREF(Py_None); resultobj = Py_None;
11086 return resultobj;
11087 fail:
11088 return NULL;
11089 }
11090
11091
11092 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11093 PyObject *resultobj = NULL;
11094 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11095 double result;
11096 PyObject * obj0 = 0 ;
11097 char *kwnames[] = {
11098 (char *) "self", NULL
11099 };
11100
11101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11103 if (SWIG_arg_fail(1)) SWIG_fail;
11104 result = (double) ((arg1)->value);
11105
11106 {
11107 resultobj = SWIG_From_double(static_cast<double >(result));
11108 }
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11116 PyObject *obj;
11117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11118 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11119 Py_INCREF(obj);
11120 return Py_BuildValue((char *)"");
11121 }
11122 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11123 PyObject *resultobj = NULL;
11124 wxString *arg1 = 0 ;
11125 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11126 int arg3 = (int) -1 ;
11127 wxImage *result;
11128 bool temp1 = false ;
11129 PyObject * obj0 = 0 ;
11130 PyObject * obj1 = 0 ;
11131 PyObject * obj2 = 0 ;
11132 char *kwnames[] = {
11133 (char *) "name",(char *) "type",(char *) "index", NULL
11134 };
11135
11136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11137 {
11138 arg1 = wxString_in_helper(obj0);
11139 if (arg1 == NULL) SWIG_fail;
11140 temp1 = true;
11141 }
11142 if (obj1) {
11143 {
11144 arg2 = static_cast<long >(SWIG_As_long(obj1));
11145 if (SWIG_arg_fail(2)) SWIG_fail;
11146 }
11147 }
11148 if (obj2) {
11149 {
11150 arg3 = static_cast<int >(SWIG_As_int(obj2));
11151 if (SWIG_arg_fail(3)) SWIG_fail;
11152 }
11153 }
11154 {
11155 PyThreadState* __tstate = wxPyBeginAllowThreads();
11156 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11157
11158 wxPyEndAllowThreads(__tstate);
11159 if (PyErr_Occurred()) SWIG_fail;
11160 }
11161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11162 {
11163 if (temp1)
11164 delete arg1;
11165 }
11166 return resultobj;
11167 fail:
11168 {
11169 if (temp1)
11170 delete arg1;
11171 }
11172 return NULL;
11173 }
11174
11175
11176 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11177 PyObject *resultobj = NULL;
11178 wxImage *arg1 = (wxImage *) 0 ;
11179 PyObject * obj0 = 0 ;
11180 char *kwnames[] = {
11181 (char *) "self", NULL
11182 };
11183
11184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11186 if (SWIG_arg_fail(1)) SWIG_fail;
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 delete arg1;
11190
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 Py_INCREF(Py_None); resultobj = Py_None;
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj = NULL;
11203 wxString *arg1 = 0 ;
11204 wxString *arg2 = 0 ;
11205 int arg3 = (int) -1 ;
11206 wxImage *result;
11207 bool temp1 = false ;
11208 bool temp2 = false ;
11209 PyObject * obj0 = 0 ;
11210 PyObject * obj1 = 0 ;
11211 PyObject * obj2 = 0 ;
11212 char *kwnames[] = {
11213 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11214 };
11215
11216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11217 {
11218 arg1 = wxString_in_helper(obj0);
11219 if (arg1 == NULL) SWIG_fail;
11220 temp1 = true;
11221 }
11222 {
11223 arg2 = wxString_in_helper(obj1);
11224 if (arg2 == NULL) SWIG_fail;
11225 temp2 = true;
11226 }
11227 if (obj2) {
11228 {
11229 arg3 = static_cast<int >(SWIG_As_int(obj2));
11230 if (SWIG_arg_fail(3)) SWIG_fail;
11231 }
11232 }
11233 {
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11236
11237 wxPyEndAllowThreads(__tstate);
11238 if (PyErr_Occurred()) SWIG_fail;
11239 }
11240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11241 {
11242 if (temp1)
11243 delete arg1;
11244 }
11245 {
11246 if (temp2)
11247 delete arg2;
11248 }
11249 return resultobj;
11250 fail:
11251 {
11252 if (temp1)
11253 delete arg1;
11254 }
11255 {
11256 if (temp2)
11257 delete arg2;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = NULL;
11265 wxInputStream *arg1 = 0 ;
11266 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11267 int arg3 = (int) -1 ;
11268 wxImage *result;
11269 wxPyInputStream *temp1 ;
11270 bool created1 ;
11271 PyObject * obj0 = 0 ;
11272 PyObject * obj1 = 0 ;
11273 PyObject * obj2 = 0 ;
11274 char *kwnames[] = {
11275 (char *) "stream",(char *) "type",(char *) "index", NULL
11276 };
11277
11278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11279 {
11280 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11281 arg1 = temp1->m_wxis;
11282 created1 = false;
11283 } else {
11284 PyErr_Clear(); // clear the failure of the wxPyConvert above
11285 arg1 = wxPyCBInputStream_create(obj0, false);
11286 if (arg1 == NULL) {
11287 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11288 SWIG_fail;
11289 }
11290 created1 = true;
11291 }
11292 }
11293 if (obj1) {
11294 {
11295 arg2 = static_cast<long >(SWIG_As_long(obj1));
11296 if (SWIG_arg_fail(2)) SWIG_fail;
11297 }
11298 }
11299 if (obj2) {
11300 {
11301 arg3 = static_cast<int >(SWIG_As_int(obj2));
11302 if (SWIG_arg_fail(3)) SWIG_fail;
11303 }
11304 }
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11313 {
11314 if (created1) delete arg1;
11315 }
11316 return resultobj;
11317 fail:
11318 {
11319 if (created1) delete arg1;
11320 }
11321 return NULL;
11322 }
11323
11324
11325 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11326 PyObject *resultobj = NULL;
11327 wxInputStream *arg1 = 0 ;
11328 wxString *arg2 = 0 ;
11329 int arg3 = (int) -1 ;
11330 wxImage *result;
11331 wxPyInputStream *temp1 ;
11332 bool created1 ;
11333 bool temp2 = false ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 char *kwnames[] = {
11338 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11339 };
11340
11341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11342 {
11343 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11344 arg1 = temp1->m_wxis;
11345 created1 = false;
11346 } else {
11347 PyErr_Clear(); // clear the failure of the wxPyConvert above
11348 arg1 = wxPyCBInputStream_create(obj0, false);
11349 if (arg1 == NULL) {
11350 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11351 SWIG_fail;
11352 }
11353 created1 = true;
11354 }
11355 }
11356 {
11357 arg2 = wxString_in_helper(obj1);
11358 if (arg2 == NULL) SWIG_fail;
11359 temp2 = true;
11360 }
11361 if (obj2) {
11362 {
11363 arg3 = static_cast<int >(SWIG_As_int(obj2));
11364 if (SWIG_arg_fail(3)) SWIG_fail;
11365 }
11366 }
11367 {
11368 PyThreadState* __tstate = wxPyBeginAllowThreads();
11369 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11370
11371 wxPyEndAllowThreads(__tstate);
11372 if (PyErr_Occurred()) SWIG_fail;
11373 }
11374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11375 {
11376 if (created1) delete arg1;
11377 }
11378 {
11379 if (temp2)
11380 delete arg2;
11381 }
11382 return resultobj;
11383 fail:
11384 {
11385 if (created1) delete arg1;
11386 }
11387 {
11388 if (temp2)
11389 delete arg2;
11390 }
11391 return NULL;
11392 }
11393
11394
11395 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11396 PyObject *resultobj = NULL;
11397 int arg1 = (int) 0 ;
11398 int arg2 = (int) 0 ;
11399 bool arg3 = (bool) true ;
11400 wxImage *result;
11401 PyObject * obj0 = 0 ;
11402 PyObject * obj1 = 0 ;
11403 PyObject * obj2 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "width",(char *) "height",(char *) "clear", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11409 if (obj0) {
11410 {
11411 arg1 = static_cast<int >(SWIG_As_int(obj0));
11412 if (SWIG_arg_fail(1)) SWIG_fail;
11413 }
11414 }
11415 if (obj1) {
11416 {
11417 arg2 = static_cast<int >(SWIG_As_int(obj1));
11418 if (SWIG_arg_fail(2)) SWIG_fail;
11419 }
11420 }
11421 if (obj2) {
11422 {
11423 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11424 if (SWIG_arg_fail(3)) SWIG_fail;
11425 }
11426 }
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11430
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11435 return resultobj;
11436 fail:
11437 return NULL;
11438 }
11439
11440
11441 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11442 PyObject *resultobj = NULL;
11443 wxBitmap *arg1 = 0 ;
11444 wxImage *result;
11445 PyObject * obj0 = 0 ;
11446 char *kwnames[] = {
11447 (char *) "bitmap", NULL
11448 };
11449
11450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11451 {
11452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11453 if (SWIG_arg_fail(1)) SWIG_fail;
11454 if (arg1 == NULL) {
11455 SWIG_null_ref("wxBitmap");
11456 }
11457 if (SWIG_arg_fail(1)) SWIG_fail;
11458 }
11459 {
11460 if (!wxPyCheckForApp()) SWIG_fail;
11461 PyThreadState* __tstate = wxPyBeginAllowThreads();
11462 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11463
11464 wxPyEndAllowThreads(__tstate);
11465 if (PyErr_Occurred()) SWIG_fail;
11466 }
11467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11468 return resultobj;
11469 fail:
11470 return NULL;
11471 }
11472
11473
11474 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11475 PyObject *resultobj = NULL;
11476 int arg1 ;
11477 int arg2 ;
11478 buffer arg3 ;
11479 int arg4 ;
11480 wxImage *result;
11481 PyObject * obj0 = 0 ;
11482 PyObject * obj1 = 0 ;
11483 PyObject * obj2 = 0 ;
11484 char *kwnames[] = {
11485 (char *) "width",(char *) "height",(char *) "data", NULL
11486 };
11487
11488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11489 {
11490 arg1 = static_cast<int >(SWIG_As_int(obj0));
11491 if (SWIG_arg_fail(1)) SWIG_fail;
11492 }
11493 {
11494 arg2 = static_cast<int >(SWIG_As_int(obj1));
11495 if (SWIG_arg_fail(2)) SWIG_fail;
11496 }
11497 {
11498 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11499 }
11500 {
11501 PyThreadState* __tstate = wxPyBeginAllowThreads();
11502 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11503
11504 wxPyEndAllowThreads(__tstate);
11505 if (PyErr_Occurred()) SWIG_fail;
11506 }
11507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11508 return resultobj;
11509 fail:
11510 return NULL;
11511 }
11512
11513
11514 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11515 PyObject *resultobj = NULL;
11516 int arg1 ;
11517 int arg2 ;
11518 buffer arg3 ;
11519 int arg4 ;
11520 buffer arg5 ;
11521 int arg6 ;
11522 wxImage *result;
11523 PyObject * obj0 = 0 ;
11524 PyObject * obj1 = 0 ;
11525 PyObject * obj2 = 0 ;
11526 PyObject * obj3 = 0 ;
11527 char *kwnames[] = {
11528 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11529 };
11530
11531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11532 {
11533 arg1 = static_cast<int >(SWIG_As_int(obj0));
11534 if (SWIG_arg_fail(1)) SWIG_fail;
11535 }
11536 {
11537 arg2 = static_cast<int >(SWIG_As_int(obj1));
11538 if (SWIG_arg_fail(2)) SWIG_fail;
11539 }
11540 {
11541 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11542 }
11543 {
11544 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11545 }
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11549
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11554 return resultobj;
11555 fail:
11556 return NULL;
11557 }
11558
11559
11560 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11561 PyObject *resultobj = NULL;
11562 wxImage *arg1 = (wxImage *) 0 ;
11563 int arg2 ;
11564 int arg3 ;
11565 bool arg4 = (bool) true ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 PyObject * obj2 = 0 ;
11569 PyObject * obj3 = 0 ;
11570 char *kwnames[] = {
11571 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11572 };
11573
11574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11576 if (SWIG_arg_fail(1)) SWIG_fail;
11577 {
11578 arg2 = static_cast<int >(SWIG_As_int(obj1));
11579 if (SWIG_arg_fail(2)) SWIG_fail;
11580 }
11581 {
11582 arg3 = static_cast<int >(SWIG_As_int(obj2));
11583 if (SWIG_arg_fail(3)) SWIG_fail;
11584 }
11585 if (obj3) {
11586 {
11587 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11588 if (SWIG_arg_fail(4)) SWIG_fail;
11589 }
11590 }
11591 {
11592 PyThreadState* __tstate = wxPyBeginAllowThreads();
11593 (arg1)->Create(arg2,arg3,arg4);
11594
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 Py_INCREF(Py_None); resultobj = Py_None;
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj = NULL;
11607 wxImage *arg1 = (wxImage *) 0 ;
11608 PyObject * obj0 = 0 ;
11609 char *kwnames[] = {
11610 (char *) "self", NULL
11611 };
11612
11613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11615 if (SWIG_arg_fail(1)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 (arg1)->Destroy();
11619
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 Py_INCREF(Py_None); resultobj = Py_None;
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj = NULL;
11632 wxImage *arg1 = (wxImage *) 0 ;
11633 int arg2 ;
11634 int arg3 ;
11635 SwigValueWrapper<wxImage > result;
11636 PyObject * obj0 = 0 ;
11637 PyObject * obj1 = 0 ;
11638 PyObject * obj2 = 0 ;
11639 char *kwnames[] = {
11640 (char *) "self",(char *) "width",(char *) "height", NULL
11641 };
11642
11643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11645 if (SWIG_arg_fail(1)) SWIG_fail;
11646 {
11647 arg2 = static_cast<int >(SWIG_As_int(obj1));
11648 if (SWIG_arg_fail(2)) SWIG_fail;
11649 }
11650 {
11651 arg3 = static_cast<int >(SWIG_As_int(obj2));
11652 if (SWIG_arg_fail(3)) SWIG_fail;
11653 }
11654 {
11655 PyThreadState* __tstate = wxPyBeginAllowThreads();
11656 result = (arg1)->Scale(arg2,arg3);
11657
11658 wxPyEndAllowThreads(__tstate);
11659 if (PyErr_Occurred()) SWIG_fail;
11660 }
11661 {
11662 wxImage * resultptr;
11663 resultptr = new wxImage(static_cast<wxImage & >(result));
11664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj = NULL;
11674 wxImage *arg1 = (wxImage *) 0 ;
11675 int arg2 ;
11676 int arg3 ;
11677 SwigValueWrapper<wxImage > result;
11678 PyObject * obj0 = 0 ;
11679 PyObject * obj1 = 0 ;
11680 PyObject * obj2 = 0 ;
11681 char *kwnames[] = {
11682 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11683 };
11684
11685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11687 if (SWIG_arg_fail(1)) SWIG_fail;
11688 {
11689 arg2 = static_cast<int >(SWIG_As_int(obj1));
11690 if (SWIG_arg_fail(2)) SWIG_fail;
11691 }
11692 {
11693 arg3 = static_cast<int >(SWIG_As_int(obj2));
11694 if (SWIG_arg_fail(3)) SWIG_fail;
11695 }
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11699
11700 wxPyEndAllowThreads(__tstate);
11701 if (PyErr_Occurred()) SWIG_fail;
11702 }
11703 {
11704 wxImage * resultptr;
11705 resultptr = new wxImage(static_cast<wxImage & >(result));
11706 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11707 }
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11715 PyObject *resultobj = NULL;
11716 wxImage *arg1 = (wxImage *) 0 ;
11717 int arg2 ;
11718 int arg3 ;
11719 wxImage *result;
11720 PyObject * obj0 = 0 ;
11721 PyObject * obj1 = 0 ;
11722 PyObject * obj2 = 0 ;
11723 char *kwnames[] = {
11724 (char *) "self",(char *) "width",(char *) "height", NULL
11725 };
11726
11727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11729 if (SWIG_arg_fail(1)) SWIG_fail;
11730 {
11731 arg2 = static_cast<int >(SWIG_As_int(obj1));
11732 if (SWIG_arg_fail(2)) SWIG_fail;
11733 }
11734 {
11735 arg3 = static_cast<int >(SWIG_As_int(obj2));
11736 if (SWIG_arg_fail(3)) SWIG_fail;
11737 }
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 {
11741 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11742 result = (wxImage *) &_result_ref;
11743 }
11744
11745 wxPyEndAllowThreads(__tstate);
11746 if (PyErr_Occurred()) SWIG_fail;
11747 }
11748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11749 return resultobj;
11750 fail:
11751 return NULL;
11752 }
11753
11754
11755 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11756 PyObject *resultobj = NULL;
11757 wxImage *arg1 = (wxImage *) 0 ;
11758 wxSize *arg2 = 0 ;
11759 wxPoint *arg3 = 0 ;
11760 int arg4 = (int) -1 ;
11761 int arg5 = (int) -1 ;
11762 int arg6 = (int) -1 ;
11763 wxImage *result;
11764 wxSize temp2 ;
11765 wxPoint temp3 ;
11766 PyObject * obj0 = 0 ;
11767 PyObject * obj1 = 0 ;
11768 PyObject * obj2 = 0 ;
11769 PyObject * obj3 = 0 ;
11770 PyObject * obj4 = 0 ;
11771 PyObject * obj5 = 0 ;
11772 char *kwnames[] = {
11773 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11774 };
11775
11776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11778 if (SWIG_arg_fail(1)) SWIG_fail;
11779 {
11780 arg2 = &temp2;
11781 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11782 }
11783 {
11784 arg3 = &temp3;
11785 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11786 }
11787 if (obj3) {
11788 {
11789 arg4 = static_cast<int >(SWIG_As_int(obj3));
11790 if (SWIG_arg_fail(4)) SWIG_fail;
11791 }
11792 }
11793 if (obj4) {
11794 {
11795 arg5 = static_cast<int >(SWIG_As_int(obj4));
11796 if (SWIG_arg_fail(5)) SWIG_fail;
11797 }
11798 }
11799 if (obj5) {
11800 {
11801 arg6 = static_cast<int >(SWIG_As_int(obj5));
11802 if (SWIG_arg_fail(6)) SWIG_fail;
11803 }
11804 }
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 {
11808 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11809 result = (wxImage *) &_result_ref;
11810 }
11811
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11823 PyObject *resultobj = NULL;
11824 wxImage *arg1 = (wxImage *) 0 ;
11825 int arg2 ;
11826 int arg3 ;
11827 byte arg4 ;
11828 byte arg5 ;
11829 byte arg6 ;
11830 PyObject * obj0 = 0 ;
11831 PyObject * obj1 = 0 ;
11832 PyObject * obj2 = 0 ;
11833 PyObject * obj3 = 0 ;
11834 PyObject * obj4 = 0 ;
11835 PyObject * obj5 = 0 ;
11836 char *kwnames[] = {
11837 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11838 };
11839
11840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11842 if (SWIG_arg_fail(1)) SWIG_fail;
11843 {
11844 arg2 = static_cast<int >(SWIG_As_int(obj1));
11845 if (SWIG_arg_fail(2)) SWIG_fail;
11846 }
11847 {
11848 arg3 = static_cast<int >(SWIG_As_int(obj2));
11849 if (SWIG_arg_fail(3)) SWIG_fail;
11850 }
11851 {
11852 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11853 if (SWIG_arg_fail(4)) SWIG_fail;
11854 }
11855 {
11856 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11857 if (SWIG_arg_fail(5)) SWIG_fail;
11858 }
11859 {
11860 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11861 if (SWIG_arg_fail(6)) SWIG_fail;
11862 }
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11866
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 Py_INCREF(Py_None); resultobj = Py_None;
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11878 PyObject *resultobj = NULL;
11879 wxImage *arg1 = (wxImage *) 0 ;
11880 wxRect *arg2 = 0 ;
11881 byte arg3 ;
11882 byte arg4 ;
11883 byte arg5 ;
11884 wxRect temp2 ;
11885 PyObject * obj0 = 0 ;
11886 PyObject * obj1 = 0 ;
11887 PyObject * obj2 = 0 ;
11888 PyObject * obj3 = 0 ;
11889 PyObject * obj4 = 0 ;
11890 char *kwnames[] = {
11891 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11892 };
11893
11894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11896 if (SWIG_arg_fail(1)) SWIG_fail;
11897 {
11898 arg2 = &temp2;
11899 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11900 }
11901 {
11902 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11903 if (SWIG_arg_fail(3)) SWIG_fail;
11904 }
11905 {
11906 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11907 if (SWIG_arg_fail(4)) SWIG_fail;
11908 }
11909 {
11910 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11911 if (SWIG_arg_fail(5)) SWIG_fail;
11912 }
11913 {
11914 PyThreadState* __tstate = wxPyBeginAllowThreads();
11915 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11916
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 Py_INCREF(Py_None); resultobj = Py_None;
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11928 PyObject *resultobj = NULL;
11929 wxImage *arg1 = (wxImage *) 0 ;
11930 int arg2 ;
11931 int arg3 ;
11932 byte result;
11933 PyObject * obj0 = 0 ;
11934 PyObject * obj1 = 0 ;
11935 PyObject * obj2 = 0 ;
11936 char *kwnames[] = {
11937 (char *) "self",(char *) "x",(char *) "y", NULL
11938 };
11939
11940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11942 if (SWIG_arg_fail(1)) SWIG_fail;
11943 {
11944 arg2 = static_cast<int >(SWIG_As_int(obj1));
11945 if (SWIG_arg_fail(2)) SWIG_fail;
11946 }
11947 {
11948 arg3 = static_cast<int >(SWIG_As_int(obj2));
11949 if (SWIG_arg_fail(3)) SWIG_fail;
11950 }
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (byte)(arg1)->GetRed(arg2,arg3);
11954
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11960 }
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11968 PyObject *resultobj = NULL;
11969 wxImage *arg1 = (wxImage *) 0 ;
11970 int arg2 ;
11971 int arg3 ;
11972 byte result;
11973 PyObject * obj0 = 0 ;
11974 PyObject * obj1 = 0 ;
11975 PyObject * obj2 = 0 ;
11976 char *kwnames[] = {
11977 (char *) "self",(char *) "x",(char *) "y", NULL
11978 };
11979
11980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11982 if (SWIG_arg_fail(1)) SWIG_fail;
11983 {
11984 arg2 = static_cast<int >(SWIG_As_int(obj1));
11985 if (SWIG_arg_fail(2)) SWIG_fail;
11986 }
11987 {
11988 arg3 = static_cast<int >(SWIG_As_int(obj2));
11989 if (SWIG_arg_fail(3)) SWIG_fail;
11990 }
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = (byte)(arg1)->GetGreen(arg2,arg3);
11994
11995 wxPyEndAllowThreads(__tstate);
11996 if (PyErr_Occurred()) SWIG_fail;
11997 }
11998 {
11999 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12000 }
12001 return resultobj;
12002 fail:
12003 return NULL;
12004 }
12005
12006
12007 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12008 PyObject *resultobj = NULL;
12009 wxImage *arg1 = (wxImage *) 0 ;
12010 int arg2 ;
12011 int arg3 ;
12012 byte result;
12013 PyObject * obj0 = 0 ;
12014 PyObject * obj1 = 0 ;
12015 PyObject * obj2 = 0 ;
12016 char *kwnames[] = {
12017 (char *) "self",(char *) "x",(char *) "y", NULL
12018 };
12019
12020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12022 if (SWIG_arg_fail(1)) SWIG_fail;
12023 {
12024 arg2 = static_cast<int >(SWIG_As_int(obj1));
12025 if (SWIG_arg_fail(2)) SWIG_fail;
12026 }
12027 {
12028 arg3 = static_cast<int >(SWIG_As_int(obj2));
12029 if (SWIG_arg_fail(3)) SWIG_fail;
12030 }
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = (byte)(arg1)->GetBlue(arg2,arg3);
12034
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12040 }
12041 return resultobj;
12042 fail:
12043 return NULL;
12044 }
12045
12046
12047 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj = NULL;
12049 wxImage *arg1 = (wxImage *) 0 ;
12050 int arg2 ;
12051 int arg3 ;
12052 byte arg4 ;
12053 PyObject * obj0 = 0 ;
12054 PyObject * obj1 = 0 ;
12055 PyObject * obj2 = 0 ;
12056 PyObject * obj3 = 0 ;
12057 char *kwnames[] = {
12058 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12059 };
12060
12061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12063 if (SWIG_arg_fail(1)) SWIG_fail;
12064 {
12065 arg2 = static_cast<int >(SWIG_As_int(obj1));
12066 if (SWIG_arg_fail(2)) SWIG_fail;
12067 }
12068 {
12069 arg3 = static_cast<int >(SWIG_As_int(obj2));
12070 if (SWIG_arg_fail(3)) SWIG_fail;
12071 }
12072 {
12073 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12074 if (SWIG_arg_fail(4)) SWIG_fail;
12075 }
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 (arg1)->SetAlpha(arg2,arg3,arg4);
12079
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 Py_INCREF(Py_None); resultobj = Py_None;
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12091 PyObject *resultobj = NULL;
12092 wxImage *arg1 = (wxImage *) 0 ;
12093 int arg2 ;
12094 int arg3 ;
12095 byte result;
12096 PyObject * obj0 = 0 ;
12097 PyObject * obj1 = 0 ;
12098 PyObject * obj2 = 0 ;
12099 char *kwnames[] = {
12100 (char *) "self",(char *) "x",(char *) "y", NULL
12101 };
12102
12103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12105 if (SWIG_arg_fail(1)) SWIG_fail;
12106 {
12107 arg2 = static_cast<int >(SWIG_As_int(obj1));
12108 if (SWIG_arg_fail(2)) SWIG_fail;
12109 }
12110 {
12111 arg3 = static_cast<int >(SWIG_As_int(obj2));
12112 if (SWIG_arg_fail(3)) SWIG_fail;
12113 }
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12117
12118 wxPyEndAllowThreads(__tstate);
12119 if (PyErr_Occurred()) SWIG_fail;
12120 }
12121 {
12122 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12123 }
12124 return resultobj;
12125 fail:
12126 return NULL;
12127 }
12128
12129
12130 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12131 PyObject *resultobj = NULL;
12132 wxImage *arg1 = (wxImage *) 0 ;
12133 bool result;
12134 PyObject * obj0 = 0 ;
12135 char *kwnames[] = {
12136 (char *) "self", NULL
12137 };
12138
12139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12141 if (SWIG_arg_fail(1)) SWIG_fail;
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 result = (bool)(arg1)->HasAlpha();
12145
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 {
12150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12151 }
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj = NULL;
12160 wxImage *arg1 = (wxImage *) 0 ;
12161 PyObject * obj0 = 0 ;
12162 char *kwnames[] = {
12163 (char *) "self", NULL
12164 };
12165
12166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12168 if (SWIG_arg_fail(1)) SWIG_fail;
12169 {
12170 PyThreadState* __tstate = wxPyBeginAllowThreads();
12171 (arg1)->InitAlpha();
12172
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
12176 Py_INCREF(Py_None); resultobj = Py_None;
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj = NULL;
12185 wxImage *arg1 = (wxImage *) 0 ;
12186 int arg2 ;
12187 int arg3 ;
12188 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12189 bool result;
12190 PyObject * obj0 = 0 ;
12191 PyObject * obj1 = 0 ;
12192 PyObject * obj2 = 0 ;
12193 PyObject * obj3 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12200 if (SWIG_arg_fail(1)) SWIG_fail;
12201 {
12202 arg2 = static_cast<int >(SWIG_As_int(obj1));
12203 if (SWIG_arg_fail(2)) SWIG_fail;
12204 }
12205 {
12206 arg3 = static_cast<int >(SWIG_As_int(obj2));
12207 if (SWIG_arg_fail(3)) SWIG_fail;
12208 }
12209 if (obj3) {
12210 {
12211 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12212 if (SWIG_arg_fail(4)) SWIG_fail;
12213 }
12214 }
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12224 }
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = NULL;
12233 wxImage *arg1 = (wxImage *) 0 ;
12234 byte *arg2 = (byte *) 0 ;
12235 byte *arg3 = (byte *) 0 ;
12236 byte *arg4 = (byte *) 0 ;
12237 byte arg5 = (byte) 0 ;
12238 byte arg6 = (byte) 0 ;
12239 byte arg7 = (byte) 0 ;
12240 bool result;
12241 byte temp2 ;
12242 int res2 = 0 ;
12243 byte temp3 ;
12244 int res3 = 0 ;
12245 byte temp4 ;
12246 int res4 = 0 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 PyObject * obj2 = 0 ;
12250 PyObject * obj3 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12253 };
12254
12255 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12256 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12257 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12260 if (SWIG_arg_fail(1)) SWIG_fail;
12261 if (obj1) {
12262 {
12263 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12264 if (SWIG_arg_fail(5)) SWIG_fail;
12265 }
12266 }
12267 if (obj2) {
12268 {
12269 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12270 if (SWIG_arg_fail(6)) SWIG_fail;
12271 }
12272 }
12273 if (obj3) {
12274 {
12275 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12276 if (SWIG_arg_fail(7)) SWIG_fail;
12277 }
12278 }
12279 {
12280 PyThreadState* __tstate = wxPyBeginAllowThreads();
12281 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12282
12283 wxPyEndAllowThreads(__tstate);
12284 if (PyErr_Occurred()) SWIG_fail;
12285 }
12286 {
12287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12288 }
12289 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12290 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12291 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12292 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12293 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12294 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj = NULL;
12303 wxImage *arg1 = (wxImage *) 0 ;
12304 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12305 bool result;
12306 PyObject * obj0 = 0 ;
12307 PyObject * obj1 = 0 ;
12308 char *kwnames[] = {
12309 (char *) "self",(char *) "threshold", NULL
12310 };
12311
12312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12314 if (SWIG_arg_fail(1)) SWIG_fail;
12315 if (obj1) {
12316 {
12317 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12318 if (SWIG_arg_fail(2)) SWIG_fail;
12319 }
12320 }
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12324
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 {
12329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12330 }
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj = NULL;
12339 wxImage *arg1 = (wxImage *) 0 ;
12340 byte arg2 ;
12341 byte arg3 ;
12342 byte arg4 ;
12343 bool result;
12344 PyObject * obj0 = 0 ;
12345 PyObject * obj1 = 0 ;
12346 PyObject * obj2 = 0 ;
12347 PyObject * obj3 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12354 if (SWIG_arg_fail(1)) SWIG_fail;
12355 {
12356 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12357 if (SWIG_arg_fail(2)) SWIG_fail;
12358 }
12359 {
12360 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12361 if (SWIG_arg_fail(3)) SWIG_fail;
12362 }
12363 {
12364 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12365 if (SWIG_arg_fail(4)) SWIG_fail;
12366 }
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12370
12371 wxPyEndAllowThreads(__tstate);
12372 if (PyErr_Occurred()) SWIG_fail;
12373 }
12374 {
12375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12376 }
12377 return resultobj;
12378 fail:
12379 return NULL;
12380 }
12381
12382
12383 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj = NULL;
12385 wxImage *arg1 = (wxImage *) 0 ;
12386 wxImage *arg2 = 0 ;
12387 byte arg3 ;
12388 byte arg4 ;
12389 byte arg5 ;
12390 bool result;
12391 PyObject * obj0 = 0 ;
12392 PyObject * obj1 = 0 ;
12393 PyObject * obj2 = 0 ;
12394 PyObject * obj3 = 0 ;
12395 PyObject * obj4 = 0 ;
12396 char *kwnames[] = {
12397 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12398 };
12399
12400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12402 if (SWIG_arg_fail(1)) SWIG_fail;
12403 {
12404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12405 if (SWIG_arg_fail(2)) SWIG_fail;
12406 if (arg2 == NULL) {
12407 SWIG_null_ref("wxImage");
12408 }
12409 if (SWIG_arg_fail(2)) SWIG_fail;
12410 }
12411 {
12412 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12413 if (SWIG_arg_fail(3)) SWIG_fail;
12414 }
12415 {
12416 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12417 if (SWIG_arg_fail(4)) SWIG_fail;
12418 }
12419 {
12420 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12421 if (SWIG_arg_fail(5)) SWIG_fail;
12422 }
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12426
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 {
12431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12432 }
12433 return resultobj;
12434 fail:
12435 return NULL;
12436 }
12437
12438
12439 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12440 PyObject *resultobj = NULL;
12441 wxString *arg1 = 0 ;
12442 bool result;
12443 bool temp1 = false ;
12444 PyObject * obj0 = 0 ;
12445 char *kwnames[] = {
12446 (char *) "filename", NULL
12447 };
12448
12449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12450 {
12451 arg1 = wxString_in_helper(obj0);
12452 if (arg1 == NULL) SWIG_fail;
12453 temp1 = true;
12454 }
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12458
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 {
12463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12464 }
12465 {
12466 if (temp1)
12467 delete arg1;
12468 }
12469 return resultobj;
12470 fail:
12471 {
12472 if (temp1)
12473 delete arg1;
12474 }
12475 return NULL;
12476 }
12477
12478
12479 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj = NULL;
12481 wxString *arg1 = 0 ;
12482 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12483 int result;
12484 bool temp1 = false ;
12485 PyObject * obj0 = 0 ;
12486 PyObject * obj1 = 0 ;
12487 char *kwnames[] = {
12488 (char *) "filename",(char *) "type", NULL
12489 };
12490
12491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12492 {
12493 arg1 = wxString_in_helper(obj0);
12494 if (arg1 == NULL) SWIG_fail;
12495 temp1 = true;
12496 }
12497 if (obj1) {
12498 {
12499 arg2 = static_cast<long >(SWIG_As_long(obj1));
12500 if (SWIG_arg_fail(2)) SWIG_fail;
12501 }
12502 }
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12506
12507 wxPyEndAllowThreads(__tstate);
12508 if (PyErr_Occurred()) SWIG_fail;
12509 }
12510 {
12511 resultobj = SWIG_From_int(static_cast<int >(result));
12512 }
12513 {
12514 if (temp1)
12515 delete arg1;
12516 }
12517 return resultobj;
12518 fail:
12519 {
12520 if (temp1)
12521 delete arg1;
12522 }
12523 return NULL;
12524 }
12525
12526
12527 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12528 PyObject *resultobj = NULL;
12529 wxImage *arg1 = (wxImage *) 0 ;
12530 wxString *arg2 = 0 ;
12531 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12532 int arg4 = (int) -1 ;
12533 bool result;
12534 bool temp2 = false ;
12535 PyObject * obj0 = 0 ;
12536 PyObject * obj1 = 0 ;
12537 PyObject * obj2 = 0 ;
12538 PyObject * obj3 = 0 ;
12539 char *kwnames[] = {
12540 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12541 };
12542
12543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12545 if (SWIG_arg_fail(1)) SWIG_fail;
12546 {
12547 arg2 = wxString_in_helper(obj1);
12548 if (arg2 == NULL) SWIG_fail;
12549 temp2 = true;
12550 }
12551 if (obj2) {
12552 {
12553 arg3 = static_cast<long >(SWIG_As_long(obj2));
12554 if (SWIG_arg_fail(3)) SWIG_fail;
12555 }
12556 }
12557 if (obj3) {
12558 {
12559 arg4 = static_cast<int >(SWIG_As_int(obj3));
12560 if (SWIG_arg_fail(4)) SWIG_fail;
12561 }
12562 }
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 {
12571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12572 }
12573 {
12574 if (temp2)
12575 delete arg2;
12576 }
12577 return resultobj;
12578 fail:
12579 {
12580 if (temp2)
12581 delete arg2;
12582 }
12583 return NULL;
12584 }
12585
12586
12587 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj = NULL;
12589 wxImage *arg1 = (wxImage *) 0 ;
12590 wxString *arg2 = 0 ;
12591 wxString *arg3 = 0 ;
12592 int arg4 = (int) -1 ;
12593 bool result;
12594 bool temp2 = false ;
12595 bool temp3 = false ;
12596 PyObject * obj0 = 0 ;
12597 PyObject * obj1 = 0 ;
12598 PyObject * obj2 = 0 ;
12599 PyObject * obj3 = 0 ;
12600 char *kwnames[] = {
12601 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12602 };
12603
12604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(1)) SWIG_fail;
12607 {
12608 arg2 = wxString_in_helper(obj1);
12609 if (arg2 == NULL) SWIG_fail;
12610 temp2 = true;
12611 }
12612 {
12613 arg3 = wxString_in_helper(obj2);
12614 if (arg3 == NULL) SWIG_fail;
12615 temp3 = true;
12616 }
12617 if (obj3) {
12618 {
12619 arg4 = static_cast<int >(SWIG_As_int(obj3));
12620 if (SWIG_arg_fail(4)) SWIG_fail;
12621 }
12622 }
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12626
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 {
12631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12632 }
12633 {
12634 if (temp2)
12635 delete arg2;
12636 }
12637 {
12638 if (temp3)
12639 delete arg3;
12640 }
12641 return resultobj;
12642 fail:
12643 {
12644 if (temp2)
12645 delete arg2;
12646 }
12647 {
12648 if (temp3)
12649 delete arg3;
12650 }
12651 return NULL;
12652 }
12653
12654
12655 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12656 PyObject *resultobj = NULL;
12657 wxImage *arg1 = (wxImage *) 0 ;
12658 wxString *arg2 = 0 ;
12659 int arg3 ;
12660 bool result;
12661 bool temp2 = false ;
12662 PyObject * obj0 = 0 ;
12663 PyObject * obj1 = 0 ;
12664 PyObject * obj2 = 0 ;
12665 char *kwnames[] = {
12666 (char *) "self",(char *) "name",(char *) "type", NULL
12667 };
12668
12669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12671 if (SWIG_arg_fail(1)) SWIG_fail;
12672 {
12673 arg2 = wxString_in_helper(obj1);
12674 if (arg2 == NULL) SWIG_fail;
12675 temp2 = true;
12676 }
12677 {
12678 arg3 = static_cast<int >(SWIG_As_int(obj2));
12679 if (SWIG_arg_fail(3)) SWIG_fail;
12680 }
12681 {
12682 PyThreadState* __tstate = wxPyBeginAllowThreads();
12683 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12684
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 {
12689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12690 }
12691 {
12692 if (temp2)
12693 delete arg2;
12694 }
12695 return resultobj;
12696 fail:
12697 {
12698 if (temp2)
12699 delete arg2;
12700 }
12701 return NULL;
12702 }
12703
12704
12705 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12706 PyObject *resultobj = NULL;
12707 wxImage *arg1 = (wxImage *) 0 ;
12708 wxString *arg2 = 0 ;
12709 wxString *arg3 = 0 ;
12710 bool result;
12711 bool temp2 = false ;
12712 bool temp3 = false ;
12713 PyObject * obj0 = 0 ;
12714 PyObject * obj1 = 0 ;
12715 PyObject * obj2 = 0 ;
12716 char *kwnames[] = {
12717 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12718 };
12719
12720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12722 if (SWIG_arg_fail(1)) SWIG_fail;
12723 {
12724 arg2 = wxString_in_helper(obj1);
12725 if (arg2 == NULL) SWIG_fail;
12726 temp2 = true;
12727 }
12728 {
12729 arg3 = wxString_in_helper(obj2);
12730 if (arg3 == NULL) SWIG_fail;
12731 temp3 = true;
12732 }
12733 {
12734 PyThreadState* __tstate = wxPyBeginAllowThreads();
12735 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12736
12737 wxPyEndAllowThreads(__tstate);
12738 if (PyErr_Occurred()) SWIG_fail;
12739 }
12740 {
12741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12742 }
12743 {
12744 if (temp2)
12745 delete arg2;
12746 }
12747 {
12748 if (temp3)
12749 delete arg3;
12750 }
12751 return resultobj;
12752 fail:
12753 {
12754 if (temp2)
12755 delete arg2;
12756 }
12757 {
12758 if (temp3)
12759 delete arg3;
12760 }
12761 return NULL;
12762 }
12763
12764
12765 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj = NULL;
12767 wxInputStream *arg1 = 0 ;
12768 bool result;
12769 wxPyInputStream *temp1 ;
12770 bool created1 ;
12771 PyObject * obj0 = 0 ;
12772 char *kwnames[] = {
12773 (char *) "stream", NULL
12774 };
12775
12776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12777 {
12778 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12779 arg1 = temp1->m_wxis;
12780 created1 = false;
12781 } else {
12782 PyErr_Clear(); // clear the failure of the wxPyConvert above
12783 arg1 = wxPyCBInputStream_create(obj0, false);
12784 if (arg1 == NULL) {
12785 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12786 SWIG_fail;
12787 }
12788 created1 = true;
12789 }
12790 }
12791 {
12792 PyThreadState* __tstate = wxPyBeginAllowThreads();
12793 result = (bool)wxImage::CanRead(*arg1);
12794
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 {
12799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12800 }
12801 {
12802 if (created1) delete arg1;
12803 }
12804 return resultobj;
12805 fail:
12806 {
12807 if (created1) delete arg1;
12808 }
12809 return NULL;
12810 }
12811
12812
12813 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj = NULL;
12815 wxImage *arg1 = (wxImage *) 0 ;
12816 wxInputStream *arg2 = 0 ;
12817 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12818 int arg4 = (int) -1 ;
12819 bool result;
12820 wxPyInputStream *temp2 ;
12821 bool created2 ;
12822 PyObject * obj0 = 0 ;
12823 PyObject * obj1 = 0 ;
12824 PyObject * obj2 = 0 ;
12825 PyObject * obj3 = 0 ;
12826 char *kwnames[] = {
12827 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12828 };
12829
12830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12832 if (SWIG_arg_fail(1)) SWIG_fail;
12833 {
12834 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12835 arg2 = temp2->m_wxis;
12836 created2 = false;
12837 } else {
12838 PyErr_Clear(); // clear the failure of the wxPyConvert above
12839 arg2 = wxPyCBInputStream_create(obj1, false);
12840 if (arg2 == NULL) {
12841 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12842 SWIG_fail;
12843 }
12844 created2 = true;
12845 }
12846 }
12847 if (obj2) {
12848 {
12849 arg3 = static_cast<long >(SWIG_As_long(obj2));
12850 if (SWIG_arg_fail(3)) SWIG_fail;
12851 }
12852 }
12853 if (obj3) {
12854 {
12855 arg4 = static_cast<int >(SWIG_As_int(obj3));
12856 if (SWIG_arg_fail(4)) SWIG_fail;
12857 }
12858 }
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12862
12863 wxPyEndAllowThreads(__tstate);
12864 if (PyErr_Occurred()) SWIG_fail;
12865 }
12866 {
12867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12868 }
12869 {
12870 if (created2) delete arg2;
12871 }
12872 return resultobj;
12873 fail:
12874 {
12875 if (created2) delete arg2;
12876 }
12877 return NULL;
12878 }
12879
12880
12881 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12882 PyObject *resultobj = NULL;
12883 wxImage *arg1 = (wxImage *) 0 ;
12884 wxInputStream *arg2 = 0 ;
12885 wxString *arg3 = 0 ;
12886 int arg4 = (int) -1 ;
12887 bool result;
12888 wxPyInputStream *temp2 ;
12889 bool created2 ;
12890 bool temp3 = false ;
12891 PyObject * obj0 = 0 ;
12892 PyObject * obj1 = 0 ;
12893 PyObject * obj2 = 0 ;
12894 PyObject * obj3 = 0 ;
12895 char *kwnames[] = {
12896 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12897 };
12898
12899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12901 if (SWIG_arg_fail(1)) SWIG_fail;
12902 {
12903 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12904 arg2 = temp2->m_wxis;
12905 created2 = false;
12906 } else {
12907 PyErr_Clear(); // clear the failure of the wxPyConvert above
12908 arg2 = wxPyCBInputStream_create(obj1, false);
12909 if (arg2 == NULL) {
12910 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12911 SWIG_fail;
12912 }
12913 created2 = true;
12914 }
12915 }
12916 {
12917 arg3 = wxString_in_helper(obj2);
12918 if (arg3 == NULL) SWIG_fail;
12919 temp3 = true;
12920 }
12921 if (obj3) {
12922 {
12923 arg4 = static_cast<int >(SWIG_As_int(obj3));
12924 if (SWIG_arg_fail(4)) SWIG_fail;
12925 }
12926 }
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12930
12931 wxPyEndAllowThreads(__tstate);
12932 if (PyErr_Occurred()) SWIG_fail;
12933 }
12934 {
12935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12936 }
12937 {
12938 if (created2) delete arg2;
12939 }
12940 {
12941 if (temp3)
12942 delete arg3;
12943 }
12944 return resultobj;
12945 fail:
12946 {
12947 if (created2) delete arg2;
12948 }
12949 {
12950 if (temp3)
12951 delete arg3;
12952 }
12953 return NULL;
12954 }
12955
12956
12957 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12958 PyObject *resultobj = NULL;
12959 wxImage *arg1 = (wxImage *) 0 ;
12960 bool result;
12961 PyObject * obj0 = 0 ;
12962 char *kwnames[] = {
12963 (char *) "self", NULL
12964 };
12965
12966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12968 if (SWIG_arg_fail(1)) SWIG_fail;
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 result = (bool)(arg1)->Ok();
12972
12973 wxPyEndAllowThreads(__tstate);
12974 if (PyErr_Occurred()) SWIG_fail;
12975 }
12976 {
12977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12978 }
12979 return resultobj;
12980 fail:
12981 return NULL;
12982 }
12983
12984
12985 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12986 PyObject *resultobj = NULL;
12987 wxImage *arg1 = (wxImage *) 0 ;
12988 int result;
12989 PyObject * obj0 = 0 ;
12990 char *kwnames[] = {
12991 (char *) "self", NULL
12992 };
12993
12994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12996 if (SWIG_arg_fail(1)) SWIG_fail;
12997 {
12998 PyThreadState* __tstate = wxPyBeginAllowThreads();
12999 result = (int)(arg1)->GetWidth();
13000
13001 wxPyEndAllowThreads(__tstate);
13002 if (PyErr_Occurred()) SWIG_fail;
13003 }
13004 {
13005 resultobj = SWIG_From_int(static_cast<int >(result));
13006 }
13007 return resultobj;
13008 fail:
13009 return NULL;
13010 }
13011
13012
13013 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
13014 PyObject *resultobj = NULL;
13015 wxImage *arg1 = (wxImage *) 0 ;
13016 int result;
13017 PyObject * obj0 = 0 ;
13018 char *kwnames[] = {
13019 (char *) "self", NULL
13020 };
13021
13022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
13023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13024 if (SWIG_arg_fail(1)) SWIG_fail;
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (int)(arg1)->GetHeight();
13028
13029 wxPyEndAllowThreads(__tstate);
13030 if (PyErr_Occurred()) SWIG_fail;
13031 }
13032 {
13033 resultobj = SWIG_From_int(static_cast<int >(result));
13034 }
13035 return resultobj;
13036 fail:
13037 return NULL;
13038 }
13039
13040
13041 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
13042 PyObject *resultobj = NULL;
13043 wxImage *arg1 = (wxImage *) 0 ;
13044 wxSize result;
13045 PyObject * obj0 = 0 ;
13046 char *kwnames[] = {
13047 (char *) "self", NULL
13048 };
13049
13050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
13051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13052 if (SWIG_arg_fail(1)) SWIG_fail;
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 result = wxImage_GetSize(arg1);
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 {
13061 wxSize * resultptr;
13062 resultptr = new wxSize(static_cast<wxSize & >(result));
13063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13064 }
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13072 PyObject *resultobj = NULL;
13073 wxImage *arg1 = (wxImage *) 0 ;
13074 wxRect *arg2 = 0 ;
13075 SwigValueWrapper<wxImage > result;
13076 wxRect temp2 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 char *kwnames[] = {
13080 (char *) "self",(char *) "rect", NULL
13081 };
13082
13083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13085 if (SWIG_arg_fail(1)) SWIG_fail;
13086 {
13087 arg2 = &temp2;
13088 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13089 }
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13093
13094 wxPyEndAllowThreads(__tstate);
13095 if (PyErr_Occurred()) SWIG_fail;
13096 }
13097 {
13098 wxImage * resultptr;
13099 resultptr = new wxImage(static_cast<wxImage & >(result));
13100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13101 }
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13109 PyObject *resultobj = NULL;
13110 wxImage *arg1 = (wxImage *) 0 ;
13111 wxSize *arg2 = 0 ;
13112 wxPoint *arg3 = 0 ;
13113 int arg4 = (int) -1 ;
13114 int arg5 = (int) -1 ;
13115 int arg6 = (int) -1 ;
13116 SwigValueWrapper<wxImage > result;
13117 wxSize temp2 ;
13118 wxPoint temp3 ;
13119 PyObject * obj0 = 0 ;
13120 PyObject * obj1 = 0 ;
13121 PyObject * obj2 = 0 ;
13122 PyObject * obj3 = 0 ;
13123 PyObject * obj4 = 0 ;
13124 PyObject * obj5 = 0 ;
13125 char *kwnames[] = {
13126 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13127 };
13128
13129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13131 if (SWIG_arg_fail(1)) SWIG_fail;
13132 {
13133 arg2 = &temp2;
13134 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13135 }
13136 {
13137 arg3 = &temp3;
13138 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13139 }
13140 if (obj3) {
13141 {
13142 arg4 = static_cast<int >(SWIG_As_int(obj3));
13143 if (SWIG_arg_fail(4)) SWIG_fail;
13144 }
13145 }
13146 if (obj4) {
13147 {
13148 arg5 = static_cast<int >(SWIG_As_int(obj4));
13149 if (SWIG_arg_fail(5)) SWIG_fail;
13150 }
13151 }
13152 if (obj5) {
13153 {
13154 arg6 = static_cast<int >(SWIG_As_int(obj5));
13155 if (SWIG_arg_fail(6)) SWIG_fail;
13156 }
13157 }
13158 {
13159 PyThreadState* __tstate = wxPyBeginAllowThreads();
13160 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13161
13162 wxPyEndAllowThreads(__tstate);
13163 if (PyErr_Occurred()) SWIG_fail;
13164 }
13165 {
13166 wxImage * resultptr;
13167 resultptr = new wxImage(static_cast<wxImage & >(result));
13168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13169 }
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj = NULL;
13178 wxImage *arg1 = (wxImage *) 0 ;
13179 SwigValueWrapper<wxImage > result;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "self", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13187 if (SWIG_arg_fail(1)) SWIG_fail;
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (arg1)->Copy();
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 {
13196 wxImage * resultptr;
13197 resultptr = new wxImage(static_cast<wxImage & >(result));
13198 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13199 }
13200 return resultobj;
13201 fail:
13202 return NULL;
13203 }
13204
13205
13206 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13207 PyObject *resultobj = NULL;
13208 wxImage *arg1 = (wxImage *) 0 ;
13209 wxImage *arg2 = 0 ;
13210 int arg3 ;
13211 int arg4 ;
13212 PyObject * obj0 = 0 ;
13213 PyObject * obj1 = 0 ;
13214 PyObject * obj2 = 0 ;
13215 PyObject * obj3 = 0 ;
13216 char *kwnames[] = {
13217 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13218 };
13219
13220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13222 if (SWIG_arg_fail(1)) SWIG_fail;
13223 {
13224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13225 if (SWIG_arg_fail(2)) SWIG_fail;
13226 if (arg2 == NULL) {
13227 SWIG_null_ref("wxImage");
13228 }
13229 if (SWIG_arg_fail(2)) SWIG_fail;
13230 }
13231 {
13232 arg3 = static_cast<int >(SWIG_As_int(obj2));
13233 if (SWIG_arg_fail(3)) SWIG_fail;
13234 }
13235 {
13236 arg4 = static_cast<int >(SWIG_As_int(obj3));
13237 if (SWIG_arg_fail(4)) SWIG_fail;
13238 }
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13242
13243 wxPyEndAllowThreads(__tstate);
13244 if (PyErr_Occurred()) SWIG_fail;
13245 }
13246 Py_INCREF(Py_None); resultobj = Py_None;
13247 return resultobj;
13248 fail:
13249 return NULL;
13250 }
13251
13252
13253 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13254 PyObject *resultobj = NULL;
13255 wxImage *arg1 = (wxImage *) 0 ;
13256 PyObject *result;
13257 PyObject * obj0 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 result = (PyObject *)wxImage_GetData(arg1);
13268
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 resultobj = result;
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj = NULL;
13281 wxImage *arg1 = (wxImage *) 0 ;
13282 buffer arg2 ;
13283 int arg3 ;
13284 PyObject * obj0 = 0 ;
13285 PyObject * obj1 = 0 ;
13286 char *kwnames[] = {
13287 (char *) "self",(char *) "data", NULL
13288 };
13289
13290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13292 if (SWIG_arg_fail(1)) SWIG_fail;
13293 {
13294 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 wxImage_SetData(arg1,arg2,arg3);
13299
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 Py_INCREF(Py_None); resultobj = Py_None;
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj = NULL;
13312 wxImage *arg1 = (wxImage *) 0 ;
13313 PyObject *result;
13314 PyObject * obj0 = 0 ;
13315 char *kwnames[] = {
13316 (char *) "self", NULL
13317 };
13318
13319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13321 if (SWIG_arg_fail(1)) SWIG_fail;
13322 {
13323 PyThreadState* __tstate = wxPyBeginAllowThreads();
13324 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13325
13326 wxPyEndAllowThreads(__tstate);
13327 if (PyErr_Occurred()) SWIG_fail;
13328 }
13329 resultobj = result;
13330 return resultobj;
13331 fail:
13332 return NULL;
13333 }
13334
13335
13336 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13337 PyObject *resultobj = NULL;
13338 wxImage *arg1 = (wxImage *) 0 ;
13339 buffer arg2 ;
13340 int arg3 ;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 char *kwnames[] = {
13344 (char *) "self",(char *) "data", NULL
13345 };
13346
13347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13349 if (SWIG_arg_fail(1)) SWIG_fail;
13350 {
13351 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13352 }
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 wxImage_SetDataBuffer(arg1,arg2,arg3);
13356
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 Py_INCREF(Py_None); resultobj = Py_None;
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13368 PyObject *resultobj = NULL;
13369 wxImage *arg1 = (wxImage *) 0 ;
13370 PyObject *result;
13371 PyObject * obj0 = 0 ;
13372 char *kwnames[] = {
13373 (char *) "self", NULL
13374 };
13375
13376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13378 if (SWIG_arg_fail(1)) SWIG_fail;
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 result = (PyObject *)wxImage_GetAlphaData(arg1);
13382
13383 wxPyEndAllowThreads(__tstate);
13384 if (PyErr_Occurred()) SWIG_fail;
13385 }
13386 resultobj = result;
13387 return resultobj;
13388 fail:
13389 return NULL;
13390 }
13391
13392
13393 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13394 PyObject *resultobj = NULL;
13395 wxImage *arg1 = (wxImage *) 0 ;
13396 buffer arg2 ;
13397 int arg3 ;
13398 PyObject * obj0 = 0 ;
13399 PyObject * obj1 = 0 ;
13400 char *kwnames[] = {
13401 (char *) "self",(char *) "alpha", NULL
13402 };
13403
13404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13406 if (SWIG_arg_fail(1)) SWIG_fail;
13407 {
13408 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 wxImage_SetAlphaData(arg1,arg2,arg3);
13413
13414 wxPyEndAllowThreads(__tstate);
13415 if (PyErr_Occurred()) SWIG_fail;
13416 }
13417 Py_INCREF(Py_None); resultobj = Py_None;
13418 return resultobj;
13419 fail:
13420 return NULL;
13421 }
13422
13423
13424 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13425 PyObject *resultobj = NULL;
13426 wxImage *arg1 = (wxImage *) 0 ;
13427 PyObject *result;
13428 PyObject * obj0 = 0 ;
13429 char *kwnames[] = {
13430 (char *) "self", NULL
13431 };
13432
13433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13435 if (SWIG_arg_fail(1)) SWIG_fail;
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13439
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = result;
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj = NULL;
13452 wxImage *arg1 = (wxImage *) 0 ;
13453 buffer arg2 ;
13454 int arg3 ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 char *kwnames[] = {
13458 (char *) "self",(char *) "alpha", NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13463 if (SWIG_arg_fail(1)) SWIG_fail;
13464 {
13465 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13466 }
13467 {
13468 PyThreadState* __tstate = wxPyBeginAllowThreads();
13469 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13470
13471 wxPyEndAllowThreads(__tstate);
13472 if (PyErr_Occurred()) SWIG_fail;
13473 }
13474 Py_INCREF(Py_None); resultobj = Py_None;
13475 return resultobj;
13476 fail:
13477 return NULL;
13478 }
13479
13480
13481 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = NULL;
13483 wxImage *arg1 = (wxImage *) 0 ;
13484 byte arg2 ;
13485 byte arg3 ;
13486 byte arg4 ;
13487 PyObject * obj0 = 0 ;
13488 PyObject * obj1 = 0 ;
13489 PyObject * obj2 = 0 ;
13490 PyObject * obj3 = 0 ;
13491 char *kwnames[] = {
13492 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13493 };
13494
13495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13497 if (SWIG_arg_fail(1)) SWIG_fail;
13498 {
13499 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13500 if (SWIG_arg_fail(2)) SWIG_fail;
13501 }
13502 {
13503 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13504 if (SWIG_arg_fail(3)) SWIG_fail;
13505 }
13506 {
13507 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13508 if (SWIG_arg_fail(4)) SWIG_fail;
13509 }
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 (arg1)->SetMaskColour(arg2,arg3,arg4);
13513
13514 wxPyEndAllowThreads(__tstate);
13515 if (PyErr_Occurred()) SWIG_fail;
13516 }
13517 Py_INCREF(Py_None); resultobj = Py_None;
13518 return resultobj;
13519 fail:
13520 return NULL;
13521 }
13522
13523
13524 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13525 PyObject *resultobj = NULL;
13526 wxImage *arg1 = (wxImage *) 0 ;
13527 byte *arg2 = (byte *) 0 ;
13528 byte *arg3 = (byte *) 0 ;
13529 byte *arg4 = (byte *) 0 ;
13530 byte temp2 ;
13531 int res2 = 0 ;
13532 byte temp3 ;
13533 int res3 = 0 ;
13534 byte temp4 ;
13535 int res4 = 0 ;
13536 PyObject * obj0 = 0 ;
13537 char *kwnames[] = {
13538 (char *) "self", NULL
13539 };
13540
13541 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13542 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13543 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13546 if (SWIG_arg_fail(1)) SWIG_fail;
13547 {
13548 PyThreadState* __tstate = wxPyBeginAllowThreads();
13549 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13550
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 Py_INCREF(Py_None); resultobj = Py_None;
13555 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13556 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13557 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13558 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13559 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13560 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13561 return resultobj;
13562 fail:
13563 return NULL;
13564 }
13565
13566
13567 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13568 PyObject *resultobj = NULL;
13569 wxImage *arg1 = (wxImage *) 0 ;
13570 byte result;
13571 PyObject * obj0 = 0 ;
13572 char *kwnames[] = {
13573 (char *) "self", NULL
13574 };
13575
13576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13578 if (SWIG_arg_fail(1)) SWIG_fail;
13579 {
13580 PyThreadState* __tstate = wxPyBeginAllowThreads();
13581 result = (byte)(arg1)->GetMaskRed();
13582
13583 wxPyEndAllowThreads(__tstate);
13584 if (PyErr_Occurred()) SWIG_fail;
13585 }
13586 {
13587 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13588 }
13589 return resultobj;
13590 fail:
13591 return NULL;
13592 }
13593
13594
13595 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13596 PyObject *resultobj = NULL;
13597 wxImage *arg1 = (wxImage *) 0 ;
13598 byte result;
13599 PyObject * obj0 = 0 ;
13600 char *kwnames[] = {
13601 (char *) "self", NULL
13602 };
13603
13604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13606 if (SWIG_arg_fail(1)) SWIG_fail;
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 result = (byte)(arg1)->GetMaskGreen();
13610
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 {
13615 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13616 }
13617 return resultobj;
13618 fail:
13619 return NULL;
13620 }
13621
13622
13623 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13624 PyObject *resultobj = NULL;
13625 wxImage *arg1 = (wxImage *) 0 ;
13626 byte result;
13627 PyObject * obj0 = 0 ;
13628 char *kwnames[] = {
13629 (char *) "self", NULL
13630 };
13631
13632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13634 if (SWIG_arg_fail(1)) SWIG_fail;
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 result = (byte)(arg1)->GetMaskBlue();
13638
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 {
13643 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13644 }
13645 return resultobj;
13646 fail:
13647 return NULL;
13648 }
13649
13650
13651 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13652 PyObject *resultobj = NULL;
13653 wxImage *arg1 = (wxImage *) 0 ;
13654 bool arg2 = (bool) true ;
13655 PyObject * obj0 = 0 ;
13656 PyObject * obj1 = 0 ;
13657 char *kwnames[] = {
13658 (char *) "self",(char *) "mask", NULL
13659 };
13660
13661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13663 if (SWIG_arg_fail(1)) SWIG_fail;
13664 if (obj1) {
13665 {
13666 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13667 if (SWIG_arg_fail(2)) SWIG_fail;
13668 }
13669 }
13670 {
13671 PyThreadState* __tstate = wxPyBeginAllowThreads();
13672 (arg1)->SetMask(arg2);
13673
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 Py_INCREF(Py_None); resultobj = Py_None;
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj = NULL;
13686 wxImage *arg1 = (wxImage *) 0 ;
13687 bool result;
13688 PyObject * obj0 = 0 ;
13689 char *kwnames[] = {
13690 (char *) "self", NULL
13691 };
13692
13693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13695 if (SWIG_arg_fail(1)) SWIG_fail;
13696 {
13697 PyThreadState* __tstate = wxPyBeginAllowThreads();
13698 result = (bool)(arg1)->HasMask();
13699
13700 wxPyEndAllowThreads(__tstate);
13701 if (PyErr_Occurred()) SWIG_fail;
13702 }
13703 {
13704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13705 }
13706 return resultobj;
13707 fail:
13708 return NULL;
13709 }
13710
13711
13712 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj = NULL;
13714 wxImage *arg1 = (wxImage *) 0 ;
13715 double arg2 ;
13716 wxPoint *arg3 = 0 ;
13717 bool arg4 = (bool) true ;
13718 wxPoint *arg5 = (wxPoint *) NULL ;
13719 SwigValueWrapper<wxImage > result;
13720 wxPoint temp3 ;
13721 PyObject * obj0 = 0 ;
13722 PyObject * obj1 = 0 ;
13723 PyObject * obj2 = 0 ;
13724 PyObject * obj3 = 0 ;
13725 PyObject * obj4 = 0 ;
13726 char *kwnames[] = {
13727 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13728 };
13729
13730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13732 if (SWIG_arg_fail(1)) SWIG_fail;
13733 {
13734 arg2 = static_cast<double >(SWIG_As_double(obj1));
13735 if (SWIG_arg_fail(2)) SWIG_fail;
13736 }
13737 {
13738 arg3 = &temp3;
13739 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13740 }
13741 if (obj3) {
13742 {
13743 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13744 if (SWIG_arg_fail(4)) SWIG_fail;
13745 }
13746 }
13747 if (obj4) {
13748 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13749 if (SWIG_arg_fail(5)) SWIG_fail;
13750 }
13751 {
13752 PyThreadState* __tstate = wxPyBeginAllowThreads();
13753 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13754
13755 wxPyEndAllowThreads(__tstate);
13756 if (PyErr_Occurred()) SWIG_fail;
13757 }
13758 {
13759 wxImage * resultptr;
13760 resultptr = new wxImage(static_cast<wxImage & >(result));
13761 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13762 }
13763 return resultobj;
13764 fail:
13765 return NULL;
13766 }
13767
13768
13769 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj = NULL;
13771 wxImage *arg1 = (wxImage *) 0 ;
13772 bool arg2 = (bool) true ;
13773 SwigValueWrapper<wxImage > result;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 char *kwnames[] = {
13777 (char *) "self",(char *) "clockwise", NULL
13778 };
13779
13780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13782 if (SWIG_arg_fail(1)) SWIG_fail;
13783 if (obj1) {
13784 {
13785 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13786 if (SWIG_arg_fail(2)) SWIG_fail;
13787 }
13788 }
13789 {
13790 PyThreadState* __tstate = wxPyBeginAllowThreads();
13791 result = (arg1)->Rotate90(arg2);
13792
13793 wxPyEndAllowThreads(__tstate);
13794 if (PyErr_Occurred()) SWIG_fail;
13795 }
13796 {
13797 wxImage * resultptr;
13798 resultptr = new wxImage(static_cast<wxImage & >(result));
13799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13800 }
13801 return resultobj;
13802 fail:
13803 return NULL;
13804 }
13805
13806
13807 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13808 PyObject *resultobj = NULL;
13809 wxImage *arg1 = (wxImage *) 0 ;
13810 bool arg2 = (bool) true ;
13811 SwigValueWrapper<wxImage > result;
13812 PyObject * obj0 = 0 ;
13813 PyObject * obj1 = 0 ;
13814 char *kwnames[] = {
13815 (char *) "self",(char *) "horizontally", NULL
13816 };
13817
13818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13820 if (SWIG_arg_fail(1)) SWIG_fail;
13821 if (obj1) {
13822 {
13823 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13824 if (SWIG_arg_fail(2)) SWIG_fail;
13825 }
13826 }
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 result = (arg1)->Mirror(arg2);
13830
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 {
13835 wxImage * resultptr;
13836 resultptr = new wxImage(static_cast<wxImage & >(result));
13837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13838 }
13839 return resultobj;
13840 fail:
13841 return NULL;
13842 }
13843
13844
13845 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13846 PyObject *resultobj = NULL;
13847 wxImage *arg1 = (wxImage *) 0 ;
13848 byte arg2 ;
13849 byte arg3 ;
13850 byte arg4 ;
13851 byte arg5 ;
13852 byte arg6 ;
13853 byte arg7 ;
13854 PyObject * obj0 = 0 ;
13855 PyObject * obj1 = 0 ;
13856 PyObject * obj2 = 0 ;
13857 PyObject * obj3 = 0 ;
13858 PyObject * obj4 = 0 ;
13859 PyObject * obj5 = 0 ;
13860 PyObject * obj6 = 0 ;
13861 char *kwnames[] = {
13862 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13863 };
13864
13865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13867 if (SWIG_arg_fail(1)) SWIG_fail;
13868 {
13869 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13870 if (SWIG_arg_fail(2)) SWIG_fail;
13871 }
13872 {
13873 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13874 if (SWIG_arg_fail(3)) SWIG_fail;
13875 }
13876 {
13877 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13878 if (SWIG_arg_fail(4)) SWIG_fail;
13879 }
13880 {
13881 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13882 if (SWIG_arg_fail(5)) SWIG_fail;
13883 }
13884 {
13885 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13886 if (SWIG_arg_fail(6)) SWIG_fail;
13887 }
13888 {
13889 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13890 if (SWIG_arg_fail(7)) SWIG_fail;
13891 }
13892 {
13893 PyThreadState* __tstate = wxPyBeginAllowThreads();
13894 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13895
13896 wxPyEndAllowThreads(__tstate);
13897 if (PyErr_Occurred()) SWIG_fail;
13898 }
13899 Py_INCREF(Py_None); resultobj = Py_None;
13900 return resultobj;
13901 fail:
13902 return NULL;
13903 }
13904
13905
13906 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13907 PyObject *resultobj = NULL;
13908 wxImage *arg1 = (wxImage *) 0 ;
13909 double arg2 = (double) 0.299 ;
13910 double arg3 = (double) 0.587 ;
13911 double arg4 = (double) 0.114 ;
13912 SwigValueWrapper<wxImage > result;
13913 PyObject * obj0 = 0 ;
13914 PyObject * obj1 = 0 ;
13915 PyObject * obj2 = 0 ;
13916 PyObject * obj3 = 0 ;
13917 char *kwnames[] = {
13918 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13919 };
13920
13921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13923 if (SWIG_arg_fail(1)) SWIG_fail;
13924 if (obj1) {
13925 {
13926 arg2 = static_cast<double >(SWIG_As_double(obj1));
13927 if (SWIG_arg_fail(2)) SWIG_fail;
13928 }
13929 }
13930 if (obj2) {
13931 {
13932 arg3 = static_cast<double >(SWIG_As_double(obj2));
13933 if (SWIG_arg_fail(3)) SWIG_fail;
13934 }
13935 }
13936 if (obj3) {
13937 {
13938 arg4 = static_cast<double >(SWIG_As_double(obj3));
13939 if (SWIG_arg_fail(4)) SWIG_fail;
13940 }
13941 }
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13945
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 {
13950 wxImage * resultptr;
13951 resultptr = new wxImage(static_cast<wxImage & >(result));
13952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13953 }
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj = NULL;
13962 wxImage *arg1 = (wxImage *) 0 ;
13963 byte arg2 ;
13964 byte arg3 ;
13965 byte arg4 ;
13966 SwigValueWrapper<wxImage > result;
13967 PyObject * obj0 = 0 ;
13968 PyObject * obj1 = 0 ;
13969 PyObject * obj2 = 0 ;
13970 PyObject * obj3 = 0 ;
13971 char *kwnames[] = {
13972 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13973 };
13974
13975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13977 if (SWIG_arg_fail(1)) SWIG_fail;
13978 {
13979 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13980 if (SWIG_arg_fail(2)) SWIG_fail;
13981 }
13982 {
13983 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13984 if (SWIG_arg_fail(3)) SWIG_fail;
13985 }
13986 {
13987 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13988 if (SWIG_arg_fail(4)) SWIG_fail;
13989 }
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13993
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 {
13998 wxImage * resultptr;
13999 resultptr = new wxImage(static_cast<wxImage & >(result));
14000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
14001 }
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14009 PyObject *resultobj = NULL;
14010 wxImage *arg1 = (wxImage *) 0 ;
14011 wxString *arg2 = 0 ;
14012 wxString *arg3 = 0 ;
14013 bool temp2 = false ;
14014 bool temp3 = false ;
14015 PyObject * obj0 = 0 ;
14016 PyObject * obj1 = 0 ;
14017 PyObject * obj2 = 0 ;
14018 char *kwnames[] = {
14019 (char *) "self",(char *) "name",(char *) "value", NULL
14020 };
14021
14022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
14023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14024 if (SWIG_arg_fail(1)) SWIG_fail;
14025 {
14026 arg2 = wxString_in_helper(obj1);
14027 if (arg2 == NULL) SWIG_fail;
14028 temp2 = true;
14029 }
14030 {
14031 arg3 = wxString_in_helper(obj2);
14032 if (arg3 == NULL) SWIG_fail;
14033 temp3 = true;
14034 }
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
14038
14039 wxPyEndAllowThreads(__tstate);
14040 if (PyErr_Occurred()) SWIG_fail;
14041 }
14042 Py_INCREF(Py_None); resultobj = Py_None;
14043 {
14044 if (temp2)
14045 delete arg2;
14046 }
14047 {
14048 if (temp3)
14049 delete arg3;
14050 }
14051 return resultobj;
14052 fail:
14053 {
14054 if (temp2)
14055 delete arg2;
14056 }
14057 {
14058 if (temp3)
14059 delete arg3;
14060 }
14061 return NULL;
14062 }
14063
14064
14065 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14066 PyObject *resultobj = NULL;
14067 wxImage *arg1 = (wxImage *) 0 ;
14068 wxString *arg2 = 0 ;
14069 int arg3 ;
14070 bool temp2 = false ;
14071 PyObject * obj0 = 0 ;
14072 PyObject * obj1 = 0 ;
14073 PyObject * obj2 = 0 ;
14074 char *kwnames[] = {
14075 (char *) "self",(char *) "name",(char *) "value", NULL
14076 };
14077
14078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14080 if (SWIG_arg_fail(1)) SWIG_fail;
14081 {
14082 arg2 = wxString_in_helper(obj1);
14083 if (arg2 == NULL) SWIG_fail;
14084 temp2 = true;
14085 }
14086 {
14087 arg3 = static_cast<int >(SWIG_As_int(obj2));
14088 if (SWIG_arg_fail(3)) SWIG_fail;
14089 }
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 (arg1)->SetOption((wxString const &)*arg2,arg3);
14093
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 Py_INCREF(Py_None); resultobj = Py_None;
14098 {
14099 if (temp2)
14100 delete arg2;
14101 }
14102 return resultobj;
14103 fail:
14104 {
14105 if (temp2)
14106 delete arg2;
14107 }
14108 return NULL;
14109 }
14110
14111
14112 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj = NULL;
14114 wxImage *arg1 = (wxImage *) 0 ;
14115 wxString *arg2 = 0 ;
14116 wxString result;
14117 bool temp2 = false ;
14118 PyObject * obj0 = 0 ;
14119 PyObject * obj1 = 0 ;
14120 char *kwnames[] = {
14121 (char *) "self",(char *) "name", NULL
14122 };
14123
14124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14126 if (SWIG_arg_fail(1)) SWIG_fail;
14127 {
14128 arg2 = wxString_in_helper(obj1);
14129 if (arg2 == NULL) SWIG_fail;
14130 temp2 = true;
14131 }
14132 {
14133 PyThreadState* __tstate = wxPyBeginAllowThreads();
14134 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14135
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 {
14140 #if wxUSE_UNICODE
14141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14142 #else
14143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14144 #endif
14145 }
14146 {
14147 if (temp2)
14148 delete arg2;
14149 }
14150 return resultobj;
14151 fail:
14152 {
14153 if (temp2)
14154 delete arg2;
14155 }
14156 return NULL;
14157 }
14158
14159
14160 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14161 PyObject *resultobj = NULL;
14162 wxImage *arg1 = (wxImage *) 0 ;
14163 wxString *arg2 = 0 ;
14164 int result;
14165 bool temp2 = false ;
14166 PyObject * obj0 = 0 ;
14167 PyObject * obj1 = 0 ;
14168 char *kwnames[] = {
14169 (char *) "self",(char *) "name", NULL
14170 };
14171
14172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14174 if (SWIG_arg_fail(1)) SWIG_fail;
14175 {
14176 arg2 = wxString_in_helper(obj1);
14177 if (arg2 == NULL) SWIG_fail;
14178 temp2 = true;
14179 }
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14183
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 {
14188 resultobj = SWIG_From_int(static_cast<int >(result));
14189 }
14190 {
14191 if (temp2)
14192 delete arg2;
14193 }
14194 return resultobj;
14195 fail:
14196 {
14197 if (temp2)
14198 delete arg2;
14199 }
14200 return NULL;
14201 }
14202
14203
14204 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14205 PyObject *resultobj = NULL;
14206 wxImage *arg1 = (wxImage *) 0 ;
14207 wxString *arg2 = 0 ;
14208 bool result;
14209 bool temp2 = false ;
14210 PyObject * obj0 = 0 ;
14211 PyObject * obj1 = 0 ;
14212 char *kwnames[] = {
14213 (char *) "self",(char *) "name", NULL
14214 };
14215
14216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14218 if (SWIG_arg_fail(1)) SWIG_fail;
14219 {
14220 arg2 = wxString_in_helper(obj1);
14221 if (arg2 == NULL) SWIG_fail;
14222 temp2 = true;
14223 }
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14227
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 {
14232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14233 }
14234 {
14235 if (temp2)
14236 delete arg2;
14237 }
14238 return resultobj;
14239 fail:
14240 {
14241 if (temp2)
14242 delete arg2;
14243 }
14244 return NULL;
14245 }
14246
14247
14248 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14249 PyObject *resultobj = NULL;
14250 wxImage *arg1 = (wxImage *) 0 ;
14251 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14252 unsigned long result;
14253 PyObject * obj0 = 0 ;
14254 PyObject * obj1 = 0 ;
14255 char *kwnames[] = {
14256 (char *) "self",(char *) "stopafter", NULL
14257 };
14258
14259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(1)) SWIG_fail;
14262 if (obj1) {
14263 {
14264 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14265 if (SWIG_arg_fail(2)) SWIG_fail;
14266 }
14267 }
14268 {
14269 PyThreadState* __tstate = wxPyBeginAllowThreads();
14270 result = (unsigned long)(arg1)->CountColours(arg2);
14271
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 {
14276 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14277 }
14278 return resultobj;
14279 fail:
14280 return NULL;
14281 }
14282
14283
14284 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14285 PyObject *resultobj = NULL;
14286 wxImage *arg1 = (wxImage *) 0 ;
14287 wxImageHistogram *arg2 = 0 ;
14288 unsigned long result;
14289 PyObject * obj0 = 0 ;
14290 PyObject * obj1 = 0 ;
14291 char *kwnames[] = {
14292 (char *) "self",(char *) "h", NULL
14293 };
14294
14295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14297 if (SWIG_arg_fail(1)) SWIG_fail;
14298 {
14299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14300 if (SWIG_arg_fail(2)) SWIG_fail;
14301 if (arg2 == NULL) {
14302 SWIG_null_ref("wxImageHistogram");
14303 }
14304 if (SWIG_arg_fail(2)) SWIG_fail;
14305 }
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14309
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 {
14314 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14315 }
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj = NULL;
14324 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14325 PyObject * obj0 = 0 ;
14326 char *kwnames[] = {
14327 (char *) "handler", NULL
14328 };
14329
14330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14332 if (SWIG_arg_fail(1)) SWIG_fail;
14333 {
14334 PyThreadState* __tstate = wxPyBeginAllowThreads();
14335 wxImage::AddHandler(arg1);
14336
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 Py_INCREF(Py_None); resultobj = Py_None;
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj = NULL;
14349 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14350 PyObject * obj0 = 0 ;
14351 char *kwnames[] = {
14352 (char *) "handler", NULL
14353 };
14354
14355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14357 if (SWIG_arg_fail(1)) SWIG_fail;
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 wxImage::InsertHandler(arg1);
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 Py_INCREF(Py_None); resultobj = Py_None;
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj = NULL;
14374 wxString *arg1 = 0 ;
14375 bool result;
14376 bool temp1 = false ;
14377 PyObject * obj0 = 0 ;
14378 char *kwnames[] = {
14379 (char *) "name", NULL
14380 };
14381
14382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14383 {
14384 arg1 = wxString_in_helper(obj0);
14385 if (arg1 == NULL) SWIG_fail;
14386 temp1 = true;
14387 }
14388 {
14389 PyThreadState* __tstate = wxPyBeginAllowThreads();
14390 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14391
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 {
14396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14397 }
14398 {
14399 if (temp1)
14400 delete arg1;
14401 }
14402 return resultobj;
14403 fail:
14404 {
14405 if (temp1)
14406 delete arg1;
14407 }
14408 return NULL;
14409 }
14410
14411
14412 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14413 PyObject *resultobj = NULL;
14414 wxString result;
14415 char *kwnames[] = {
14416 NULL
14417 };
14418
14419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14420 {
14421 PyThreadState* __tstate = wxPyBeginAllowThreads();
14422 result = wxImage::GetImageExtWildcard();
14423
14424 wxPyEndAllowThreads(__tstate);
14425 if (PyErr_Occurred()) SWIG_fail;
14426 }
14427 {
14428 #if wxUSE_UNICODE
14429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14430 #else
14431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14432 #endif
14433 }
14434 return resultobj;
14435 fail:
14436 return NULL;
14437 }
14438
14439
14440 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14441 PyObject *resultobj = NULL;
14442 wxImage *arg1 = (wxImage *) 0 ;
14443 int arg2 = (int) -1 ;
14444 wxBitmap result;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 char *kwnames[] = {
14448 (char *) "self",(char *) "depth", NULL
14449 };
14450
14451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14453 if (SWIG_arg_fail(1)) SWIG_fail;
14454 if (obj1) {
14455 {
14456 arg2 = static_cast<int >(SWIG_As_int(obj1));
14457 if (SWIG_arg_fail(2)) SWIG_fail;
14458 }
14459 }
14460 {
14461 if (!wxPyCheckForApp()) SWIG_fail;
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = wxImage_ConvertToBitmap(arg1,arg2);
14464
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 {
14469 wxBitmap * resultptr;
14470 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14472 }
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj = NULL;
14481 wxImage *arg1 = (wxImage *) 0 ;
14482 byte arg2 ;
14483 byte arg3 ;
14484 byte arg4 ;
14485 wxBitmap result;
14486 PyObject * obj0 = 0 ;
14487 PyObject * obj1 = 0 ;
14488 PyObject * obj2 = 0 ;
14489 PyObject * obj3 = 0 ;
14490 char *kwnames[] = {
14491 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14492 };
14493
14494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14496 if (SWIG_arg_fail(1)) SWIG_fail;
14497 {
14498 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14499 if (SWIG_arg_fail(2)) SWIG_fail;
14500 }
14501 {
14502 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14503 if (SWIG_arg_fail(3)) SWIG_fail;
14504 }
14505 {
14506 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14507 if (SWIG_arg_fail(4)) SWIG_fail;
14508 }
14509 {
14510 if (!wxPyCheckForApp()) SWIG_fail;
14511 PyThreadState* __tstate = wxPyBeginAllowThreads();
14512 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14513
14514 wxPyEndAllowThreads(__tstate);
14515 if (PyErr_Occurred()) SWIG_fail;
14516 }
14517 {
14518 wxBitmap * resultptr;
14519 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14520 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14521 }
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj = NULL;
14530 wxImage *arg1 = (wxImage *) 0 ;
14531 double arg2 ;
14532 PyObject * obj0 = 0 ;
14533 PyObject * obj1 = 0 ;
14534 char *kwnames[] = {
14535 (char *) "self",(char *) "angle", NULL
14536 };
14537
14538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14540 if (SWIG_arg_fail(1)) SWIG_fail;
14541 {
14542 arg2 = static_cast<double >(SWIG_As_double(obj1));
14543 if (SWIG_arg_fail(2)) SWIG_fail;
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 (arg1)->RotateHue(arg2);
14548
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 Py_INCREF(Py_None); resultobj = Py_None;
14553 return resultobj;
14554 fail:
14555 return NULL;
14556 }
14557
14558
14559 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj = NULL;
14561 wxImage_RGBValue arg1 ;
14562 wxImage_HSVValue result;
14563 PyObject * obj0 = 0 ;
14564 char *kwnames[] = {
14565 (char *) "rgb", NULL
14566 };
14567
14568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14569 {
14570 wxImage_RGBValue * argp;
14571 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14572 if (SWIG_arg_fail(1)) SWIG_fail;
14573 if (argp == NULL) {
14574 SWIG_null_ref("wxImage_RGBValue");
14575 }
14576 if (SWIG_arg_fail(1)) SWIG_fail;
14577 arg1 = *argp;
14578 }
14579 {
14580 PyThreadState* __tstate = wxPyBeginAllowThreads();
14581 result = wxImage::RGBtoHSV(arg1);
14582
14583 wxPyEndAllowThreads(__tstate);
14584 if (PyErr_Occurred()) SWIG_fail;
14585 }
14586 {
14587 wxImage_HSVValue * resultptr;
14588 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14590 }
14591 return resultobj;
14592 fail:
14593 return NULL;
14594 }
14595
14596
14597 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14598 PyObject *resultobj = NULL;
14599 wxImage_HSVValue arg1 ;
14600 wxImage_RGBValue result;
14601 PyObject * obj0 = 0 ;
14602 char *kwnames[] = {
14603 (char *) "hsv", NULL
14604 };
14605
14606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14607 {
14608 wxImage_HSVValue * argp;
14609 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14610 if (SWIG_arg_fail(1)) SWIG_fail;
14611 if (argp == NULL) {
14612 SWIG_null_ref("wxImage_HSVValue");
14613 }
14614 if (SWIG_arg_fail(1)) SWIG_fail;
14615 arg1 = *argp;
14616 }
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = wxImage::HSVtoRGB(arg1);
14620
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 {
14625 wxImage_RGBValue * resultptr;
14626 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14628 }
14629 return resultobj;
14630 fail:
14631 return NULL;
14632 }
14633
14634
14635 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14636 PyObject *obj;
14637 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14638 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14639 Py_INCREF(obj);
14640 return Py_BuildValue((char *)"");
14641 }
14642 static int _wrap_NullImage_set(PyObject *) {
14643 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14644 return 1;
14645 }
14646
14647
14648 static PyObject *_wrap_NullImage_get(void) {
14649 PyObject *pyobj = NULL;
14650
14651 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14652 return pyobj;
14653 }
14654
14655
14656 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14657 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14658 return 1;
14659 }
14660
14661
14662 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14663 PyObject *pyobj = NULL;
14664
14665 {
14666 #if wxUSE_UNICODE
14667 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14668 #else
14669 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14670 #endif
14671 }
14672 return pyobj;
14673 }
14674
14675
14676 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14677 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14678 return 1;
14679 }
14680
14681
14682 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14683 PyObject *pyobj = NULL;
14684
14685 {
14686 #if wxUSE_UNICODE
14687 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14688 #else
14689 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14690 #endif
14691 }
14692 return pyobj;
14693 }
14694
14695
14696 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14697 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14698 return 1;
14699 }
14700
14701
14702 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14703 PyObject *pyobj = NULL;
14704
14705 {
14706 #if wxUSE_UNICODE
14707 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14708 #else
14709 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14710 #endif
14711 }
14712 return pyobj;
14713 }
14714
14715
14716 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14717 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14718 return 1;
14719 }
14720
14721
14722 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14723 PyObject *pyobj = NULL;
14724
14725 {
14726 #if wxUSE_UNICODE
14727 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14728 #else
14729 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14730 #endif
14731 }
14732 return pyobj;
14733 }
14734
14735
14736 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14737 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14738 return 1;
14739 }
14740
14741
14742 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14743 PyObject *pyobj = NULL;
14744
14745 {
14746 #if wxUSE_UNICODE
14747 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14748 #else
14749 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14750 #endif
14751 }
14752 return pyobj;
14753 }
14754
14755
14756 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14757 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14758 return 1;
14759 }
14760
14761
14762 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14763 PyObject *pyobj = NULL;
14764
14765 {
14766 #if wxUSE_UNICODE
14767 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14768 #else
14769 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14770 #endif
14771 }
14772 return pyobj;
14773 }
14774
14775
14776 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14777 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14778 return 1;
14779 }
14780
14781
14782 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14783 PyObject *pyobj = NULL;
14784
14785 {
14786 #if wxUSE_UNICODE
14787 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14788 #else
14789 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14790 #endif
14791 }
14792 return pyobj;
14793 }
14794
14795
14796 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14797 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14798 return 1;
14799 }
14800
14801
14802 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14803 PyObject *pyobj = NULL;
14804
14805 {
14806 #if wxUSE_UNICODE
14807 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14808 #else
14809 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14810 #endif
14811 }
14812 return pyobj;
14813 }
14814
14815
14816 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14817 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14818 return 1;
14819 }
14820
14821
14822 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14823 PyObject *pyobj = NULL;
14824
14825 {
14826 #if wxUSE_UNICODE
14827 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14828 #else
14829 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14830 #endif
14831 }
14832 return pyobj;
14833 }
14834
14835
14836 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14837 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14838 return 1;
14839 }
14840
14841
14842 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14843 PyObject *pyobj = NULL;
14844
14845 {
14846 #if wxUSE_UNICODE
14847 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14848 #else
14849 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14850 #endif
14851 }
14852 return pyobj;
14853 }
14854
14855
14856 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14857 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14858 return 1;
14859 }
14860
14861
14862 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14863 PyObject *pyobj = NULL;
14864
14865 {
14866 #if wxUSE_UNICODE
14867 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14868 #else
14869 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14870 #endif
14871 }
14872 return pyobj;
14873 }
14874
14875
14876 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14877 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14878 return 1;
14879 }
14880
14881
14882 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14883 PyObject *pyobj = NULL;
14884
14885 {
14886 #if wxUSE_UNICODE
14887 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14888 #else
14889 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14890 #endif
14891 }
14892 return pyobj;
14893 }
14894
14895
14896 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14897 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14898 return 1;
14899 }
14900
14901
14902 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14903 PyObject *pyobj = NULL;
14904
14905 {
14906 #if wxUSE_UNICODE
14907 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14908 #else
14909 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14910 #endif
14911 }
14912 return pyobj;
14913 }
14914
14915
14916 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14917 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14918 return 1;
14919 }
14920
14921
14922 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14923 PyObject *pyobj = NULL;
14924
14925 {
14926 #if wxUSE_UNICODE
14927 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14928 #else
14929 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14930 #endif
14931 }
14932 return pyobj;
14933 }
14934
14935
14936 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14937 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14938 return 1;
14939 }
14940
14941
14942 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14943 PyObject *pyobj = NULL;
14944
14945 {
14946 #if wxUSE_UNICODE
14947 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14948 #else
14949 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14950 #endif
14951 }
14952 return pyobj;
14953 }
14954
14955
14956 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj = NULL;
14958 wxBMPHandler *result;
14959 char *kwnames[] = {
14960 NULL
14961 };
14962
14963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (wxBMPHandler *)new wxBMPHandler();
14967
14968 wxPyEndAllowThreads(__tstate);
14969 if (PyErr_Occurred()) SWIG_fail;
14970 }
14971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14972 return resultobj;
14973 fail:
14974 return NULL;
14975 }
14976
14977
14978 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14979 PyObject *obj;
14980 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14981 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14982 Py_INCREF(obj);
14983 return Py_BuildValue((char *)"");
14984 }
14985 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14986 PyObject *resultobj = NULL;
14987 wxICOHandler *result;
14988 char *kwnames[] = {
14989 NULL
14990 };
14991
14992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14993 {
14994 PyThreadState* __tstate = wxPyBeginAllowThreads();
14995 result = (wxICOHandler *)new wxICOHandler();
14996
14997 wxPyEndAllowThreads(__tstate);
14998 if (PyErr_Occurred()) SWIG_fail;
14999 }
15000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
15001 return resultobj;
15002 fail:
15003 return NULL;
15004 }
15005
15006
15007 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
15008 PyObject *obj;
15009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15010 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
15011 Py_INCREF(obj);
15012 return Py_BuildValue((char *)"");
15013 }
15014 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15015 PyObject *resultobj = NULL;
15016 wxCURHandler *result;
15017 char *kwnames[] = {
15018 NULL
15019 };
15020
15021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
15022 {
15023 PyThreadState* __tstate = wxPyBeginAllowThreads();
15024 result = (wxCURHandler *)new wxCURHandler();
15025
15026 wxPyEndAllowThreads(__tstate);
15027 if (PyErr_Occurred()) SWIG_fail;
15028 }
15029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
15030 return resultobj;
15031 fail:
15032 return NULL;
15033 }
15034
15035
15036 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
15037 PyObject *obj;
15038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15039 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
15040 Py_INCREF(obj);
15041 return Py_BuildValue((char *)"");
15042 }
15043 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj = NULL;
15045 wxANIHandler *result;
15046 char *kwnames[] = {
15047 NULL
15048 };
15049
15050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (wxANIHandler *)new wxANIHandler();
15054
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15059 return resultobj;
15060 fail:
15061 return NULL;
15062 }
15063
15064
15065 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15066 PyObject *obj;
15067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15068 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15069 Py_INCREF(obj);
15070 return Py_BuildValue((char *)"");
15071 }
15072 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15073 PyObject *resultobj = NULL;
15074 wxPNGHandler *result;
15075 char *kwnames[] = {
15076 NULL
15077 };
15078
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15080 {
15081 PyThreadState* __tstate = wxPyBeginAllowThreads();
15082 result = (wxPNGHandler *)new wxPNGHandler();
15083
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15095 PyObject *obj;
15096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15097 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15098 Py_INCREF(obj);
15099 return Py_BuildValue((char *)"");
15100 }
15101 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15102 PyObject *resultobj = NULL;
15103 wxGIFHandler *result;
15104 char *kwnames[] = {
15105 NULL
15106 };
15107
15108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (wxGIFHandler *)new wxGIFHandler();
15112
15113 wxPyEndAllowThreads(__tstate);
15114 if (PyErr_Occurred()) SWIG_fail;
15115 }
15116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15117 return resultobj;
15118 fail:
15119 return NULL;
15120 }
15121
15122
15123 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15124 PyObject *obj;
15125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15126 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15127 Py_INCREF(obj);
15128 return Py_BuildValue((char *)"");
15129 }
15130 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15131 PyObject *resultobj = NULL;
15132 wxPCXHandler *result;
15133 char *kwnames[] = {
15134 NULL
15135 };
15136
15137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15138 {
15139 PyThreadState* __tstate = wxPyBeginAllowThreads();
15140 result = (wxPCXHandler *)new wxPCXHandler();
15141
15142 wxPyEndAllowThreads(__tstate);
15143 if (PyErr_Occurred()) SWIG_fail;
15144 }
15145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15146 return resultobj;
15147 fail:
15148 return NULL;
15149 }
15150
15151
15152 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15153 PyObject *obj;
15154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15155 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15156 Py_INCREF(obj);
15157 return Py_BuildValue((char *)"");
15158 }
15159 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15160 PyObject *resultobj = NULL;
15161 wxJPEGHandler *result;
15162 char *kwnames[] = {
15163 NULL
15164 };
15165
15166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15167 {
15168 PyThreadState* __tstate = wxPyBeginAllowThreads();
15169 result = (wxJPEGHandler *)new wxJPEGHandler();
15170
15171 wxPyEndAllowThreads(__tstate);
15172 if (PyErr_Occurred()) SWIG_fail;
15173 }
15174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15175 return resultobj;
15176 fail:
15177 return NULL;
15178 }
15179
15180
15181 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15182 PyObject *obj;
15183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15184 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15185 Py_INCREF(obj);
15186 return Py_BuildValue((char *)"");
15187 }
15188 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15189 PyObject *resultobj = NULL;
15190 wxPNMHandler *result;
15191 char *kwnames[] = {
15192 NULL
15193 };
15194
15195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15196 {
15197 PyThreadState* __tstate = wxPyBeginAllowThreads();
15198 result = (wxPNMHandler *)new wxPNMHandler();
15199
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15211 PyObject *obj;
15212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15213 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15214 Py_INCREF(obj);
15215 return Py_BuildValue((char *)"");
15216 }
15217 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15218 PyObject *resultobj = NULL;
15219 wxXPMHandler *result;
15220 char *kwnames[] = {
15221 NULL
15222 };
15223
15224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15225 {
15226 PyThreadState* __tstate = wxPyBeginAllowThreads();
15227 result = (wxXPMHandler *)new wxXPMHandler();
15228
15229 wxPyEndAllowThreads(__tstate);
15230 if (PyErr_Occurred()) SWIG_fail;
15231 }
15232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15233 return resultobj;
15234 fail:
15235 return NULL;
15236 }
15237
15238
15239 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15240 PyObject *obj;
15241 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15242 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15243 Py_INCREF(obj);
15244 return Py_BuildValue((char *)"");
15245 }
15246 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15247 PyObject *resultobj = NULL;
15248 wxTIFFHandler *result;
15249 char *kwnames[] = {
15250 NULL
15251 };
15252
15253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 result = (wxTIFFHandler *)new wxTIFFHandler();
15257
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15269 PyObject *obj;
15270 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15271 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15272 Py_INCREF(obj);
15273 return Py_BuildValue((char *)"");
15274 }
15275 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj = NULL;
15277 wxImage *arg1 = 0 ;
15278 wxImage *arg2 = 0 ;
15279 int arg3 = (int) 236 ;
15280 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15281 bool result;
15282 PyObject * obj0 = 0 ;
15283 PyObject * obj1 = 0 ;
15284 PyObject * obj2 = 0 ;
15285 PyObject * obj3 = 0 ;
15286 char *kwnames[] = {
15287 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15288 };
15289
15290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15291 {
15292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15293 if (SWIG_arg_fail(1)) SWIG_fail;
15294 if (arg1 == NULL) {
15295 SWIG_null_ref("wxImage");
15296 }
15297 if (SWIG_arg_fail(1)) SWIG_fail;
15298 }
15299 {
15300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15301 if (SWIG_arg_fail(2)) SWIG_fail;
15302 if (arg2 == NULL) {
15303 SWIG_null_ref("wxImage");
15304 }
15305 if (SWIG_arg_fail(2)) SWIG_fail;
15306 }
15307 if (obj2) {
15308 {
15309 arg3 = static_cast<int >(SWIG_As_int(obj2));
15310 if (SWIG_arg_fail(3)) SWIG_fail;
15311 }
15312 }
15313 if (obj3) {
15314 {
15315 arg4 = static_cast<int >(SWIG_As_int(obj3));
15316 if (SWIG_arg_fail(4)) SWIG_fail;
15317 }
15318 }
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15322
15323 wxPyEndAllowThreads(__tstate);
15324 if (PyErr_Occurred()) SWIG_fail;
15325 }
15326 {
15327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15328 }
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15336 PyObject *obj;
15337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15338 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15339 Py_INCREF(obj);
15340 return Py_BuildValue((char *)"");
15341 }
15342 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15343 PyObject *resultobj = NULL;
15344 wxEvtHandler *result;
15345 char *kwnames[] = {
15346 NULL
15347 };
15348
15349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (wxEvtHandler *)new wxEvtHandler();
15353
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj = NULL;
15366 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15367 wxEvtHandler *result;
15368 PyObject * obj0 = 0 ;
15369 char *kwnames[] = {
15370 (char *) "self", NULL
15371 };
15372
15373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15375 if (SWIG_arg_fail(1)) SWIG_fail;
15376 {
15377 PyThreadState* __tstate = wxPyBeginAllowThreads();
15378 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15379
15380 wxPyEndAllowThreads(__tstate);
15381 if (PyErr_Occurred()) SWIG_fail;
15382 }
15383 {
15384 resultobj = wxPyMake_wxObject(result, 0);
15385 }
15386 return resultobj;
15387 fail:
15388 return NULL;
15389 }
15390
15391
15392 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15393 PyObject *resultobj = NULL;
15394 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15395 wxEvtHandler *result;
15396 PyObject * obj0 = 0 ;
15397 char *kwnames[] = {
15398 (char *) "self", NULL
15399 };
15400
15401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15403 if (SWIG_arg_fail(1)) SWIG_fail;
15404 {
15405 PyThreadState* __tstate = wxPyBeginAllowThreads();
15406 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15407
15408 wxPyEndAllowThreads(__tstate);
15409 if (PyErr_Occurred()) SWIG_fail;
15410 }
15411 {
15412 resultobj = wxPyMake_wxObject(result, 0);
15413 }
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15421 PyObject *resultobj = NULL;
15422 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15423 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15424 PyObject * obj0 = 0 ;
15425 PyObject * obj1 = 0 ;
15426 char *kwnames[] = {
15427 (char *) "self",(char *) "handler", NULL
15428 };
15429
15430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(1)) SWIG_fail;
15433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15434 if (SWIG_arg_fail(2)) SWIG_fail;
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 (arg1)->SetNextHandler(arg2);
15438
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 Py_INCREF(Py_None); resultobj = Py_None;
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj = NULL;
15451 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15452 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15453 PyObject * obj0 = 0 ;
15454 PyObject * obj1 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "self",(char *) "handler", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15463 if (SWIG_arg_fail(2)) SWIG_fail;
15464 {
15465 PyThreadState* __tstate = wxPyBeginAllowThreads();
15466 (arg1)->SetPreviousHandler(arg2);
15467
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 Py_INCREF(Py_None); resultobj = Py_None;
15472 return resultobj;
15473 fail:
15474 return NULL;
15475 }
15476
15477
15478 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15479 PyObject *resultobj = NULL;
15480 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15481 bool result;
15482 PyObject * obj0 = 0 ;
15483 char *kwnames[] = {
15484 (char *) "self", NULL
15485 };
15486
15487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15489 if (SWIG_arg_fail(1)) SWIG_fail;
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 result = (bool)(arg1)->GetEvtHandlerEnabled();
15493
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 {
15498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15499 }
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15507 PyObject *resultobj = NULL;
15508 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15509 bool arg2 ;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 char *kwnames[] = {
15513 (char *) "self",(char *) "enabled", NULL
15514 };
15515
15516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15518 if (SWIG_arg_fail(1)) SWIG_fail;
15519 {
15520 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15521 if (SWIG_arg_fail(2)) SWIG_fail;
15522 }
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 (arg1)->SetEvtHandlerEnabled(arg2);
15526
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 Py_INCREF(Py_None); resultobj = Py_None;
15531 return resultobj;
15532 fail:
15533 return NULL;
15534 }
15535
15536
15537 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15538 PyObject *resultobj = NULL;
15539 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15540 wxEvent *arg2 = 0 ;
15541 bool result;
15542 PyObject * obj0 = 0 ;
15543 PyObject * obj1 = 0 ;
15544 char *kwnames[] = {
15545 (char *) "self",(char *) "event", NULL
15546 };
15547
15548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15550 if (SWIG_arg_fail(1)) SWIG_fail;
15551 {
15552 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15553 if (SWIG_arg_fail(2)) SWIG_fail;
15554 if (arg2 == NULL) {
15555 SWIG_null_ref("wxEvent");
15556 }
15557 if (SWIG_arg_fail(2)) SWIG_fail;
15558 }
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 result = (bool)(arg1)->ProcessEvent(*arg2);
15562
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 {
15567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15568 }
15569 return resultobj;
15570 fail:
15571 return NULL;
15572 }
15573
15574
15575 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15576 PyObject *resultobj = NULL;
15577 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15578 wxEvent *arg2 = 0 ;
15579 PyObject * obj0 = 0 ;
15580 PyObject * obj1 = 0 ;
15581 char *kwnames[] = {
15582 (char *) "self",(char *) "event", NULL
15583 };
15584
15585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15587 if (SWIG_arg_fail(1)) SWIG_fail;
15588 {
15589 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15590 if (SWIG_arg_fail(2)) SWIG_fail;
15591 if (arg2 == NULL) {
15592 SWIG_null_ref("wxEvent");
15593 }
15594 if (SWIG_arg_fail(2)) SWIG_fail;
15595 }
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 (arg1)->AddPendingEvent(*arg2);
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 Py_INCREF(Py_None); resultobj = Py_None;
15604 return resultobj;
15605 fail:
15606 return NULL;
15607 }
15608
15609
15610 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15611 PyObject *resultobj = NULL;
15612 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15613 PyObject * obj0 = 0 ;
15614 char *kwnames[] = {
15615 (char *) "self", NULL
15616 };
15617
15618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15620 if (SWIG_arg_fail(1)) SWIG_fail;
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 (arg1)->ProcessPendingEvents();
15624
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 Py_INCREF(Py_None); resultobj = Py_None;
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15636 PyObject *resultobj = NULL;
15637 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15638 int arg2 ;
15639 int arg3 ;
15640 int arg4 ;
15641 PyObject *arg5 = (PyObject *) 0 ;
15642 PyObject * obj0 = 0 ;
15643 PyObject * obj1 = 0 ;
15644 PyObject * obj2 = 0 ;
15645 PyObject * obj3 = 0 ;
15646 PyObject * obj4 = 0 ;
15647 char *kwnames[] = {
15648 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15649 };
15650
15651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15653 if (SWIG_arg_fail(1)) SWIG_fail;
15654 {
15655 arg2 = static_cast<int >(SWIG_As_int(obj1));
15656 if (SWIG_arg_fail(2)) SWIG_fail;
15657 }
15658 {
15659 arg3 = static_cast<int >(SWIG_As_int(obj2));
15660 if (SWIG_arg_fail(3)) SWIG_fail;
15661 }
15662 {
15663 arg4 = static_cast<int >(SWIG_As_int(obj3));
15664 if (SWIG_arg_fail(4)) SWIG_fail;
15665 }
15666 arg5 = obj4;
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15670
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 Py_INCREF(Py_None); resultobj = Py_None;
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = NULL;
15683 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15684 int arg2 ;
15685 int arg3 = (int) -1 ;
15686 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15687 bool result;
15688 PyObject * obj0 = 0 ;
15689 PyObject * obj1 = 0 ;
15690 PyObject * obj2 = 0 ;
15691 PyObject * obj3 = 0 ;
15692 char *kwnames[] = {
15693 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15694 };
15695
15696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15698 if (SWIG_arg_fail(1)) SWIG_fail;
15699 {
15700 arg2 = static_cast<int >(SWIG_As_int(obj1));
15701 if (SWIG_arg_fail(2)) SWIG_fail;
15702 }
15703 if (obj2) {
15704 {
15705 arg3 = static_cast<int >(SWIG_As_int(obj2));
15706 if (SWIG_arg_fail(3)) SWIG_fail;
15707 }
15708 }
15709 if (obj3) {
15710 {
15711 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15712 if (SWIG_arg_fail(4)) SWIG_fail;
15713 }
15714 }
15715 {
15716 PyThreadState* __tstate = wxPyBeginAllowThreads();
15717 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15718
15719 wxPyEndAllowThreads(__tstate);
15720 if (PyErr_Occurred()) SWIG_fail;
15721 }
15722 {
15723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15724 }
15725 return resultobj;
15726 fail:
15727 return NULL;
15728 }
15729
15730
15731 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15732 PyObject *resultobj = NULL;
15733 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15734 PyObject *arg2 = (PyObject *) 0 ;
15735 bool arg3 = (bool) true ;
15736 PyObject * obj0 = 0 ;
15737 PyObject * obj1 = 0 ;
15738 PyObject * obj2 = 0 ;
15739 char *kwnames[] = {
15740 (char *) "self",(char *) "_self",(char *) "incref", NULL
15741 };
15742
15743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15745 if (SWIG_arg_fail(1)) SWIG_fail;
15746 arg2 = obj1;
15747 if (obj2) {
15748 {
15749 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15750 if (SWIG_arg_fail(3)) SWIG_fail;
15751 }
15752 }
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15756
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 Py_INCREF(Py_None); resultobj = Py_None;
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15768 PyObject *obj;
15769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15770 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15771 Py_INCREF(obj);
15772 return Py_BuildValue((char *)"");
15773 }
15774 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15775 PyObject *resultobj = NULL;
15776 wxEventType result;
15777 char *kwnames[] = {
15778 NULL
15779 };
15780
15781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 result = (wxEventType)wxNewEventType();
15785
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 {
15790 resultobj = SWIG_From_int(static_cast<int >(result));
15791 }
15792 return resultobj;
15793 fail:
15794 return NULL;
15795 }
15796
15797
15798 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15799 PyObject *resultobj = NULL;
15800 wxEvent *arg1 = (wxEvent *) 0 ;
15801 PyObject * obj0 = 0 ;
15802 char *kwnames[] = {
15803 (char *) "self", NULL
15804 };
15805
15806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15808 if (SWIG_arg_fail(1)) SWIG_fail;
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 delete arg1;
15812
15813 wxPyEndAllowThreads(__tstate);
15814 if (PyErr_Occurred()) SWIG_fail;
15815 }
15816 Py_INCREF(Py_None); resultobj = Py_None;
15817 return resultobj;
15818 fail:
15819 return NULL;
15820 }
15821
15822
15823 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15824 PyObject *resultobj = NULL;
15825 wxEvent *arg1 = (wxEvent *) 0 ;
15826 wxEventType arg2 ;
15827 PyObject * obj0 = 0 ;
15828 PyObject * obj1 = 0 ;
15829 char *kwnames[] = {
15830 (char *) "self",(char *) "typ", NULL
15831 };
15832
15833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15835 if (SWIG_arg_fail(1)) SWIG_fail;
15836 {
15837 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15838 if (SWIG_arg_fail(2)) SWIG_fail;
15839 }
15840 {
15841 PyThreadState* __tstate = wxPyBeginAllowThreads();
15842 (arg1)->SetEventType(arg2);
15843
15844 wxPyEndAllowThreads(__tstate);
15845 if (PyErr_Occurred()) SWIG_fail;
15846 }
15847 Py_INCREF(Py_None); resultobj = Py_None;
15848 return resultobj;
15849 fail:
15850 return NULL;
15851 }
15852
15853
15854 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15855 PyObject *resultobj = NULL;
15856 wxEvent *arg1 = (wxEvent *) 0 ;
15857 wxEventType result;
15858 PyObject * obj0 = 0 ;
15859 char *kwnames[] = {
15860 (char *) "self", NULL
15861 };
15862
15863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15865 if (SWIG_arg_fail(1)) SWIG_fail;
15866 {
15867 PyThreadState* __tstate = wxPyBeginAllowThreads();
15868 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15869
15870 wxPyEndAllowThreads(__tstate);
15871 if (PyErr_Occurred()) SWIG_fail;
15872 }
15873 {
15874 resultobj = SWIG_From_int(static_cast<int >(result));
15875 }
15876 return resultobj;
15877 fail:
15878 return NULL;
15879 }
15880
15881
15882 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15883 PyObject *resultobj = NULL;
15884 wxEvent *arg1 = (wxEvent *) 0 ;
15885 wxObject *result;
15886 PyObject * obj0 = 0 ;
15887 char *kwnames[] = {
15888 (char *) "self", NULL
15889 };
15890
15891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15893 if (SWIG_arg_fail(1)) SWIG_fail;
15894 {
15895 PyThreadState* __tstate = wxPyBeginAllowThreads();
15896 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15897
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 {
15902 resultobj = wxPyMake_wxObject(result, (bool)0);
15903 }
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj = NULL;
15912 wxEvent *arg1 = (wxEvent *) 0 ;
15913 wxObject *arg2 = (wxObject *) 0 ;
15914 PyObject * obj0 = 0 ;
15915 PyObject * obj1 = 0 ;
15916 char *kwnames[] = {
15917 (char *) "self",(char *) "obj", NULL
15918 };
15919
15920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15922 if (SWIG_arg_fail(1)) SWIG_fail;
15923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15924 if (SWIG_arg_fail(2)) SWIG_fail;
15925 {
15926 PyThreadState* __tstate = wxPyBeginAllowThreads();
15927 (arg1)->SetEventObject(arg2);
15928
15929 wxPyEndAllowThreads(__tstate);
15930 if (PyErr_Occurred()) SWIG_fail;
15931 }
15932 Py_INCREF(Py_None); resultobj = Py_None;
15933 return resultobj;
15934 fail:
15935 return NULL;
15936 }
15937
15938
15939 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15940 PyObject *resultobj = NULL;
15941 wxEvent *arg1 = (wxEvent *) 0 ;
15942 long result;
15943 PyObject * obj0 = 0 ;
15944 char *kwnames[] = {
15945 (char *) "self", NULL
15946 };
15947
15948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15950 if (SWIG_arg_fail(1)) SWIG_fail;
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15954
15955 wxPyEndAllowThreads(__tstate);
15956 if (PyErr_Occurred()) SWIG_fail;
15957 }
15958 {
15959 resultobj = SWIG_From_long(static_cast<long >(result));
15960 }
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj = NULL;
15969 wxEvent *arg1 = (wxEvent *) 0 ;
15970 long arg2 = (long) 0 ;
15971 PyObject * obj0 = 0 ;
15972 PyObject * obj1 = 0 ;
15973 char *kwnames[] = {
15974 (char *) "self",(char *) "ts", NULL
15975 };
15976
15977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15979 if (SWIG_arg_fail(1)) SWIG_fail;
15980 if (obj1) {
15981 {
15982 arg2 = static_cast<long >(SWIG_As_long(obj1));
15983 if (SWIG_arg_fail(2)) SWIG_fail;
15984 }
15985 }
15986 {
15987 PyThreadState* __tstate = wxPyBeginAllowThreads();
15988 (arg1)->SetTimestamp(arg2);
15989
15990 wxPyEndAllowThreads(__tstate);
15991 if (PyErr_Occurred()) SWIG_fail;
15992 }
15993 Py_INCREF(Py_None); resultobj = Py_None;
15994 return resultobj;
15995 fail:
15996 return NULL;
15997 }
15998
15999
16000 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
16001 PyObject *resultobj = NULL;
16002 wxEvent *arg1 = (wxEvent *) 0 ;
16003 int result;
16004 PyObject * obj0 = 0 ;
16005 char *kwnames[] = {
16006 (char *) "self", NULL
16007 };
16008
16009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
16010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16011 if (SWIG_arg_fail(1)) SWIG_fail;
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 result = (int)((wxEvent const *)arg1)->GetId();
16015
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 {
16020 resultobj = SWIG_From_int(static_cast<int >(result));
16021 }
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
16029 PyObject *resultobj = NULL;
16030 wxEvent *arg1 = (wxEvent *) 0 ;
16031 int arg2 ;
16032 PyObject * obj0 = 0 ;
16033 PyObject * obj1 = 0 ;
16034 char *kwnames[] = {
16035 (char *) "self",(char *) "Id", NULL
16036 };
16037
16038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
16039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16040 if (SWIG_arg_fail(1)) SWIG_fail;
16041 {
16042 arg2 = static_cast<int >(SWIG_As_int(obj1));
16043 if (SWIG_arg_fail(2)) SWIG_fail;
16044 }
16045 {
16046 PyThreadState* __tstate = wxPyBeginAllowThreads();
16047 (arg1)->SetId(arg2);
16048
16049 wxPyEndAllowThreads(__tstate);
16050 if (PyErr_Occurred()) SWIG_fail;
16051 }
16052 Py_INCREF(Py_None); resultobj = Py_None;
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj = NULL;
16061 wxEvent *arg1 = (wxEvent *) 0 ;
16062 bool result;
16063 PyObject * obj0 = 0 ;
16064 char *kwnames[] = {
16065 (char *) "self", NULL
16066 };
16067
16068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16070 if (SWIG_arg_fail(1)) SWIG_fail;
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16074
16075 wxPyEndAllowThreads(__tstate);
16076 if (PyErr_Occurred()) SWIG_fail;
16077 }
16078 {
16079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16080 }
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16088 PyObject *resultobj = NULL;
16089 wxEvent *arg1 = (wxEvent *) 0 ;
16090 bool arg2 = (bool) true ;
16091 PyObject * obj0 = 0 ;
16092 PyObject * obj1 = 0 ;
16093 char *kwnames[] = {
16094 (char *) "self",(char *) "skip", NULL
16095 };
16096
16097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16099 if (SWIG_arg_fail(1)) SWIG_fail;
16100 if (obj1) {
16101 {
16102 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16103 if (SWIG_arg_fail(2)) SWIG_fail;
16104 }
16105 }
16106 {
16107 PyThreadState* __tstate = wxPyBeginAllowThreads();
16108 (arg1)->Skip(arg2);
16109
16110 wxPyEndAllowThreads(__tstate);
16111 if (PyErr_Occurred()) SWIG_fail;
16112 }
16113 Py_INCREF(Py_None); resultobj = Py_None;
16114 return resultobj;
16115 fail:
16116 return NULL;
16117 }
16118
16119
16120 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16121 PyObject *resultobj = NULL;
16122 wxEvent *arg1 = (wxEvent *) 0 ;
16123 bool result;
16124 PyObject * obj0 = 0 ;
16125 char *kwnames[] = {
16126 (char *) "self", NULL
16127 };
16128
16129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16131 if (SWIG_arg_fail(1)) SWIG_fail;
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16135
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 {
16140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16141 }
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj = NULL;
16150 wxEvent *arg1 = (wxEvent *) 0 ;
16151 bool result;
16152 PyObject * obj0 = 0 ;
16153 char *kwnames[] = {
16154 (char *) "self", NULL
16155 };
16156
16157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16159 if (SWIG_arg_fail(1)) SWIG_fail;
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16163
16164 wxPyEndAllowThreads(__tstate);
16165 if (PyErr_Occurred()) SWIG_fail;
16166 }
16167 {
16168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16169 }
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16177 PyObject *resultobj = NULL;
16178 wxEvent *arg1 = (wxEvent *) 0 ;
16179 int result;
16180 PyObject * obj0 = 0 ;
16181 char *kwnames[] = {
16182 (char *) "self", NULL
16183 };
16184
16185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16187 if (SWIG_arg_fail(1)) SWIG_fail;
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 result = (int)(arg1)->StopPropagation();
16191
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 {
16196 resultobj = SWIG_From_int(static_cast<int >(result));
16197 }
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = NULL;
16206 wxEvent *arg1 = (wxEvent *) 0 ;
16207 int arg2 ;
16208 PyObject * obj0 = 0 ;
16209 PyObject * obj1 = 0 ;
16210 char *kwnames[] = {
16211 (char *) "self",(char *) "propagationLevel", NULL
16212 };
16213
16214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16216 if (SWIG_arg_fail(1)) SWIG_fail;
16217 {
16218 arg2 = static_cast<int >(SWIG_As_int(obj1));
16219 if (SWIG_arg_fail(2)) SWIG_fail;
16220 }
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 (arg1)->ResumePropagation(arg2);
16224
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 Py_INCREF(Py_None); resultobj = Py_None;
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj = NULL;
16237 wxEvent *arg1 = (wxEvent *) 0 ;
16238 wxEvent *result;
16239 PyObject * obj0 = 0 ;
16240 char *kwnames[] = {
16241 (char *) "self", NULL
16242 };
16243
16244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16246 if (SWIG_arg_fail(1)) SWIG_fail;
16247 {
16248 PyThreadState* __tstate = wxPyBeginAllowThreads();
16249 result = (wxEvent *)(arg1)->Clone();
16250
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16262 PyObject *obj;
16263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16264 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16265 Py_INCREF(obj);
16266 return Py_BuildValue((char *)"");
16267 }
16268 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16269 PyObject *resultobj = NULL;
16270 wxEvent *arg1 = 0 ;
16271 wxPropagationDisabler *result;
16272 PyObject * obj0 = 0 ;
16273 char *kwnames[] = {
16274 (char *) "event", NULL
16275 };
16276
16277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16278 {
16279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16280 if (SWIG_arg_fail(1)) SWIG_fail;
16281 if (arg1 == NULL) {
16282 SWIG_null_ref("wxEvent");
16283 }
16284 if (SWIG_arg_fail(1)) SWIG_fail;
16285 }
16286 {
16287 PyThreadState* __tstate = wxPyBeginAllowThreads();
16288 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16289
16290 wxPyEndAllowThreads(__tstate);
16291 if (PyErr_Occurred()) SWIG_fail;
16292 }
16293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16294 return resultobj;
16295 fail:
16296 return NULL;
16297 }
16298
16299
16300 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16301 PyObject *resultobj = NULL;
16302 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16303 PyObject * obj0 = 0 ;
16304 char *kwnames[] = {
16305 (char *) "self", NULL
16306 };
16307
16308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16310 if (SWIG_arg_fail(1)) SWIG_fail;
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 delete arg1;
16314
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 Py_INCREF(Py_None); resultobj = Py_None;
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16326 PyObject *obj;
16327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16328 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16329 Py_INCREF(obj);
16330 return Py_BuildValue((char *)"");
16331 }
16332 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj = NULL;
16334 wxEvent *arg1 = 0 ;
16335 wxPropagateOnce *result;
16336 PyObject * obj0 = 0 ;
16337 char *kwnames[] = {
16338 (char *) "event", NULL
16339 };
16340
16341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16342 {
16343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16344 if (SWIG_arg_fail(1)) SWIG_fail;
16345 if (arg1 == NULL) {
16346 SWIG_null_ref("wxEvent");
16347 }
16348 if (SWIG_arg_fail(1)) SWIG_fail;
16349 }
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16353
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16358 return resultobj;
16359 fail:
16360 return NULL;
16361 }
16362
16363
16364 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16365 PyObject *resultobj = NULL;
16366 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16367 PyObject * obj0 = 0 ;
16368 char *kwnames[] = {
16369 (char *) "self", NULL
16370 };
16371
16372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16374 if (SWIG_arg_fail(1)) SWIG_fail;
16375 {
16376 PyThreadState* __tstate = wxPyBeginAllowThreads();
16377 delete arg1;
16378
16379 wxPyEndAllowThreads(__tstate);
16380 if (PyErr_Occurred()) SWIG_fail;
16381 }
16382 Py_INCREF(Py_None); resultobj = Py_None;
16383 return resultobj;
16384 fail:
16385 return NULL;
16386 }
16387
16388
16389 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16390 PyObject *obj;
16391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16392 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16393 Py_INCREF(obj);
16394 return Py_BuildValue((char *)"");
16395 }
16396 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16397 PyObject *resultobj = NULL;
16398 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16399 int arg2 = (int) 0 ;
16400 wxCommandEvent *result;
16401 PyObject * obj0 = 0 ;
16402 PyObject * obj1 = 0 ;
16403 char *kwnames[] = {
16404 (char *) "commandType",(char *) "winid", NULL
16405 };
16406
16407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16408 if (obj0) {
16409 {
16410 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16411 if (SWIG_arg_fail(1)) SWIG_fail;
16412 }
16413 }
16414 if (obj1) {
16415 {
16416 arg2 = static_cast<int >(SWIG_As_int(obj1));
16417 if (SWIG_arg_fail(2)) SWIG_fail;
16418 }
16419 }
16420 {
16421 PyThreadState* __tstate = wxPyBeginAllowThreads();
16422 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16423
16424 wxPyEndAllowThreads(__tstate);
16425 if (PyErr_Occurred()) SWIG_fail;
16426 }
16427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16428 return resultobj;
16429 fail:
16430 return NULL;
16431 }
16432
16433
16434 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16435 PyObject *resultobj = NULL;
16436 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16437 int result;
16438 PyObject * obj0 = 0 ;
16439 char *kwnames[] = {
16440 (char *) "self", NULL
16441 };
16442
16443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16445 if (SWIG_arg_fail(1)) SWIG_fail;
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16449
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 {
16454 resultobj = SWIG_From_int(static_cast<int >(result));
16455 }
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj = NULL;
16464 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16465 wxString *arg2 = 0 ;
16466 bool temp2 = false ;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 char *kwnames[] = {
16470 (char *) "self",(char *) "s", NULL
16471 };
16472
16473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16475 if (SWIG_arg_fail(1)) SWIG_fail;
16476 {
16477 arg2 = wxString_in_helper(obj1);
16478 if (arg2 == NULL) SWIG_fail;
16479 temp2 = true;
16480 }
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 (arg1)->SetString((wxString const &)*arg2);
16484
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 Py_INCREF(Py_None); resultobj = Py_None;
16489 {
16490 if (temp2)
16491 delete arg2;
16492 }
16493 return resultobj;
16494 fail:
16495 {
16496 if (temp2)
16497 delete arg2;
16498 }
16499 return NULL;
16500 }
16501
16502
16503 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj = NULL;
16505 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16506 wxString result;
16507 PyObject * obj0 = 0 ;
16508 char *kwnames[] = {
16509 (char *) "self", NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16514 if (SWIG_arg_fail(1)) SWIG_fail;
16515 {
16516 PyThreadState* __tstate = wxPyBeginAllowThreads();
16517 result = ((wxCommandEvent const *)arg1)->GetString();
16518
16519 wxPyEndAllowThreads(__tstate);
16520 if (PyErr_Occurred()) SWIG_fail;
16521 }
16522 {
16523 #if wxUSE_UNICODE
16524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16525 #else
16526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16527 #endif
16528 }
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj = NULL;
16537 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16538 bool result;
16539 PyObject * obj0 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16546 if (SWIG_arg_fail(1)) SWIG_fail;
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16550
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 {
16555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16556 }
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj = NULL;
16565 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16566 bool result;
16567 PyObject * obj0 = 0 ;
16568 char *kwnames[] = {
16569 (char *) "self", NULL
16570 };
16571
16572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16574 if (SWIG_arg_fail(1)) SWIG_fail;
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16578
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16584 }
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj = NULL;
16593 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16594 long arg2 ;
16595 PyObject * obj0 = 0 ;
16596 PyObject * obj1 = 0 ;
16597 char *kwnames[] = {
16598 (char *) "self",(char *) "extraLong", NULL
16599 };
16600
16601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16603 if (SWIG_arg_fail(1)) SWIG_fail;
16604 {
16605 arg2 = static_cast<long >(SWIG_As_long(obj1));
16606 if (SWIG_arg_fail(2)) SWIG_fail;
16607 }
16608 {
16609 PyThreadState* __tstate = wxPyBeginAllowThreads();
16610 (arg1)->SetExtraLong(arg2);
16611
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 Py_INCREF(Py_None); resultobj = Py_None;
16616 return resultobj;
16617 fail:
16618 return NULL;
16619 }
16620
16621
16622 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16623 PyObject *resultobj = NULL;
16624 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16625 long result;
16626 PyObject * obj0 = 0 ;
16627 char *kwnames[] = {
16628 (char *) "self", NULL
16629 };
16630
16631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16633 if (SWIG_arg_fail(1)) SWIG_fail;
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 resultobj = SWIG_From_long(static_cast<long >(result));
16643 }
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj = NULL;
16652 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16653 int arg2 ;
16654 PyObject * obj0 = 0 ;
16655 PyObject * obj1 = 0 ;
16656 char *kwnames[] = {
16657 (char *) "self",(char *) "i", NULL
16658 };
16659
16660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16662 if (SWIG_arg_fail(1)) SWIG_fail;
16663 {
16664 arg2 = static_cast<int >(SWIG_As_int(obj1));
16665 if (SWIG_arg_fail(2)) SWIG_fail;
16666 }
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 (arg1)->SetInt(arg2);
16670
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 Py_INCREF(Py_None); resultobj = Py_None;
16675 return resultobj;
16676 fail:
16677 return NULL;
16678 }
16679
16680
16681 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16682 PyObject *resultobj = NULL;
16683 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16684 long result;
16685 PyObject * obj0 = 0 ;
16686 char *kwnames[] = {
16687 (char *) "self", NULL
16688 };
16689
16690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16692 if (SWIG_arg_fail(1)) SWIG_fail;
16693 {
16694 PyThreadState* __tstate = wxPyBeginAllowThreads();
16695 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16696
16697 wxPyEndAllowThreads(__tstate);
16698 if (PyErr_Occurred()) SWIG_fail;
16699 }
16700 {
16701 resultobj = SWIG_From_long(static_cast<long >(result));
16702 }
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj = NULL;
16711 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16712 wxEvent *result;
16713 PyObject * obj0 = 0 ;
16714 char *kwnames[] = {
16715 (char *) "self", NULL
16716 };
16717
16718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16720 if (SWIG_arg_fail(1)) SWIG_fail;
16721 {
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16724
16725 wxPyEndAllowThreads(__tstate);
16726 if (PyErr_Occurred()) SWIG_fail;
16727 }
16728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16736 PyObject *obj;
16737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16738 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16739 Py_INCREF(obj);
16740 return Py_BuildValue((char *)"");
16741 }
16742 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16743 PyObject *resultobj = NULL;
16744 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16745 int arg2 = (int) 0 ;
16746 wxNotifyEvent *result;
16747 PyObject * obj0 = 0 ;
16748 PyObject * obj1 = 0 ;
16749 char *kwnames[] = {
16750 (char *) "commandType",(char *) "winid", NULL
16751 };
16752
16753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16754 if (obj0) {
16755 {
16756 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16757 if (SWIG_arg_fail(1)) SWIG_fail;
16758 }
16759 }
16760 if (obj1) {
16761 {
16762 arg2 = static_cast<int >(SWIG_As_int(obj1));
16763 if (SWIG_arg_fail(2)) SWIG_fail;
16764 }
16765 }
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16769
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = NULL;
16782 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16783 PyObject * obj0 = 0 ;
16784 char *kwnames[] = {
16785 (char *) "self", NULL
16786 };
16787
16788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16790 if (SWIG_arg_fail(1)) SWIG_fail;
16791 {
16792 PyThreadState* __tstate = wxPyBeginAllowThreads();
16793 (arg1)->Veto();
16794
16795 wxPyEndAllowThreads(__tstate);
16796 if (PyErr_Occurred()) SWIG_fail;
16797 }
16798 Py_INCREF(Py_None); resultobj = Py_None;
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj = NULL;
16807 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16808 PyObject * obj0 = 0 ;
16809 char *kwnames[] = {
16810 (char *) "self", NULL
16811 };
16812
16813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16815 if (SWIG_arg_fail(1)) SWIG_fail;
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 (arg1)->Allow();
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 Py_INCREF(Py_None); resultobj = Py_None;
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16831 PyObject *resultobj = NULL;
16832 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16833 bool result;
16834 PyObject * obj0 = 0 ;
16835 char *kwnames[] = {
16836 (char *) "self", NULL
16837 };
16838
16839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16841 if (SWIG_arg_fail(1)) SWIG_fail;
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = (bool)(arg1)->IsAllowed();
16845
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 {
16850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16851 }
16852 return resultobj;
16853 fail:
16854 return NULL;
16855 }
16856
16857
16858 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16859 PyObject *obj;
16860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16861 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16862 Py_INCREF(obj);
16863 return Py_BuildValue((char *)"");
16864 }
16865 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16866 PyObject *resultobj = NULL;
16867 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16868 int arg2 = (int) 0 ;
16869 int arg3 = (int) 0 ;
16870 int arg4 = (int) 0 ;
16871 wxScrollEvent *result;
16872 PyObject * obj0 = 0 ;
16873 PyObject * obj1 = 0 ;
16874 PyObject * obj2 = 0 ;
16875 PyObject * obj3 = 0 ;
16876 char *kwnames[] = {
16877 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16878 };
16879
16880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16881 if (obj0) {
16882 {
16883 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16884 if (SWIG_arg_fail(1)) SWIG_fail;
16885 }
16886 }
16887 if (obj1) {
16888 {
16889 arg2 = static_cast<int >(SWIG_As_int(obj1));
16890 if (SWIG_arg_fail(2)) SWIG_fail;
16891 }
16892 }
16893 if (obj2) {
16894 {
16895 arg3 = static_cast<int >(SWIG_As_int(obj2));
16896 if (SWIG_arg_fail(3)) SWIG_fail;
16897 }
16898 }
16899 if (obj3) {
16900 {
16901 arg4 = static_cast<int >(SWIG_As_int(obj3));
16902 if (SWIG_arg_fail(4)) SWIG_fail;
16903 }
16904 }
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16908
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16920 PyObject *resultobj = NULL;
16921 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16922 int result;
16923 PyObject * obj0 = 0 ;
16924 char *kwnames[] = {
16925 (char *) "self", NULL
16926 };
16927
16928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16930 if (SWIG_arg_fail(1)) SWIG_fail;
16931 {
16932 PyThreadState* __tstate = wxPyBeginAllowThreads();
16933 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16934
16935 wxPyEndAllowThreads(__tstate);
16936 if (PyErr_Occurred()) SWIG_fail;
16937 }
16938 {
16939 resultobj = SWIG_From_int(static_cast<int >(result));
16940 }
16941 return resultobj;
16942 fail:
16943 return NULL;
16944 }
16945
16946
16947 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16948 PyObject *resultobj = NULL;
16949 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16950 int result;
16951 PyObject * obj0 = 0 ;
16952 char *kwnames[] = {
16953 (char *) "self", NULL
16954 };
16955
16956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16958 if (SWIG_arg_fail(1)) SWIG_fail;
16959 {
16960 PyThreadState* __tstate = wxPyBeginAllowThreads();
16961 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16962
16963 wxPyEndAllowThreads(__tstate);
16964 if (PyErr_Occurred()) SWIG_fail;
16965 }
16966 {
16967 resultobj = SWIG_From_int(static_cast<int >(result));
16968 }
16969 return resultobj;
16970 fail:
16971 return NULL;
16972 }
16973
16974
16975 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16976 PyObject *resultobj = NULL;
16977 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16978 int arg2 ;
16979 PyObject * obj0 = 0 ;
16980 PyObject * obj1 = 0 ;
16981 char *kwnames[] = {
16982 (char *) "self",(char *) "orient", NULL
16983 };
16984
16985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16987 if (SWIG_arg_fail(1)) SWIG_fail;
16988 {
16989 arg2 = static_cast<int >(SWIG_As_int(obj1));
16990 if (SWIG_arg_fail(2)) SWIG_fail;
16991 }
16992 {
16993 PyThreadState* __tstate = wxPyBeginAllowThreads();
16994 (arg1)->SetOrientation(arg2);
16995
16996 wxPyEndAllowThreads(__tstate);
16997 if (PyErr_Occurred()) SWIG_fail;
16998 }
16999 Py_INCREF(Py_None); resultobj = Py_None;
17000 return resultobj;
17001 fail:
17002 return NULL;
17003 }
17004
17005
17006 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17007 PyObject *resultobj = NULL;
17008 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
17009 int arg2 ;
17010 PyObject * obj0 = 0 ;
17011 PyObject * obj1 = 0 ;
17012 char *kwnames[] = {
17013 (char *) "self",(char *) "pos", NULL
17014 };
17015
17016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
17018 if (SWIG_arg_fail(1)) SWIG_fail;
17019 {
17020 arg2 = static_cast<int >(SWIG_As_int(obj1));
17021 if (SWIG_arg_fail(2)) SWIG_fail;
17022 }
17023 {
17024 PyThreadState* __tstate = wxPyBeginAllowThreads();
17025 (arg1)->SetPosition(arg2);
17026
17027 wxPyEndAllowThreads(__tstate);
17028 if (PyErr_Occurred()) SWIG_fail;
17029 }
17030 Py_INCREF(Py_None); resultobj = Py_None;
17031 return resultobj;
17032 fail:
17033 return NULL;
17034 }
17035
17036
17037 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
17038 PyObject *obj;
17039 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17040 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
17041 Py_INCREF(obj);
17042 return Py_BuildValue((char *)"");
17043 }
17044 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17045 PyObject *resultobj = NULL;
17046 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17047 int arg2 = (int) 0 ;
17048 int arg3 = (int) 0 ;
17049 wxScrollWinEvent *result;
17050 PyObject * obj0 = 0 ;
17051 PyObject * obj1 = 0 ;
17052 PyObject * obj2 = 0 ;
17053 char *kwnames[] = {
17054 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17055 };
17056
17057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17058 if (obj0) {
17059 {
17060 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17061 if (SWIG_arg_fail(1)) SWIG_fail;
17062 }
17063 }
17064 if (obj1) {
17065 {
17066 arg2 = static_cast<int >(SWIG_As_int(obj1));
17067 if (SWIG_arg_fail(2)) SWIG_fail;
17068 }
17069 }
17070 if (obj2) {
17071 {
17072 arg3 = static_cast<int >(SWIG_As_int(obj2));
17073 if (SWIG_arg_fail(3)) SWIG_fail;
17074 }
17075 }
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17079
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17084 return resultobj;
17085 fail:
17086 return NULL;
17087 }
17088
17089
17090 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17091 PyObject *resultobj = NULL;
17092 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17093 int result;
17094 PyObject * obj0 = 0 ;
17095 char *kwnames[] = {
17096 (char *) "self", NULL
17097 };
17098
17099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17101 if (SWIG_arg_fail(1)) SWIG_fail;
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17105
17106 wxPyEndAllowThreads(__tstate);
17107 if (PyErr_Occurred()) SWIG_fail;
17108 }
17109 {
17110 resultobj = SWIG_From_int(static_cast<int >(result));
17111 }
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17119 PyObject *resultobj = NULL;
17120 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17121 int result;
17122 PyObject * obj0 = 0 ;
17123 char *kwnames[] = {
17124 (char *) "self", NULL
17125 };
17126
17127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17129 if (SWIG_arg_fail(1)) SWIG_fail;
17130 {
17131 PyThreadState* __tstate = wxPyBeginAllowThreads();
17132 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17133
17134 wxPyEndAllowThreads(__tstate);
17135 if (PyErr_Occurred()) SWIG_fail;
17136 }
17137 {
17138 resultobj = SWIG_From_int(static_cast<int >(result));
17139 }
17140 return resultobj;
17141 fail:
17142 return NULL;
17143 }
17144
17145
17146 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17147 PyObject *resultobj = NULL;
17148 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17149 int arg2 ;
17150 PyObject * obj0 = 0 ;
17151 PyObject * obj1 = 0 ;
17152 char *kwnames[] = {
17153 (char *) "self",(char *) "orient", NULL
17154 };
17155
17156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17158 if (SWIG_arg_fail(1)) SWIG_fail;
17159 {
17160 arg2 = static_cast<int >(SWIG_As_int(obj1));
17161 if (SWIG_arg_fail(2)) SWIG_fail;
17162 }
17163 {
17164 PyThreadState* __tstate = wxPyBeginAllowThreads();
17165 (arg1)->SetOrientation(arg2);
17166
17167 wxPyEndAllowThreads(__tstate);
17168 if (PyErr_Occurred()) SWIG_fail;
17169 }
17170 Py_INCREF(Py_None); resultobj = Py_None;
17171 return resultobj;
17172 fail:
17173 return NULL;
17174 }
17175
17176
17177 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17178 PyObject *resultobj = NULL;
17179 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17180 int arg2 ;
17181 PyObject * obj0 = 0 ;
17182 PyObject * obj1 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "self",(char *) "pos", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 {
17191 arg2 = static_cast<int >(SWIG_As_int(obj1));
17192 if (SWIG_arg_fail(2)) SWIG_fail;
17193 }
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 (arg1)->SetPosition(arg2);
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 Py_INCREF(Py_None); resultobj = Py_None;
17202 return resultobj;
17203 fail:
17204 return NULL;
17205 }
17206
17207
17208 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17209 PyObject *obj;
17210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17211 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17212 Py_INCREF(obj);
17213 return Py_BuildValue((char *)"");
17214 }
17215 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17216 PyObject *resultobj = NULL;
17217 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17218 wxMouseEvent *result;
17219 PyObject * obj0 = 0 ;
17220 char *kwnames[] = {
17221 (char *) "mouseType", NULL
17222 };
17223
17224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17225 if (obj0) {
17226 {
17227 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17228 if (SWIG_arg_fail(1)) SWIG_fail;
17229 }
17230 }
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 {
17239 resultobj = wxPyMake_wxObject(result, (bool)1);
17240 }
17241 return resultobj;
17242 fail:
17243 return NULL;
17244 }
17245
17246
17247 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17248 PyObject *resultobj = NULL;
17249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17250 bool result;
17251 PyObject * obj0 = 0 ;
17252 char *kwnames[] = {
17253 (char *) "self", NULL
17254 };
17255
17256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17258 if (SWIG_arg_fail(1)) SWIG_fail;
17259 {
17260 PyThreadState* __tstate = wxPyBeginAllowThreads();
17261 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17262
17263 wxPyEndAllowThreads(__tstate);
17264 if (PyErr_Occurred()) SWIG_fail;
17265 }
17266 {
17267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17268 }
17269 return resultobj;
17270 fail:
17271 return NULL;
17272 }
17273
17274
17275 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17276 PyObject *resultobj = NULL;
17277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17278 int arg2 = (int) wxMOUSE_BTN_ANY ;
17279 bool result;
17280 PyObject * obj0 = 0 ;
17281 PyObject * obj1 = 0 ;
17282 char *kwnames[] = {
17283 (char *) "self",(char *) "but", NULL
17284 };
17285
17286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17288 if (SWIG_arg_fail(1)) SWIG_fail;
17289 if (obj1) {
17290 {
17291 arg2 = static_cast<int >(SWIG_As_int(obj1));
17292 if (SWIG_arg_fail(2)) SWIG_fail;
17293 }
17294 }
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17298
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 {
17303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17304 }
17305 return resultobj;
17306 fail:
17307 return NULL;
17308 }
17309
17310
17311 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17312 PyObject *resultobj = NULL;
17313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17314 int arg2 = (int) wxMOUSE_BTN_ANY ;
17315 bool result;
17316 PyObject * obj0 = 0 ;
17317 PyObject * obj1 = 0 ;
17318 char *kwnames[] = {
17319 (char *) "self",(char *) "but", NULL
17320 };
17321
17322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17324 if (SWIG_arg_fail(1)) SWIG_fail;
17325 if (obj1) {
17326 {
17327 arg2 = static_cast<int >(SWIG_As_int(obj1));
17328 if (SWIG_arg_fail(2)) SWIG_fail;
17329 }
17330 }
17331 {
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17334
17335 wxPyEndAllowThreads(__tstate);
17336 if (PyErr_Occurred()) SWIG_fail;
17337 }
17338 {
17339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17340 }
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj = NULL;
17349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17350 int arg2 = (int) wxMOUSE_BTN_ANY ;
17351 bool result;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 char *kwnames[] = {
17355 (char *) "self",(char *) "but", NULL
17356 };
17357
17358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17360 if (SWIG_arg_fail(1)) SWIG_fail;
17361 if (obj1) {
17362 {
17363 arg2 = static_cast<int >(SWIG_As_int(obj1));
17364 if (SWIG_arg_fail(2)) SWIG_fail;
17365 }
17366 }
17367 {
17368 PyThreadState* __tstate = wxPyBeginAllowThreads();
17369 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17370
17371 wxPyEndAllowThreads(__tstate);
17372 if (PyErr_Occurred()) SWIG_fail;
17373 }
17374 {
17375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17376 }
17377 return resultobj;
17378 fail:
17379 return NULL;
17380 }
17381
17382
17383 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17384 PyObject *resultobj = NULL;
17385 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17386 int arg2 ;
17387 bool result;
17388 PyObject * obj0 = 0 ;
17389 PyObject * obj1 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self",(char *) "button", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 {
17398 arg2 = static_cast<int >(SWIG_As_int(obj1));
17399 if (SWIG_arg_fail(2)) SWIG_fail;
17400 }
17401 {
17402 PyThreadState* __tstate = wxPyBeginAllowThreads();
17403 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17404
17405 wxPyEndAllowThreads(__tstate);
17406 if (PyErr_Occurred()) SWIG_fail;
17407 }
17408 {
17409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17410 }
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj = NULL;
17419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17420 int arg2 ;
17421 bool result;
17422 PyObject * obj0 = 0 ;
17423 PyObject * obj1 = 0 ;
17424 char *kwnames[] = {
17425 (char *) "self",(char *) "but", NULL
17426 };
17427
17428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17430 if (SWIG_arg_fail(1)) SWIG_fail;
17431 {
17432 arg2 = static_cast<int >(SWIG_As_int(obj1));
17433 if (SWIG_arg_fail(2)) SWIG_fail;
17434 }
17435 {
17436 PyThreadState* __tstate = wxPyBeginAllowThreads();
17437 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17438
17439 wxPyEndAllowThreads(__tstate);
17440 if (PyErr_Occurred()) SWIG_fail;
17441 }
17442 {
17443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17444 }
17445 return resultobj;
17446 fail:
17447 return NULL;
17448 }
17449
17450
17451 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17452 PyObject *resultobj = NULL;
17453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17454 int result;
17455 PyObject * obj0 = 0 ;
17456 char *kwnames[] = {
17457 (char *) "self", NULL
17458 };
17459
17460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17462 if (SWIG_arg_fail(1)) SWIG_fail;
17463 {
17464 PyThreadState* __tstate = wxPyBeginAllowThreads();
17465 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17466
17467 wxPyEndAllowThreads(__tstate);
17468 if (PyErr_Occurred()) SWIG_fail;
17469 }
17470 {
17471 resultobj = SWIG_From_int(static_cast<int >(result));
17472 }
17473 return resultobj;
17474 fail:
17475 return NULL;
17476 }
17477
17478
17479 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17480 PyObject *resultobj = NULL;
17481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17482 bool result;
17483 PyObject * obj0 = 0 ;
17484 char *kwnames[] = {
17485 (char *) "self", NULL
17486 };
17487
17488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17490 if (SWIG_arg_fail(1)) SWIG_fail;
17491 {
17492 PyThreadState* __tstate = wxPyBeginAllowThreads();
17493 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17494
17495 wxPyEndAllowThreads(__tstate);
17496 if (PyErr_Occurred()) SWIG_fail;
17497 }
17498 {
17499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17500 }
17501 return resultobj;
17502 fail:
17503 return NULL;
17504 }
17505
17506
17507 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17508 PyObject *resultobj = NULL;
17509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17510 bool result;
17511 PyObject * obj0 = 0 ;
17512 char *kwnames[] = {
17513 (char *) "self", NULL
17514 };
17515
17516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17518 if (SWIG_arg_fail(1)) SWIG_fail;
17519 {
17520 PyThreadState* __tstate = wxPyBeginAllowThreads();
17521 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17522
17523 wxPyEndAllowThreads(__tstate);
17524 if (PyErr_Occurred()) SWIG_fail;
17525 }
17526 {
17527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17528 }
17529 return resultobj;
17530 fail:
17531 return NULL;
17532 }
17533
17534
17535 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17536 PyObject *resultobj = NULL;
17537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17538 bool result;
17539 PyObject * obj0 = 0 ;
17540 char *kwnames[] = {
17541 (char *) "self", NULL
17542 };
17543
17544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17546 if (SWIG_arg_fail(1)) SWIG_fail;
17547 {
17548 PyThreadState* __tstate = wxPyBeginAllowThreads();
17549 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17550
17551 wxPyEndAllowThreads(__tstate);
17552 if (PyErr_Occurred()) SWIG_fail;
17553 }
17554 {
17555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17556 }
17557 return resultobj;
17558 fail:
17559 return NULL;
17560 }
17561
17562
17563 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17564 PyObject *resultobj = NULL;
17565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17566 bool result;
17567 PyObject * obj0 = 0 ;
17568 char *kwnames[] = {
17569 (char *) "self", NULL
17570 };
17571
17572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17574 if (SWIG_arg_fail(1)) SWIG_fail;
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17584 }
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17592 PyObject *resultobj = NULL;
17593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17594 bool result;
17595 PyObject * obj0 = 0 ;
17596 char *kwnames[] = {
17597 (char *) "self", NULL
17598 };
17599
17600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17602 if (SWIG_arg_fail(1)) SWIG_fail;
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17606
17607 wxPyEndAllowThreads(__tstate);
17608 if (PyErr_Occurred()) SWIG_fail;
17609 }
17610 {
17611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17612 }
17613 return resultobj;
17614 fail:
17615 return NULL;
17616 }
17617
17618
17619 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17620 PyObject *resultobj = NULL;
17621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17622 bool result;
17623 PyObject * obj0 = 0 ;
17624 char *kwnames[] = {
17625 (char *) "self", NULL
17626 };
17627
17628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17630 if (SWIG_arg_fail(1)) SWIG_fail;
17631 {
17632 PyThreadState* __tstate = wxPyBeginAllowThreads();
17633 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17634
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 {
17639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17640 }
17641 return resultobj;
17642 fail:
17643 return NULL;
17644 }
17645
17646
17647 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17648 PyObject *resultobj = NULL;
17649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17650 bool result;
17651 PyObject * obj0 = 0 ;
17652 char *kwnames[] = {
17653 (char *) "self", NULL
17654 };
17655
17656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17658 if (SWIG_arg_fail(1)) SWIG_fail;
17659 {
17660 PyThreadState* __tstate = wxPyBeginAllowThreads();
17661 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17662
17663 wxPyEndAllowThreads(__tstate);
17664 if (PyErr_Occurred()) SWIG_fail;
17665 }
17666 {
17667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj = NULL;
17677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17678 bool result;
17679 PyObject * obj0 = 0 ;
17680 char *kwnames[] = {
17681 (char *) "self", NULL
17682 };
17683
17684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17686 if (SWIG_arg_fail(1)) SWIG_fail;
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17690
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17696 }
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj = NULL;
17705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17706 bool result;
17707 PyObject * obj0 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17714 if (SWIG_arg_fail(1)) SWIG_fail;
17715 {
17716 PyThreadState* __tstate = wxPyBeginAllowThreads();
17717 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17718
17719 wxPyEndAllowThreads(__tstate);
17720 if (PyErr_Occurred()) SWIG_fail;
17721 }
17722 {
17723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17724 }
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj = NULL;
17733 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17734 bool result;
17735 PyObject * obj0 = 0 ;
17736 char *kwnames[] = {
17737 (char *) "self", NULL
17738 };
17739
17740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17742 if (SWIG_arg_fail(1)) SWIG_fail;
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17746
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17752 }
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj = NULL;
17761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17762 bool result;
17763 PyObject * obj0 = 0 ;
17764 char *kwnames[] = {
17765 (char *) "self", NULL
17766 };
17767
17768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17770 if (SWIG_arg_fail(1)) SWIG_fail;
17771 {
17772 PyThreadState* __tstate = wxPyBeginAllowThreads();
17773 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17774
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 {
17779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17780 }
17781 return resultobj;
17782 fail:
17783 return NULL;
17784 }
17785
17786
17787 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17788 PyObject *resultobj = NULL;
17789 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17790 bool result;
17791 PyObject * obj0 = 0 ;
17792 char *kwnames[] = {
17793 (char *) "self", NULL
17794 };
17795
17796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17798 if (SWIG_arg_fail(1)) SWIG_fail;
17799 {
17800 PyThreadState* __tstate = wxPyBeginAllowThreads();
17801 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17802
17803 wxPyEndAllowThreads(__tstate);
17804 if (PyErr_Occurred()) SWIG_fail;
17805 }
17806 {
17807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17808 }
17809 return resultobj;
17810 fail:
17811 return NULL;
17812 }
17813
17814
17815 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17816 PyObject *resultobj = NULL;
17817 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17818 bool result;
17819 PyObject * obj0 = 0 ;
17820 char *kwnames[] = {
17821 (char *) "self", NULL
17822 };
17823
17824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17826 if (SWIG_arg_fail(1)) SWIG_fail;
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17830
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 {
17835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17836 }
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj = NULL;
17845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17846 bool result;
17847 PyObject * obj0 = 0 ;
17848 char *kwnames[] = {
17849 (char *) "self", NULL
17850 };
17851
17852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17854 if (SWIG_arg_fail(1)) SWIG_fail;
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 {
17863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17872 PyObject *resultobj = NULL;
17873 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17874 bool result;
17875 PyObject * obj0 = 0 ;
17876 char *kwnames[] = {
17877 (char *) "self", NULL
17878 };
17879
17880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17882 if (SWIG_arg_fail(1)) SWIG_fail;
17883 {
17884 PyThreadState* __tstate = wxPyBeginAllowThreads();
17885 result = (bool)(arg1)->LeftIsDown();
17886
17887 wxPyEndAllowThreads(__tstate);
17888 if (PyErr_Occurred()) SWIG_fail;
17889 }
17890 {
17891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17892 }
17893 return resultobj;
17894 fail:
17895 return NULL;
17896 }
17897
17898
17899 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17900 PyObject *resultobj = NULL;
17901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17902 bool result;
17903 PyObject * obj0 = 0 ;
17904 char *kwnames[] = {
17905 (char *) "self", NULL
17906 };
17907
17908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17910 if (SWIG_arg_fail(1)) SWIG_fail;
17911 {
17912 PyThreadState* __tstate = wxPyBeginAllowThreads();
17913 result = (bool)(arg1)->MiddleIsDown();
17914
17915 wxPyEndAllowThreads(__tstate);
17916 if (PyErr_Occurred()) SWIG_fail;
17917 }
17918 {
17919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17920 }
17921 return resultobj;
17922 fail:
17923 return NULL;
17924 }
17925
17926
17927 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17928 PyObject *resultobj = NULL;
17929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17930 bool result;
17931 PyObject * obj0 = 0 ;
17932 char *kwnames[] = {
17933 (char *) "self", NULL
17934 };
17935
17936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17938 if (SWIG_arg_fail(1)) SWIG_fail;
17939 {
17940 PyThreadState* __tstate = wxPyBeginAllowThreads();
17941 result = (bool)(arg1)->RightIsDown();
17942
17943 wxPyEndAllowThreads(__tstate);
17944 if (PyErr_Occurred()) SWIG_fail;
17945 }
17946 {
17947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17948 }
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj = NULL;
17957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17958 bool result;
17959 PyObject * obj0 = 0 ;
17960 char *kwnames[] = {
17961 (char *) "self", NULL
17962 };
17963
17964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17966 if (SWIG_arg_fail(1)) SWIG_fail;
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17970
17971 wxPyEndAllowThreads(__tstate);
17972 if (PyErr_Occurred()) SWIG_fail;
17973 }
17974 {
17975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17976 }
17977 return resultobj;
17978 fail:
17979 return NULL;
17980 }
17981
17982
17983 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17984 PyObject *resultobj = NULL;
17985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17986 bool result;
17987 PyObject * obj0 = 0 ;
17988 char *kwnames[] = {
17989 (char *) "self", NULL
17990 };
17991
17992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17994 if (SWIG_arg_fail(1)) SWIG_fail;
17995 {
17996 PyThreadState* __tstate = wxPyBeginAllowThreads();
17997 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17998
17999 wxPyEndAllowThreads(__tstate);
18000 if (PyErr_Occurred()) SWIG_fail;
18001 }
18002 {
18003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18004 }
18005 return resultobj;
18006 fail:
18007 return NULL;
18008 }
18009
18010
18011 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
18012 PyObject *resultobj = NULL;
18013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18014 bool result;
18015 PyObject * obj0 = 0 ;
18016 char *kwnames[] = {
18017 (char *) "self", NULL
18018 };
18019
18020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
18021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18022 if (SWIG_arg_fail(1)) SWIG_fail;
18023 {
18024 PyThreadState* __tstate = wxPyBeginAllowThreads();
18025 result = (bool)((wxMouseEvent const *)arg1)->Entering();
18026
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 {
18031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18032 }
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
18040 PyObject *resultobj = NULL;
18041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18042 bool result;
18043 PyObject * obj0 = 0 ;
18044 char *kwnames[] = {
18045 (char *) "self", NULL
18046 };
18047
18048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
18049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18050 if (SWIG_arg_fail(1)) SWIG_fail;
18051 {
18052 PyThreadState* __tstate = wxPyBeginAllowThreads();
18053 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18054
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 {
18059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18060 }
18061 return resultobj;
18062 fail:
18063 return NULL;
18064 }
18065
18066
18067 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18068 PyObject *resultobj = NULL;
18069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18070 wxPoint result;
18071 PyObject * obj0 = 0 ;
18072 char *kwnames[] = {
18073 (char *) "self", NULL
18074 };
18075
18076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18078 if (SWIG_arg_fail(1)) SWIG_fail;
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 result = (arg1)->GetPosition();
18082
18083 wxPyEndAllowThreads(__tstate);
18084 if (PyErr_Occurred()) SWIG_fail;
18085 }
18086 {
18087 wxPoint * resultptr;
18088 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18090 }
18091 return resultobj;
18092 fail:
18093 return NULL;
18094 }
18095
18096
18097 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18098 PyObject *resultobj = NULL;
18099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18100 long *arg2 = (long *) 0 ;
18101 long *arg3 = (long *) 0 ;
18102 long temp2 ;
18103 int res2 = 0 ;
18104 long temp3 ;
18105 int res3 = 0 ;
18106 PyObject * obj0 = 0 ;
18107 char *kwnames[] = {
18108 (char *) "self", NULL
18109 };
18110
18111 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18112 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18115 if (SWIG_arg_fail(1)) SWIG_fail;
18116 {
18117 PyThreadState* __tstate = wxPyBeginAllowThreads();
18118 (arg1)->GetPosition(arg2,arg3);
18119
18120 wxPyEndAllowThreads(__tstate);
18121 if (PyErr_Occurred()) SWIG_fail;
18122 }
18123 Py_INCREF(Py_None); resultobj = Py_None;
18124 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18125 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18126 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18127 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18128 return resultobj;
18129 fail:
18130 return NULL;
18131 }
18132
18133
18134 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18135 PyObject *resultobj = NULL;
18136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18137 wxDC *arg2 = 0 ;
18138 wxPoint result;
18139 PyObject * obj0 = 0 ;
18140 PyObject * obj1 = 0 ;
18141 char *kwnames[] = {
18142 (char *) "self",(char *) "dc", NULL
18143 };
18144
18145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18147 if (SWIG_arg_fail(1)) SWIG_fail;
18148 {
18149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18150 if (SWIG_arg_fail(2)) SWIG_fail;
18151 if (arg2 == NULL) {
18152 SWIG_null_ref("wxDC");
18153 }
18154 if (SWIG_arg_fail(2)) SWIG_fail;
18155 }
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18159
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 {
18164 wxPoint * resultptr;
18165 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18167 }
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj = NULL;
18176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18177 int result;
18178 PyObject * obj0 = 0 ;
18179 char *kwnames[] = {
18180 (char *) "self", NULL
18181 };
18182
18183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18185 if (SWIG_arg_fail(1)) SWIG_fail;
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (int)((wxMouseEvent const *)arg1)->GetX();
18189
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 {
18194 resultobj = SWIG_From_int(static_cast<int >(result));
18195 }
18196 return resultobj;
18197 fail:
18198 return NULL;
18199 }
18200
18201
18202 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18203 PyObject *resultobj = NULL;
18204 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18205 int result;
18206 PyObject * obj0 = 0 ;
18207 char *kwnames[] = {
18208 (char *) "self", NULL
18209 };
18210
18211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18213 if (SWIG_arg_fail(1)) SWIG_fail;
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (int)((wxMouseEvent const *)arg1)->GetY();
18217
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 {
18222 resultobj = SWIG_From_int(static_cast<int >(result));
18223 }
18224 return resultobj;
18225 fail:
18226 return NULL;
18227 }
18228
18229
18230 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18231 PyObject *resultobj = NULL;
18232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18233 int result;
18234 PyObject * obj0 = 0 ;
18235 char *kwnames[] = {
18236 (char *) "self", NULL
18237 };
18238
18239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18241 if (SWIG_arg_fail(1)) SWIG_fail;
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18245
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 {
18250 resultobj = SWIG_From_int(static_cast<int >(result));
18251 }
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj = NULL;
18260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18261 int result;
18262 PyObject * obj0 = 0 ;
18263 char *kwnames[] = {
18264 (char *) "self", NULL
18265 };
18266
18267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18269 if (SWIG_arg_fail(1)) SWIG_fail;
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18273
18274 wxPyEndAllowThreads(__tstate);
18275 if (PyErr_Occurred()) SWIG_fail;
18276 }
18277 {
18278 resultobj = SWIG_From_int(static_cast<int >(result));
18279 }
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18287 PyObject *resultobj = NULL;
18288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18289 int result;
18290 PyObject * obj0 = 0 ;
18291 char *kwnames[] = {
18292 (char *) "self", NULL
18293 };
18294
18295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18297 if (SWIG_arg_fail(1)) SWIG_fail;
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18301
18302 wxPyEndAllowThreads(__tstate);
18303 if (PyErr_Occurred()) SWIG_fail;
18304 }
18305 {
18306 resultobj = SWIG_From_int(static_cast<int >(result));
18307 }
18308 return resultobj;
18309 fail:
18310 return NULL;
18311 }
18312
18313
18314 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj = NULL;
18316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18317 bool result;
18318 PyObject * obj0 = 0 ;
18319 char *kwnames[] = {
18320 (char *) "self", NULL
18321 };
18322
18323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18325 if (SWIG_arg_fail(1)) SWIG_fail;
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18329
18330 wxPyEndAllowThreads(__tstate);
18331 if (PyErr_Occurred()) SWIG_fail;
18332 }
18333 {
18334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18335 }
18336 return resultobj;
18337 fail:
18338 return NULL;
18339 }
18340
18341
18342 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18343 PyObject *resultobj = NULL;
18344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18345 int arg2 ;
18346 PyObject * obj0 = 0 ;
18347 PyObject * obj1 = 0 ;
18348 char *kwnames[] = {
18349 (char *) "self",(char *) "m_x", NULL
18350 };
18351
18352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18354 if (SWIG_arg_fail(1)) SWIG_fail;
18355 {
18356 arg2 = static_cast<int >(SWIG_As_int(obj1));
18357 if (SWIG_arg_fail(2)) SWIG_fail;
18358 }
18359 if (arg1) (arg1)->m_x = arg2;
18360
18361 Py_INCREF(Py_None); resultobj = Py_None;
18362 return resultobj;
18363 fail:
18364 return NULL;
18365 }
18366
18367
18368 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18369 PyObject *resultobj = NULL;
18370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18371 int result;
18372 PyObject * obj0 = 0 ;
18373 char *kwnames[] = {
18374 (char *) "self", NULL
18375 };
18376
18377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18379 if (SWIG_arg_fail(1)) SWIG_fail;
18380 result = (int) ((arg1)->m_x);
18381
18382 {
18383 resultobj = SWIG_From_int(static_cast<int >(result));
18384 }
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18392 PyObject *resultobj = NULL;
18393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18394 int arg2 ;
18395 PyObject * obj0 = 0 ;
18396 PyObject * obj1 = 0 ;
18397 char *kwnames[] = {
18398 (char *) "self",(char *) "m_y", NULL
18399 };
18400
18401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18403 if (SWIG_arg_fail(1)) SWIG_fail;
18404 {
18405 arg2 = static_cast<int >(SWIG_As_int(obj1));
18406 if (SWIG_arg_fail(2)) SWIG_fail;
18407 }
18408 if (arg1) (arg1)->m_y = arg2;
18409
18410 Py_INCREF(Py_None); resultobj = Py_None;
18411 return resultobj;
18412 fail:
18413 return NULL;
18414 }
18415
18416
18417 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18418 PyObject *resultobj = NULL;
18419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18420 int result;
18421 PyObject * obj0 = 0 ;
18422 char *kwnames[] = {
18423 (char *) "self", NULL
18424 };
18425
18426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18428 if (SWIG_arg_fail(1)) SWIG_fail;
18429 result = (int) ((arg1)->m_y);
18430
18431 {
18432 resultobj = SWIG_From_int(static_cast<int >(result));
18433 }
18434 return resultobj;
18435 fail:
18436 return NULL;
18437 }
18438
18439
18440 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18441 PyObject *resultobj = NULL;
18442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18443 bool arg2 ;
18444 PyObject * obj0 = 0 ;
18445 PyObject * obj1 = 0 ;
18446 char *kwnames[] = {
18447 (char *) "self",(char *) "m_leftDown", NULL
18448 };
18449
18450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18452 if (SWIG_arg_fail(1)) SWIG_fail;
18453 {
18454 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18455 if (SWIG_arg_fail(2)) SWIG_fail;
18456 }
18457 if (arg1) (arg1)->m_leftDown = arg2;
18458
18459 Py_INCREF(Py_None); resultobj = Py_None;
18460 return resultobj;
18461 fail:
18462 return NULL;
18463 }
18464
18465
18466 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18467 PyObject *resultobj = NULL;
18468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18469 bool result;
18470 PyObject * obj0 = 0 ;
18471 char *kwnames[] = {
18472 (char *) "self", NULL
18473 };
18474
18475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18477 if (SWIG_arg_fail(1)) SWIG_fail;
18478 result = (bool) ((arg1)->m_leftDown);
18479
18480 {
18481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18482 }
18483 return resultobj;
18484 fail:
18485 return NULL;
18486 }
18487
18488
18489 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18490 PyObject *resultobj = NULL;
18491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18492 bool arg2 ;
18493 PyObject * obj0 = 0 ;
18494 PyObject * obj1 = 0 ;
18495 char *kwnames[] = {
18496 (char *) "self",(char *) "m_middleDown", NULL
18497 };
18498
18499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18501 if (SWIG_arg_fail(1)) SWIG_fail;
18502 {
18503 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18504 if (SWIG_arg_fail(2)) SWIG_fail;
18505 }
18506 if (arg1) (arg1)->m_middleDown = arg2;
18507
18508 Py_INCREF(Py_None); resultobj = Py_None;
18509 return resultobj;
18510 fail:
18511 return NULL;
18512 }
18513
18514
18515 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18516 PyObject *resultobj = NULL;
18517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18518 bool result;
18519 PyObject * obj0 = 0 ;
18520 char *kwnames[] = {
18521 (char *) "self", NULL
18522 };
18523
18524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18526 if (SWIG_arg_fail(1)) SWIG_fail;
18527 result = (bool) ((arg1)->m_middleDown);
18528
18529 {
18530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18531 }
18532 return resultobj;
18533 fail:
18534 return NULL;
18535 }
18536
18537
18538 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18539 PyObject *resultobj = NULL;
18540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18541 bool arg2 ;
18542 PyObject * obj0 = 0 ;
18543 PyObject * obj1 = 0 ;
18544 char *kwnames[] = {
18545 (char *) "self",(char *) "m_rightDown", NULL
18546 };
18547
18548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18550 if (SWIG_arg_fail(1)) SWIG_fail;
18551 {
18552 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18553 if (SWIG_arg_fail(2)) SWIG_fail;
18554 }
18555 if (arg1) (arg1)->m_rightDown = arg2;
18556
18557 Py_INCREF(Py_None); resultobj = Py_None;
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18565 PyObject *resultobj = NULL;
18566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18567 bool result;
18568 PyObject * obj0 = 0 ;
18569 char *kwnames[] = {
18570 (char *) "self", NULL
18571 };
18572
18573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18575 if (SWIG_arg_fail(1)) SWIG_fail;
18576 result = (bool) ((arg1)->m_rightDown);
18577
18578 {
18579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18580 }
18581 return resultobj;
18582 fail:
18583 return NULL;
18584 }
18585
18586
18587 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18588 PyObject *resultobj = NULL;
18589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18590 bool arg2 ;
18591 PyObject * obj0 = 0 ;
18592 PyObject * obj1 = 0 ;
18593 char *kwnames[] = {
18594 (char *) "self",(char *) "m_controlDown", NULL
18595 };
18596
18597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18599 if (SWIG_arg_fail(1)) SWIG_fail;
18600 {
18601 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18602 if (SWIG_arg_fail(2)) SWIG_fail;
18603 }
18604 if (arg1) (arg1)->m_controlDown = arg2;
18605
18606 Py_INCREF(Py_None); resultobj = Py_None;
18607 return resultobj;
18608 fail:
18609 return NULL;
18610 }
18611
18612
18613 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18614 PyObject *resultobj = NULL;
18615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18616 bool result;
18617 PyObject * obj0 = 0 ;
18618 char *kwnames[] = {
18619 (char *) "self", NULL
18620 };
18621
18622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18624 if (SWIG_arg_fail(1)) SWIG_fail;
18625 result = (bool) ((arg1)->m_controlDown);
18626
18627 {
18628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18629 }
18630 return resultobj;
18631 fail:
18632 return NULL;
18633 }
18634
18635
18636 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj = NULL;
18638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18639 bool arg2 ;
18640 PyObject * obj0 = 0 ;
18641 PyObject * obj1 = 0 ;
18642 char *kwnames[] = {
18643 (char *) "self",(char *) "m_shiftDown", NULL
18644 };
18645
18646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18648 if (SWIG_arg_fail(1)) SWIG_fail;
18649 {
18650 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18651 if (SWIG_arg_fail(2)) SWIG_fail;
18652 }
18653 if (arg1) (arg1)->m_shiftDown = arg2;
18654
18655 Py_INCREF(Py_None); resultobj = Py_None;
18656 return resultobj;
18657 fail:
18658 return NULL;
18659 }
18660
18661
18662 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18663 PyObject *resultobj = NULL;
18664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18665 bool result;
18666 PyObject * obj0 = 0 ;
18667 char *kwnames[] = {
18668 (char *) "self", NULL
18669 };
18670
18671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18673 if (SWIG_arg_fail(1)) SWIG_fail;
18674 result = (bool) ((arg1)->m_shiftDown);
18675
18676 {
18677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18678 }
18679 return resultobj;
18680 fail:
18681 return NULL;
18682 }
18683
18684
18685 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18686 PyObject *resultobj = NULL;
18687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18688 bool arg2 ;
18689 PyObject * obj0 = 0 ;
18690 PyObject * obj1 = 0 ;
18691 char *kwnames[] = {
18692 (char *) "self",(char *) "m_altDown", NULL
18693 };
18694
18695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18697 if (SWIG_arg_fail(1)) SWIG_fail;
18698 {
18699 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18700 if (SWIG_arg_fail(2)) SWIG_fail;
18701 }
18702 if (arg1) (arg1)->m_altDown = arg2;
18703
18704 Py_INCREF(Py_None); resultobj = Py_None;
18705 return resultobj;
18706 fail:
18707 return NULL;
18708 }
18709
18710
18711 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18712 PyObject *resultobj = NULL;
18713 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18714 bool result;
18715 PyObject * obj0 = 0 ;
18716 char *kwnames[] = {
18717 (char *) "self", NULL
18718 };
18719
18720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18722 if (SWIG_arg_fail(1)) SWIG_fail;
18723 result = (bool) ((arg1)->m_altDown);
18724
18725 {
18726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18727 }
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18735 PyObject *resultobj = NULL;
18736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18737 bool arg2 ;
18738 PyObject * obj0 = 0 ;
18739 PyObject * obj1 = 0 ;
18740 char *kwnames[] = {
18741 (char *) "self",(char *) "m_metaDown", NULL
18742 };
18743
18744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18746 if (SWIG_arg_fail(1)) SWIG_fail;
18747 {
18748 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18749 if (SWIG_arg_fail(2)) SWIG_fail;
18750 }
18751 if (arg1) (arg1)->m_metaDown = arg2;
18752
18753 Py_INCREF(Py_None); resultobj = Py_None;
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18761 PyObject *resultobj = NULL;
18762 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18763 bool result;
18764 PyObject * obj0 = 0 ;
18765 char *kwnames[] = {
18766 (char *) "self", NULL
18767 };
18768
18769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18771 if (SWIG_arg_fail(1)) SWIG_fail;
18772 result = (bool) ((arg1)->m_metaDown);
18773
18774 {
18775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18776 }
18777 return resultobj;
18778 fail:
18779 return NULL;
18780 }
18781
18782
18783 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18784 PyObject *resultobj = NULL;
18785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18786 int arg2 ;
18787 PyObject * obj0 = 0 ;
18788 PyObject * obj1 = 0 ;
18789 char *kwnames[] = {
18790 (char *) "self",(char *) "m_wheelRotation", NULL
18791 };
18792
18793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18795 if (SWIG_arg_fail(1)) SWIG_fail;
18796 {
18797 arg2 = static_cast<int >(SWIG_As_int(obj1));
18798 if (SWIG_arg_fail(2)) SWIG_fail;
18799 }
18800 if (arg1) (arg1)->m_wheelRotation = arg2;
18801
18802 Py_INCREF(Py_None); resultobj = Py_None;
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18810 PyObject *resultobj = NULL;
18811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18812 int result;
18813 PyObject * obj0 = 0 ;
18814 char *kwnames[] = {
18815 (char *) "self", NULL
18816 };
18817
18818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18820 if (SWIG_arg_fail(1)) SWIG_fail;
18821 result = (int) ((arg1)->m_wheelRotation);
18822
18823 {
18824 resultobj = SWIG_From_int(static_cast<int >(result));
18825 }
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18833 PyObject *resultobj = NULL;
18834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18835 int arg2 ;
18836 PyObject * obj0 = 0 ;
18837 PyObject * obj1 = 0 ;
18838 char *kwnames[] = {
18839 (char *) "self",(char *) "m_wheelDelta", NULL
18840 };
18841
18842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18844 if (SWIG_arg_fail(1)) SWIG_fail;
18845 {
18846 arg2 = static_cast<int >(SWIG_As_int(obj1));
18847 if (SWIG_arg_fail(2)) SWIG_fail;
18848 }
18849 if (arg1) (arg1)->m_wheelDelta = arg2;
18850
18851 Py_INCREF(Py_None); resultobj = Py_None;
18852 return resultobj;
18853 fail:
18854 return NULL;
18855 }
18856
18857
18858 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18859 PyObject *resultobj = NULL;
18860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18861 int result;
18862 PyObject * obj0 = 0 ;
18863 char *kwnames[] = {
18864 (char *) "self", NULL
18865 };
18866
18867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18869 if (SWIG_arg_fail(1)) SWIG_fail;
18870 result = (int) ((arg1)->m_wheelDelta);
18871
18872 {
18873 resultobj = SWIG_From_int(static_cast<int >(result));
18874 }
18875 return resultobj;
18876 fail:
18877 return NULL;
18878 }
18879
18880
18881 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18882 PyObject *resultobj = NULL;
18883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18884 int arg2 ;
18885 PyObject * obj0 = 0 ;
18886 PyObject * obj1 = 0 ;
18887 char *kwnames[] = {
18888 (char *) "self",(char *) "m_linesPerAction", NULL
18889 };
18890
18891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18893 if (SWIG_arg_fail(1)) SWIG_fail;
18894 {
18895 arg2 = static_cast<int >(SWIG_As_int(obj1));
18896 if (SWIG_arg_fail(2)) SWIG_fail;
18897 }
18898 if (arg1) (arg1)->m_linesPerAction = arg2;
18899
18900 Py_INCREF(Py_None); resultobj = Py_None;
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18908 PyObject *resultobj = NULL;
18909 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18910 int result;
18911 PyObject * obj0 = 0 ;
18912 char *kwnames[] = {
18913 (char *) "self", NULL
18914 };
18915
18916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18918 if (SWIG_arg_fail(1)) SWIG_fail;
18919 result = (int) ((arg1)->m_linesPerAction);
18920
18921 {
18922 resultobj = SWIG_From_int(static_cast<int >(result));
18923 }
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18931 PyObject *obj;
18932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18933 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18934 Py_INCREF(obj);
18935 return Py_BuildValue((char *)"");
18936 }
18937 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18938 PyObject *resultobj = NULL;
18939 int arg1 = (int) 0 ;
18940 int arg2 = (int) 0 ;
18941 wxSetCursorEvent *result;
18942 PyObject * obj0 = 0 ;
18943 PyObject * obj1 = 0 ;
18944 char *kwnames[] = {
18945 (char *) "x",(char *) "y", NULL
18946 };
18947
18948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18949 if (obj0) {
18950 {
18951 arg1 = static_cast<int >(SWIG_As_int(obj0));
18952 if (SWIG_arg_fail(1)) SWIG_fail;
18953 }
18954 }
18955 if (obj1) {
18956 {
18957 arg2 = static_cast<int >(SWIG_As_int(obj1));
18958 if (SWIG_arg_fail(2)) SWIG_fail;
18959 }
18960 }
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18964
18965 wxPyEndAllowThreads(__tstate);
18966 if (PyErr_Occurred()) SWIG_fail;
18967 }
18968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj = NULL;
18977 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18978 int result;
18979 PyObject * obj0 = 0 ;
18980 char *kwnames[] = {
18981 (char *) "self", NULL
18982 };
18983
18984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18986 if (SWIG_arg_fail(1)) SWIG_fail;
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18990
18991 wxPyEndAllowThreads(__tstate);
18992 if (PyErr_Occurred()) SWIG_fail;
18993 }
18994 {
18995 resultobj = SWIG_From_int(static_cast<int >(result));
18996 }
18997 return resultobj;
18998 fail:
18999 return NULL;
19000 }
19001
19002
19003 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj = NULL;
19005 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19006 int result;
19007 PyObject * obj0 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "self", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
19013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19014 if (SWIG_arg_fail(1)) SWIG_fail;
19015 {
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
19018
19019 wxPyEndAllowThreads(__tstate);
19020 if (PyErr_Occurred()) SWIG_fail;
19021 }
19022 {
19023 resultobj = SWIG_From_int(static_cast<int >(result));
19024 }
19025 return resultobj;
19026 fail:
19027 return NULL;
19028 }
19029
19030
19031 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj = NULL;
19033 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19034 wxCursor *arg2 = 0 ;
19035 PyObject * obj0 = 0 ;
19036 PyObject * obj1 = 0 ;
19037 char *kwnames[] = {
19038 (char *) "self",(char *) "cursor", NULL
19039 };
19040
19041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
19042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19043 if (SWIG_arg_fail(1)) SWIG_fail;
19044 {
19045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
19046 if (SWIG_arg_fail(2)) SWIG_fail;
19047 if (arg2 == NULL) {
19048 SWIG_null_ref("wxCursor");
19049 }
19050 if (SWIG_arg_fail(2)) SWIG_fail;
19051 }
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 (arg1)->SetCursor((wxCursor const &)*arg2);
19055
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 Py_INCREF(Py_None); resultobj = Py_None;
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19067 PyObject *resultobj = NULL;
19068 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19069 wxCursor *result;
19070 PyObject * obj0 = 0 ;
19071 char *kwnames[] = {
19072 (char *) "self", NULL
19073 };
19074
19075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19077 if (SWIG_arg_fail(1)) SWIG_fail;
19078 {
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 {
19081 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19082 result = (wxCursor *) &_result_ref;
19083 }
19084
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 wxCursor* resultptr = new wxCursor(*result);
19090 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19091 }
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = NULL;
19100 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19101 bool result;
19102 PyObject * obj0 = 0 ;
19103 char *kwnames[] = {
19104 (char *) "self", NULL
19105 };
19106
19107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19109 if (SWIG_arg_fail(1)) SWIG_fail;
19110 {
19111 PyThreadState* __tstate = wxPyBeginAllowThreads();
19112 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19113
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 {
19118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19119 }
19120 return resultobj;
19121 fail:
19122 return NULL;
19123 }
19124
19125
19126 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19127 PyObject *obj;
19128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19129 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19130 Py_INCREF(obj);
19131 return Py_BuildValue((char *)"");
19132 }
19133 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19134 PyObject *resultobj = NULL;
19135 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19136 wxKeyEvent *result;
19137 PyObject * obj0 = 0 ;
19138 char *kwnames[] = {
19139 (char *) "eventType", NULL
19140 };
19141
19142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19143 if (obj0) {
19144 {
19145 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19146 if (SWIG_arg_fail(1)) SWIG_fail;
19147 }
19148 }
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19152
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19157 return resultobj;
19158 fail:
19159 return NULL;
19160 }
19161
19162
19163 static PyObject *_wrap_KeyEvent_GetModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19164 PyObject *resultobj = NULL;
19165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19166 int result;
19167 PyObject * obj0 = 0 ;
19168 char *kwnames[] = {
19169 (char *) "self", NULL
19170 };
19171
19172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetModifiers",kwnames,&obj0)) goto fail;
19173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19174 if (SWIG_arg_fail(1)) SWIG_fail;
19175 {
19176 PyThreadState* __tstate = wxPyBeginAllowThreads();
19177 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
19178
19179 wxPyEndAllowThreads(__tstate);
19180 if (PyErr_Occurred()) SWIG_fail;
19181 }
19182 {
19183 resultobj = SWIG_From_int(static_cast<int >(result));
19184 }
19185 return resultobj;
19186 fail:
19187 return NULL;
19188 }
19189
19190
19191 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19192 PyObject *resultobj = NULL;
19193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19194 bool result;
19195 PyObject * obj0 = 0 ;
19196 char *kwnames[] = {
19197 (char *) "self", NULL
19198 };
19199
19200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19202 if (SWIG_arg_fail(1)) SWIG_fail;
19203 {
19204 PyThreadState* __tstate = wxPyBeginAllowThreads();
19205 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19206
19207 wxPyEndAllowThreads(__tstate);
19208 if (PyErr_Occurred()) SWIG_fail;
19209 }
19210 {
19211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19212 }
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19220 PyObject *resultobj = NULL;
19221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19222 bool result;
19223 PyObject * obj0 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "self", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19234
19235 wxPyEndAllowThreads(__tstate);
19236 if (PyErr_Occurred()) SWIG_fail;
19237 }
19238 {
19239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19240 }
19241 return resultobj;
19242 fail:
19243 return NULL;
19244 }
19245
19246
19247 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19248 PyObject *resultobj = NULL;
19249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19250 bool result;
19251 PyObject * obj0 = 0 ;
19252 char *kwnames[] = {
19253 (char *) "self", NULL
19254 };
19255
19256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19258 if (SWIG_arg_fail(1)) SWIG_fail;
19259 {
19260 PyThreadState* __tstate = wxPyBeginAllowThreads();
19261 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19262
19263 wxPyEndAllowThreads(__tstate);
19264 if (PyErr_Occurred()) SWIG_fail;
19265 }
19266 {
19267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19268 }
19269 return resultobj;
19270 fail:
19271 return NULL;
19272 }
19273
19274
19275 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19276 PyObject *resultobj = NULL;
19277 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19278 bool result;
19279 PyObject * obj0 = 0 ;
19280 char *kwnames[] = {
19281 (char *) "self", NULL
19282 };
19283
19284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19286 if (SWIG_arg_fail(1)) SWIG_fail;
19287 {
19288 PyThreadState* __tstate = wxPyBeginAllowThreads();
19289 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19290
19291 wxPyEndAllowThreads(__tstate);
19292 if (PyErr_Occurred()) SWIG_fail;
19293 }
19294 {
19295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19296 }
19297 return resultobj;
19298 fail:
19299 return NULL;
19300 }
19301
19302
19303 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19304 PyObject *resultobj = NULL;
19305 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19306 bool result;
19307 PyObject * obj0 = 0 ;
19308 char *kwnames[] = {
19309 (char *) "self", NULL
19310 };
19311
19312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19314 if (SWIG_arg_fail(1)) SWIG_fail;
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19318
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 {
19323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19324 }
19325 return resultobj;
19326 fail:
19327 return NULL;
19328 }
19329
19330
19331 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19332 PyObject *resultobj = NULL;
19333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19334 bool result;
19335 PyObject * obj0 = 0 ;
19336 char *kwnames[] = {
19337 (char *) "self", NULL
19338 };
19339
19340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19342 if (SWIG_arg_fail(1)) SWIG_fail;
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19346
19347 wxPyEndAllowThreads(__tstate);
19348 if (PyErr_Occurred()) SWIG_fail;
19349 }
19350 {
19351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19352 }
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj = NULL;
19361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19362 int result;
19363 PyObject * obj0 = 0 ;
19364 char *kwnames[] = {
19365 (char *) "self", NULL
19366 };
19367
19368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19370 if (SWIG_arg_fail(1)) SWIG_fail;
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19374
19375 wxPyEndAllowThreads(__tstate);
19376 if (PyErr_Occurred()) SWIG_fail;
19377 }
19378 {
19379 resultobj = SWIG_From_int(static_cast<int >(result));
19380 }
19381 return resultobj;
19382 fail:
19383 return NULL;
19384 }
19385
19386
19387 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19388 PyObject *resultobj = NULL;
19389 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19390 int result;
19391 PyObject * obj0 = 0 ;
19392 char *kwnames[] = {
19393 (char *) "self", NULL
19394 };
19395
19396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19398 if (SWIG_arg_fail(1)) SWIG_fail;
19399 {
19400 PyThreadState* __tstate = wxPyBeginAllowThreads();
19401 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19402
19403 wxPyEndAllowThreads(__tstate);
19404 if (PyErr_Occurred()) SWIG_fail;
19405 }
19406 {
19407 resultobj = SWIG_From_int(static_cast<int >(result));
19408 }
19409 return resultobj;
19410 fail:
19411 return NULL;
19412 }
19413
19414
19415 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj = NULL;
19417 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19418 unsigned int result;
19419 PyObject * obj0 = 0 ;
19420 char *kwnames[] = {
19421 (char *) "self", NULL
19422 };
19423
19424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19426 if (SWIG_arg_fail(1)) SWIG_fail;
19427 {
19428 PyThreadState* __tstate = wxPyBeginAllowThreads();
19429 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19430
19431 wxPyEndAllowThreads(__tstate);
19432 if (PyErr_Occurred()) SWIG_fail;
19433 }
19434 {
19435 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19436 }
19437 return resultobj;
19438 fail:
19439 return NULL;
19440 }
19441
19442
19443 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19444 PyObject *resultobj = NULL;
19445 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19446 unsigned int result;
19447 PyObject * obj0 = 0 ;
19448 char *kwnames[] = {
19449 (char *) "self", NULL
19450 };
19451
19452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19454 if (SWIG_arg_fail(1)) SWIG_fail;
19455 {
19456 PyThreadState* __tstate = wxPyBeginAllowThreads();
19457 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19458
19459 wxPyEndAllowThreads(__tstate);
19460 if (PyErr_Occurred()) SWIG_fail;
19461 }
19462 {
19463 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19464 }
19465 return resultobj;
19466 fail:
19467 return NULL;
19468 }
19469
19470
19471 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19472 PyObject *resultobj = NULL;
19473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19474 wxPoint result;
19475 PyObject * obj0 = 0 ;
19476 char *kwnames[] = {
19477 (char *) "self", NULL
19478 };
19479
19480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19482 if (SWIG_arg_fail(1)) SWIG_fail;
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 result = (arg1)->GetPosition();
19486
19487 wxPyEndAllowThreads(__tstate);
19488 if (PyErr_Occurred()) SWIG_fail;
19489 }
19490 {
19491 wxPoint * resultptr;
19492 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19494 }
19495 return resultobj;
19496 fail:
19497 return NULL;
19498 }
19499
19500
19501 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19502 PyObject *resultobj = NULL;
19503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19504 long *arg2 = (long *) 0 ;
19505 long *arg3 = (long *) 0 ;
19506 long temp2 ;
19507 int res2 = 0 ;
19508 long temp3 ;
19509 int res3 = 0 ;
19510 PyObject * obj0 = 0 ;
19511 char *kwnames[] = {
19512 (char *) "self", NULL
19513 };
19514
19515 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19516 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19519 if (SWIG_arg_fail(1)) SWIG_fail;
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 (arg1)->GetPosition(arg2,arg3);
19523
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 Py_INCREF(Py_None); resultobj = Py_None;
19528 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19529 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19530 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19531 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19532 return resultobj;
19533 fail:
19534 return NULL;
19535 }
19536
19537
19538 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19539 PyObject *resultobj = NULL;
19540 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19541 int result;
19542 PyObject * obj0 = 0 ;
19543 char *kwnames[] = {
19544 (char *) "self", NULL
19545 };
19546
19547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19549 if (SWIG_arg_fail(1)) SWIG_fail;
19550 {
19551 PyThreadState* __tstate = wxPyBeginAllowThreads();
19552 result = (int)((wxKeyEvent const *)arg1)->GetX();
19553
19554 wxPyEndAllowThreads(__tstate);
19555 if (PyErr_Occurred()) SWIG_fail;
19556 }
19557 {
19558 resultobj = SWIG_From_int(static_cast<int >(result));
19559 }
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj = NULL;
19568 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19569 int result;
19570 PyObject * obj0 = 0 ;
19571 char *kwnames[] = {
19572 (char *) "self", NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 {
19579 PyThreadState* __tstate = wxPyBeginAllowThreads();
19580 result = (int)((wxKeyEvent const *)arg1)->GetY();
19581
19582 wxPyEndAllowThreads(__tstate);
19583 if (PyErr_Occurred()) SWIG_fail;
19584 }
19585 {
19586 resultobj = SWIG_From_int(static_cast<int >(result));
19587 }
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19595 PyObject *resultobj = NULL;
19596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19597 int arg2 ;
19598 PyObject * obj0 = 0 ;
19599 PyObject * obj1 = 0 ;
19600 char *kwnames[] = {
19601 (char *) "self",(char *) "m_x", NULL
19602 };
19603
19604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19606 if (SWIG_arg_fail(1)) SWIG_fail;
19607 {
19608 arg2 = static_cast<int >(SWIG_As_int(obj1));
19609 if (SWIG_arg_fail(2)) SWIG_fail;
19610 }
19611 if (arg1) (arg1)->m_x = arg2;
19612
19613 Py_INCREF(Py_None); resultobj = Py_None;
19614 return resultobj;
19615 fail:
19616 return NULL;
19617 }
19618
19619
19620 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19621 PyObject *resultobj = NULL;
19622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19623 int result;
19624 PyObject * obj0 = 0 ;
19625 char *kwnames[] = {
19626 (char *) "self", NULL
19627 };
19628
19629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19631 if (SWIG_arg_fail(1)) SWIG_fail;
19632 result = (int) ((arg1)->m_x);
19633
19634 {
19635 resultobj = SWIG_From_int(static_cast<int >(result));
19636 }
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19644 PyObject *resultobj = NULL;
19645 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19646 int arg2 ;
19647 PyObject * obj0 = 0 ;
19648 PyObject * obj1 = 0 ;
19649 char *kwnames[] = {
19650 (char *) "self",(char *) "m_y", NULL
19651 };
19652
19653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19655 if (SWIG_arg_fail(1)) SWIG_fail;
19656 {
19657 arg2 = static_cast<int >(SWIG_As_int(obj1));
19658 if (SWIG_arg_fail(2)) SWIG_fail;
19659 }
19660 if (arg1) (arg1)->m_y = arg2;
19661
19662 Py_INCREF(Py_None); resultobj = Py_None;
19663 return resultobj;
19664 fail:
19665 return NULL;
19666 }
19667
19668
19669 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj = NULL;
19671 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19672 int result;
19673 PyObject * obj0 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "self", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19680 if (SWIG_arg_fail(1)) SWIG_fail;
19681 result = (int) ((arg1)->m_y);
19682
19683 {
19684 resultobj = SWIG_From_int(static_cast<int >(result));
19685 }
19686 return resultobj;
19687 fail:
19688 return NULL;
19689 }
19690
19691
19692 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19693 PyObject *resultobj = NULL;
19694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19695 long arg2 ;
19696 PyObject * obj0 = 0 ;
19697 PyObject * obj1 = 0 ;
19698 char *kwnames[] = {
19699 (char *) "self",(char *) "m_keyCode", NULL
19700 };
19701
19702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19704 if (SWIG_arg_fail(1)) SWIG_fail;
19705 {
19706 arg2 = static_cast<long >(SWIG_As_long(obj1));
19707 if (SWIG_arg_fail(2)) SWIG_fail;
19708 }
19709 if (arg1) (arg1)->m_keyCode = arg2;
19710
19711 Py_INCREF(Py_None); resultobj = Py_None;
19712 return resultobj;
19713 fail:
19714 return NULL;
19715 }
19716
19717
19718 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19719 PyObject *resultobj = NULL;
19720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19721 long result;
19722 PyObject * obj0 = 0 ;
19723 char *kwnames[] = {
19724 (char *) "self", NULL
19725 };
19726
19727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19729 if (SWIG_arg_fail(1)) SWIG_fail;
19730 result = (long) ((arg1)->m_keyCode);
19731
19732 {
19733 resultobj = SWIG_From_long(static_cast<long >(result));
19734 }
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj = NULL;
19743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19744 bool arg2 ;
19745 PyObject * obj0 = 0 ;
19746 PyObject * obj1 = 0 ;
19747 char *kwnames[] = {
19748 (char *) "self",(char *) "m_controlDown", NULL
19749 };
19750
19751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19753 if (SWIG_arg_fail(1)) SWIG_fail;
19754 {
19755 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19756 if (SWIG_arg_fail(2)) SWIG_fail;
19757 }
19758 if (arg1) (arg1)->m_controlDown = arg2;
19759
19760 Py_INCREF(Py_None); resultobj = Py_None;
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19768 PyObject *resultobj = NULL;
19769 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19770 bool result;
19771 PyObject * obj0 = 0 ;
19772 char *kwnames[] = {
19773 (char *) "self", NULL
19774 };
19775
19776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19778 if (SWIG_arg_fail(1)) SWIG_fail;
19779 result = (bool) ((arg1)->m_controlDown);
19780
19781 {
19782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19783 }
19784 return resultobj;
19785 fail:
19786 return NULL;
19787 }
19788
19789
19790 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19791 PyObject *resultobj = NULL;
19792 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19793 bool arg2 ;
19794 PyObject * obj0 = 0 ;
19795 PyObject * obj1 = 0 ;
19796 char *kwnames[] = {
19797 (char *) "self",(char *) "m_shiftDown", NULL
19798 };
19799
19800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19802 if (SWIG_arg_fail(1)) SWIG_fail;
19803 {
19804 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19805 if (SWIG_arg_fail(2)) SWIG_fail;
19806 }
19807 if (arg1) (arg1)->m_shiftDown = arg2;
19808
19809 Py_INCREF(Py_None); resultobj = Py_None;
19810 return resultobj;
19811 fail:
19812 return NULL;
19813 }
19814
19815
19816 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj = NULL;
19818 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19819 bool result;
19820 PyObject * obj0 = 0 ;
19821 char *kwnames[] = {
19822 (char *) "self", NULL
19823 };
19824
19825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19827 if (SWIG_arg_fail(1)) SWIG_fail;
19828 result = (bool) ((arg1)->m_shiftDown);
19829
19830 {
19831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19832 }
19833 return resultobj;
19834 fail:
19835 return NULL;
19836 }
19837
19838
19839 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19840 PyObject *resultobj = NULL;
19841 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19842 bool arg2 ;
19843 PyObject * obj0 = 0 ;
19844 PyObject * obj1 = 0 ;
19845 char *kwnames[] = {
19846 (char *) "self",(char *) "m_altDown", NULL
19847 };
19848
19849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19851 if (SWIG_arg_fail(1)) SWIG_fail;
19852 {
19853 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19854 if (SWIG_arg_fail(2)) SWIG_fail;
19855 }
19856 if (arg1) (arg1)->m_altDown = arg2;
19857
19858 Py_INCREF(Py_None); resultobj = Py_None;
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj = NULL;
19867 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19868 bool result;
19869 PyObject * obj0 = 0 ;
19870 char *kwnames[] = {
19871 (char *) "self", NULL
19872 };
19873
19874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19876 if (SWIG_arg_fail(1)) SWIG_fail;
19877 result = (bool) ((arg1)->m_altDown);
19878
19879 {
19880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19881 }
19882 return resultobj;
19883 fail:
19884 return NULL;
19885 }
19886
19887
19888 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19889 PyObject *resultobj = NULL;
19890 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19891 bool arg2 ;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 char *kwnames[] = {
19895 (char *) "self",(char *) "m_metaDown", NULL
19896 };
19897
19898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19900 if (SWIG_arg_fail(1)) SWIG_fail;
19901 {
19902 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19903 if (SWIG_arg_fail(2)) SWIG_fail;
19904 }
19905 if (arg1) (arg1)->m_metaDown = arg2;
19906
19907 Py_INCREF(Py_None); resultobj = Py_None;
19908 return resultobj;
19909 fail:
19910 return NULL;
19911 }
19912
19913
19914 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19915 PyObject *resultobj = NULL;
19916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19917 bool result;
19918 PyObject * obj0 = 0 ;
19919 char *kwnames[] = {
19920 (char *) "self", NULL
19921 };
19922
19923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19925 if (SWIG_arg_fail(1)) SWIG_fail;
19926 result = (bool) ((arg1)->m_metaDown);
19927
19928 {
19929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19930 }
19931 return resultobj;
19932 fail:
19933 return NULL;
19934 }
19935
19936
19937 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19938 PyObject *resultobj = NULL;
19939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19940 bool arg2 ;
19941 PyObject * obj0 = 0 ;
19942 PyObject * obj1 = 0 ;
19943 char *kwnames[] = {
19944 (char *) "self",(char *) "m_scanCode", NULL
19945 };
19946
19947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19949 if (SWIG_arg_fail(1)) SWIG_fail;
19950 {
19951 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19952 if (SWIG_arg_fail(2)) SWIG_fail;
19953 }
19954 if (arg1) (arg1)->m_scanCode = arg2;
19955
19956 Py_INCREF(Py_None); resultobj = Py_None;
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj = NULL;
19965 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19966 bool result;
19967 PyObject * obj0 = 0 ;
19968 char *kwnames[] = {
19969 (char *) "self", NULL
19970 };
19971
19972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19974 if (SWIG_arg_fail(1)) SWIG_fail;
19975 result = (bool) ((arg1)->m_scanCode);
19976
19977 {
19978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19979 }
19980 return resultobj;
19981 fail:
19982 return NULL;
19983 }
19984
19985
19986 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19987 PyObject *resultobj = NULL;
19988 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19989 unsigned int arg2 ;
19990 PyObject * obj0 = 0 ;
19991 PyObject * obj1 = 0 ;
19992 char *kwnames[] = {
19993 (char *) "self",(char *) "m_rawCode", NULL
19994 };
19995
19996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19998 if (SWIG_arg_fail(1)) SWIG_fail;
19999 {
20000 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
20001 if (SWIG_arg_fail(2)) SWIG_fail;
20002 }
20003 if (arg1) (arg1)->m_rawCode = arg2;
20004
20005 Py_INCREF(Py_None); resultobj = Py_None;
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
20013 PyObject *resultobj = NULL;
20014 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20015 unsigned int result;
20016 PyObject * obj0 = 0 ;
20017 char *kwnames[] = {
20018 (char *) "self", NULL
20019 };
20020
20021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
20022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20023 if (SWIG_arg_fail(1)) SWIG_fail;
20024 result = (unsigned int) ((arg1)->m_rawCode);
20025
20026 {
20027 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20028 }
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
20036 PyObject *resultobj = NULL;
20037 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20038 unsigned int arg2 ;
20039 PyObject * obj0 = 0 ;
20040 PyObject * obj1 = 0 ;
20041 char *kwnames[] = {
20042 (char *) "self",(char *) "m_rawFlags", NULL
20043 };
20044
20045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
20046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20047 if (SWIG_arg_fail(1)) SWIG_fail;
20048 {
20049 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
20050 if (SWIG_arg_fail(2)) SWIG_fail;
20051 }
20052 if (arg1) (arg1)->m_rawFlags = arg2;
20053
20054 Py_INCREF(Py_None); resultobj = Py_None;
20055 return resultobj;
20056 fail:
20057 return NULL;
20058 }
20059
20060
20061 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
20062 PyObject *resultobj = NULL;
20063 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20064 unsigned int result;
20065 PyObject * obj0 = 0 ;
20066 char *kwnames[] = {
20067 (char *) "self", NULL
20068 };
20069
20070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
20071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20072 if (SWIG_arg_fail(1)) SWIG_fail;
20073 result = (unsigned int) ((arg1)->m_rawFlags);
20074
20075 {
20076 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20077 }
20078 return resultobj;
20079 fail:
20080 return NULL;
20081 }
20082
20083
20084 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20085 PyObject *obj;
20086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20087 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20088 Py_INCREF(obj);
20089 return Py_BuildValue((char *)"");
20090 }
20091 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20092 PyObject *resultobj = NULL;
20093 wxSize const &arg1_defvalue = wxDefaultSize ;
20094 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20095 int arg2 = (int) 0 ;
20096 wxSizeEvent *result;
20097 wxSize temp1 ;
20098 PyObject * obj0 = 0 ;
20099 PyObject * obj1 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "sz",(char *) "winid", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20105 if (obj0) {
20106 {
20107 arg1 = &temp1;
20108 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20109 }
20110 }
20111 if (obj1) {
20112 {
20113 arg2 = static_cast<int >(SWIG_As_int(obj1));
20114 if (SWIG_arg_fail(2)) SWIG_fail;
20115 }
20116 }
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20120
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20132 PyObject *resultobj = NULL;
20133 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20134 wxSize result;
20135 PyObject * obj0 = 0 ;
20136 char *kwnames[] = {
20137 (char *) "self", NULL
20138 };
20139
20140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20142 if (SWIG_arg_fail(1)) SWIG_fail;
20143 {
20144 PyThreadState* __tstate = wxPyBeginAllowThreads();
20145 result = ((wxSizeEvent const *)arg1)->GetSize();
20146
20147 wxPyEndAllowThreads(__tstate);
20148 if (PyErr_Occurred()) SWIG_fail;
20149 }
20150 {
20151 wxSize * resultptr;
20152 resultptr = new wxSize(static_cast<wxSize & >(result));
20153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20154 }
20155 return resultobj;
20156 fail:
20157 return NULL;
20158 }
20159
20160
20161 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20162 PyObject *resultobj = NULL;
20163 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20164 wxRect result;
20165 PyObject * obj0 = 0 ;
20166 char *kwnames[] = {
20167 (char *) "self", NULL
20168 };
20169
20170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20172 if (SWIG_arg_fail(1)) SWIG_fail;
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 result = ((wxSizeEvent const *)arg1)->GetRect();
20176
20177 wxPyEndAllowThreads(__tstate);
20178 if (PyErr_Occurred()) SWIG_fail;
20179 }
20180 {
20181 wxRect * resultptr;
20182 resultptr = new wxRect(static_cast<wxRect & >(result));
20183 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20184 }
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj = NULL;
20193 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20194 wxRect arg2 ;
20195 PyObject * obj0 = 0 ;
20196 PyObject * obj1 = 0 ;
20197 char *kwnames[] = {
20198 (char *) "self",(char *) "rect", NULL
20199 };
20200
20201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20203 if (SWIG_arg_fail(1)) SWIG_fail;
20204 {
20205 wxRect * argp;
20206 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20207 if (SWIG_arg_fail(2)) SWIG_fail;
20208 if (argp == NULL) {
20209 SWIG_null_ref("wxRect");
20210 }
20211 if (SWIG_arg_fail(2)) SWIG_fail;
20212 arg2 = *argp;
20213 }
20214 {
20215 PyThreadState* __tstate = wxPyBeginAllowThreads();
20216 (arg1)->SetRect(arg2);
20217
20218 wxPyEndAllowThreads(__tstate);
20219 if (PyErr_Occurred()) SWIG_fail;
20220 }
20221 Py_INCREF(Py_None); resultobj = Py_None;
20222 return resultobj;
20223 fail:
20224 return NULL;
20225 }
20226
20227
20228 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20229 PyObject *resultobj = NULL;
20230 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20231 wxSize arg2 ;
20232 PyObject * obj0 = 0 ;
20233 PyObject * obj1 = 0 ;
20234 char *kwnames[] = {
20235 (char *) "self",(char *) "size", NULL
20236 };
20237
20238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20240 if (SWIG_arg_fail(1)) SWIG_fail;
20241 {
20242 wxSize * argp;
20243 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20244 if (SWIG_arg_fail(2)) SWIG_fail;
20245 if (argp == NULL) {
20246 SWIG_null_ref("wxSize");
20247 }
20248 if (SWIG_arg_fail(2)) SWIG_fail;
20249 arg2 = *argp;
20250 }
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 wxSizeEvent_SetSize(arg1,arg2);
20254
20255 wxPyEndAllowThreads(__tstate);
20256 if (PyErr_Occurred()) SWIG_fail;
20257 }
20258 Py_INCREF(Py_None); resultobj = Py_None;
20259 return resultobj;
20260 fail:
20261 return NULL;
20262 }
20263
20264
20265 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20266 PyObject *resultobj = NULL;
20267 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20268 wxSize *arg2 = (wxSize *) 0 ;
20269 PyObject * obj0 = 0 ;
20270 PyObject * obj1 = 0 ;
20271 char *kwnames[] = {
20272 (char *) "self",(char *) "m_size", NULL
20273 };
20274
20275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20277 if (SWIG_arg_fail(1)) SWIG_fail;
20278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20279 if (SWIG_arg_fail(2)) SWIG_fail;
20280 if (arg1) (arg1)->m_size = *arg2;
20281
20282 Py_INCREF(Py_None); resultobj = Py_None;
20283 return resultobj;
20284 fail:
20285 return NULL;
20286 }
20287
20288
20289 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20290 PyObject *resultobj = NULL;
20291 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20292 wxSize *result;
20293 PyObject * obj0 = 0 ;
20294 char *kwnames[] = {
20295 (char *) "self", NULL
20296 };
20297
20298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20300 if (SWIG_arg_fail(1)) SWIG_fail;
20301 result = (wxSize *)& ((arg1)->m_size);
20302
20303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20304 return resultobj;
20305 fail:
20306 return NULL;
20307 }
20308
20309
20310 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20311 PyObject *resultobj = NULL;
20312 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20313 wxRect *arg2 = (wxRect *) 0 ;
20314 PyObject * obj0 = 0 ;
20315 PyObject * obj1 = 0 ;
20316 char *kwnames[] = {
20317 (char *) "self",(char *) "m_rect", NULL
20318 };
20319
20320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20322 if (SWIG_arg_fail(1)) SWIG_fail;
20323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20324 if (SWIG_arg_fail(2)) SWIG_fail;
20325 if (arg1) (arg1)->m_rect = *arg2;
20326
20327 Py_INCREF(Py_None); resultobj = Py_None;
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20335 PyObject *resultobj = NULL;
20336 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20337 wxRect *result;
20338 PyObject * obj0 = 0 ;
20339 char *kwnames[] = {
20340 (char *) "self", NULL
20341 };
20342
20343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20345 if (SWIG_arg_fail(1)) SWIG_fail;
20346 result = (wxRect *)& ((arg1)->m_rect);
20347
20348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20356 PyObject *obj;
20357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20358 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20359 Py_INCREF(obj);
20360 return Py_BuildValue((char *)"");
20361 }
20362 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20363 PyObject *resultobj = NULL;
20364 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20365 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20366 int arg2 = (int) 0 ;
20367 wxMoveEvent *result;
20368 wxPoint temp1 ;
20369 PyObject * obj0 = 0 ;
20370 PyObject * obj1 = 0 ;
20371 char *kwnames[] = {
20372 (char *) "pos",(char *) "winid", NULL
20373 };
20374
20375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20376 if (obj0) {
20377 {
20378 arg1 = &temp1;
20379 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20380 }
20381 }
20382 if (obj1) {
20383 {
20384 arg2 = static_cast<int >(SWIG_As_int(obj1));
20385 if (SWIG_arg_fail(2)) SWIG_fail;
20386 }
20387 }
20388 {
20389 PyThreadState* __tstate = wxPyBeginAllowThreads();
20390 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20391
20392 wxPyEndAllowThreads(__tstate);
20393 if (PyErr_Occurred()) SWIG_fail;
20394 }
20395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20396 return resultobj;
20397 fail:
20398 return NULL;
20399 }
20400
20401
20402 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20403 PyObject *resultobj = NULL;
20404 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20405 wxPoint result;
20406 PyObject * obj0 = 0 ;
20407 char *kwnames[] = {
20408 (char *) "self", NULL
20409 };
20410
20411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20413 if (SWIG_arg_fail(1)) SWIG_fail;
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = ((wxMoveEvent const *)arg1)->GetPosition();
20417
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 {
20422 wxPoint * resultptr;
20423 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20425 }
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20433 PyObject *resultobj = NULL;
20434 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20435 wxRect result;
20436 PyObject * obj0 = 0 ;
20437 char *kwnames[] = {
20438 (char *) "self", NULL
20439 };
20440
20441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20443 if (SWIG_arg_fail(1)) SWIG_fail;
20444 {
20445 PyThreadState* __tstate = wxPyBeginAllowThreads();
20446 result = ((wxMoveEvent const *)arg1)->GetRect();
20447
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 {
20452 wxRect * resultptr;
20453 resultptr = new wxRect(static_cast<wxRect & >(result));
20454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20455 }
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20463 PyObject *resultobj = NULL;
20464 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20465 wxRect *arg2 = 0 ;
20466 wxRect temp2 ;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 char *kwnames[] = {
20470 (char *) "self",(char *) "rect", NULL
20471 };
20472
20473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20475 if (SWIG_arg_fail(1)) SWIG_fail;
20476 {
20477 arg2 = &temp2;
20478 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20479 }
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 (arg1)->SetRect((wxRect const &)*arg2);
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 Py_INCREF(Py_None); resultobj = Py_None;
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj = NULL;
20496 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20497 wxPoint *arg2 = 0 ;
20498 wxPoint temp2 ;
20499 PyObject * obj0 = 0 ;
20500 PyObject * obj1 = 0 ;
20501 char *kwnames[] = {
20502 (char *) "self",(char *) "pos", NULL
20503 };
20504
20505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 {
20509 arg2 = &temp2;
20510 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20511 }
20512 {
20513 PyThreadState* __tstate = wxPyBeginAllowThreads();
20514 (arg1)->SetPosition((wxPoint const &)*arg2);
20515
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 Py_INCREF(Py_None); resultobj = Py_None;
20520 return resultobj;
20521 fail:
20522 return NULL;
20523 }
20524
20525
20526 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20527 PyObject *obj;
20528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20529 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20530 Py_INCREF(obj);
20531 return Py_BuildValue((char *)"");
20532 }
20533 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20534 PyObject *resultobj = NULL;
20535 int arg1 = (int) 0 ;
20536 wxPaintEvent *result;
20537 PyObject * obj0 = 0 ;
20538 char *kwnames[] = {
20539 (char *) "Id", NULL
20540 };
20541
20542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20543 if (obj0) {
20544 {
20545 arg1 = static_cast<int >(SWIG_As_int(obj0));
20546 if (SWIG_arg_fail(1)) SWIG_fail;
20547 }
20548 }
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20552
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20557 return resultobj;
20558 fail:
20559 return NULL;
20560 }
20561
20562
20563 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20564 PyObject *obj;
20565 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20566 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20567 Py_INCREF(obj);
20568 return Py_BuildValue((char *)"");
20569 }
20570 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20571 PyObject *resultobj = NULL;
20572 int arg1 = (int) 0 ;
20573 wxNcPaintEvent *result;
20574 PyObject * obj0 = 0 ;
20575 char *kwnames[] = {
20576 (char *) "winid", NULL
20577 };
20578
20579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20580 if (obj0) {
20581 {
20582 arg1 = static_cast<int >(SWIG_As_int(obj0));
20583 if (SWIG_arg_fail(1)) SWIG_fail;
20584 }
20585 }
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20589
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20601 PyObject *obj;
20602 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20603 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20604 Py_INCREF(obj);
20605 return Py_BuildValue((char *)"");
20606 }
20607 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20608 PyObject *resultobj = NULL;
20609 int arg1 = (int) 0 ;
20610 wxDC *arg2 = (wxDC *) NULL ;
20611 wxEraseEvent *result;
20612 PyObject * obj0 = 0 ;
20613 PyObject * obj1 = 0 ;
20614 char *kwnames[] = {
20615 (char *) "Id",(char *) "dc", NULL
20616 };
20617
20618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20619 if (obj0) {
20620 {
20621 arg1 = static_cast<int >(SWIG_As_int(obj0));
20622 if (SWIG_arg_fail(1)) SWIG_fail;
20623 }
20624 }
20625 if (obj1) {
20626 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20627 if (SWIG_arg_fail(2)) SWIG_fail;
20628 }
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20632
20633 wxPyEndAllowThreads(__tstate);
20634 if (PyErr_Occurred()) SWIG_fail;
20635 }
20636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20644 PyObject *resultobj = NULL;
20645 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20646 wxDC *result;
20647 PyObject * obj0 = 0 ;
20648 char *kwnames[] = {
20649 (char *) "self", NULL
20650 };
20651
20652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20654 if (SWIG_arg_fail(1)) SWIG_fail;
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20658
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 {
20663 resultobj = wxPyMake_wxObject(result, (bool)0);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20672 PyObject *obj;
20673 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20674 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20675 Py_INCREF(obj);
20676 return Py_BuildValue((char *)"");
20677 }
20678 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj = NULL;
20680 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20681 int arg2 = (int) 0 ;
20682 wxFocusEvent *result;
20683 PyObject * obj0 = 0 ;
20684 PyObject * obj1 = 0 ;
20685 char *kwnames[] = {
20686 (char *) "type",(char *) "winid", NULL
20687 };
20688
20689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20690 if (obj0) {
20691 {
20692 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20693 if (SWIG_arg_fail(1)) SWIG_fail;
20694 }
20695 }
20696 if (obj1) {
20697 {
20698 arg2 = static_cast<int >(SWIG_As_int(obj1));
20699 if (SWIG_arg_fail(2)) SWIG_fail;
20700 }
20701 }
20702 {
20703 PyThreadState* __tstate = wxPyBeginAllowThreads();
20704 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20705
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20717 PyObject *resultobj = NULL;
20718 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20719 wxWindow *result;
20720 PyObject * obj0 = 0 ;
20721 char *kwnames[] = {
20722 (char *) "self", NULL
20723 };
20724
20725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20727 if (SWIG_arg_fail(1)) SWIG_fail;
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20731
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 {
20736 resultobj = wxPyMake_wxObject(result, (bool)0);
20737 }
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20745 PyObject *resultobj = NULL;
20746 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20747 wxWindow *arg2 = (wxWindow *) 0 ;
20748 PyObject * obj0 = 0 ;
20749 PyObject * obj1 = 0 ;
20750 char *kwnames[] = {
20751 (char *) "self",(char *) "win", NULL
20752 };
20753
20754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20756 if (SWIG_arg_fail(1)) SWIG_fail;
20757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20758 if (SWIG_arg_fail(2)) SWIG_fail;
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 (arg1)->SetWindow(arg2);
20762
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 Py_INCREF(Py_None); resultobj = Py_None;
20767 return resultobj;
20768 fail:
20769 return NULL;
20770 }
20771
20772
20773 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20774 PyObject *obj;
20775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20776 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20777 Py_INCREF(obj);
20778 return Py_BuildValue((char *)"");
20779 }
20780 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20781 PyObject *resultobj = NULL;
20782 wxWindow *arg1 = (wxWindow *) NULL ;
20783 wxChildFocusEvent *result;
20784 PyObject * obj0 = 0 ;
20785 char *kwnames[] = {
20786 (char *) "win", NULL
20787 };
20788
20789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20790 if (obj0) {
20791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20797
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20809 PyObject *resultobj = NULL;
20810 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20811 wxWindow *result;
20812 PyObject * obj0 = 0 ;
20813 char *kwnames[] = {
20814 (char *) "self", NULL
20815 };
20816
20817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20819 if (SWIG_arg_fail(1)) SWIG_fail;
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20823
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 resultobj = wxPyMake_wxObject(result, (bool)0);
20829 }
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20837 PyObject *obj;
20838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20839 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20840 Py_INCREF(obj);
20841 return Py_BuildValue((char *)"");
20842 }
20843 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20844 PyObject *resultobj = NULL;
20845 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20846 bool arg2 = (bool) true ;
20847 int arg3 = (int) 0 ;
20848 wxActivateEvent *result;
20849 PyObject * obj0 = 0 ;
20850 PyObject * obj1 = 0 ;
20851 PyObject * obj2 = 0 ;
20852 char *kwnames[] = {
20853 (char *) "type",(char *) "active",(char *) "Id", NULL
20854 };
20855
20856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20857 if (obj0) {
20858 {
20859 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20860 if (SWIG_arg_fail(1)) SWIG_fail;
20861 }
20862 }
20863 if (obj1) {
20864 {
20865 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20866 if (SWIG_arg_fail(2)) SWIG_fail;
20867 }
20868 }
20869 if (obj2) {
20870 {
20871 arg3 = static_cast<int >(SWIG_As_int(obj2));
20872 if (SWIG_arg_fail(3)) SWIG_fail;
20873 }
20874 }
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20878
20879 wxPyEndAllowThreads(__tstate);
20880 if (PyErr_Occurred()) SWIG_fail;
20881 }
20882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20890 PyObject *resultobj = NULL;
20891 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20892 bool result;
20893 PyObject * obj0 = 0 ;
20894 char *kwnames[] = {
20895 (char *) "self", NULL
20896 };
20897
20898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20900 if (SWIG_arg_fail(1)) SWIG_fail;
20901 {
20902 PyThreadState* __tstate = wxPyBeginAllowThreads();
20903 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20904
20905 wxPyEndAllowThreads(__tstate);
20906 if (PyErr_Occurred()) SWIG_fail;
20907 }
20908 {
20909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20910 }
20911 return resultobj;
20912 fail:
20913 return NULL;
20914 }
20915
20916
20917 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20918 PyObject *obj;
20919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20920 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20921 Py_INCREF(obj);
20922 return Py_BuildValue((char *)"");
20923 }
20924 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20925 PyObject *resultobj = NULL;
20926 int arg1 = (int) 0 ;
20927 wxInitDialogEvent *result;
20928 PyObject * obj0 = 0 ;
20929 char *kwnames[] = {
20930 (char *) "Id", NULL
20931 };
20932
20933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20934 if (obj0) {
20935 {
20936 arg1 = static_cast<int >(SWIG_As_int(obj0));
20937 if (SWIG_arg_fail(1)) SWIG_fail;
20938 }
20939 }
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20943
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20948 return resultobj;
20949 fail:
20950 return NULL;
20951 }
20952
20953
20954 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20955 PyObject *obj;
20956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20957 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20958 Py_INCREF(obj);
20959 return Py_BuildValue((char *)"");
20960 }
20961 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20962 PyObject *resultobj = NULL;
20963 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20964 int arg2 = (int) 0 ;
20965 wxMenu *arg3 = (wxMenu *) NULL ;
20966 wxMenuEvent *result;
20967 PyObject * obj0 = 0 ;
20968 PyObject * obj1 = 0 ;
20969 PyObject * obj2 = 0 ;
20970 char *kwnames[] = {
20971 (char *) "type",(char *) "winid",(char *) "menu", NULL
20972 };
20973
20974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20975 if (obj0) {
20976 {
20977 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20978 if (SWIG_arg_fail(1)) SWIG_fail;
20979 }
20980 }
20981 if (obj1) {
20982 {
20983 arg2 = static_cast<int >(SWIG_As_int(obj1));
20984 if (SWIG_arg_fail(2)) SWIG_fail;
20985 }
20986 }
20987 if (obj2) {
20988 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20989 if (SWIG_arg_fail(3)) SWIG_fail;
20990 }
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20994
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
21006 PyObject *resultobj = NULL;
21007 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21008 int result;
21009 PyObject * obj0 = 0 ;
21010 char *kwnames[] = {
21011 (char *) "self", NULL
21012 };
21013
21014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
21015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21016 if (SWIG_arg_fail(1)) SWIG_fail;
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
21020
21021 wxPyEndAllowThreads(__tstate);
21022 if (PyErr_Occurred()) SWIG_fail;
21023 }
21024 {
21025 resultobj = SWIG_From_int(static_cast<int >(result));
21026 }
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
21034 PyObject *resultobj = NULL;
21035 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21036 bool result;
21037 PyObject * obj0 = 0 ;
21038 char *kwnames[] = {
21039 (char *) "self", NULL
21040 };
21041
21042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
21043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21044 if (SWIG_arg_fail(1)) SWIG_fail;
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
21048
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 {
21053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21054 }
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
21062 PyObject *resultobj = NULL;
21063 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21064 wxMenu *result;
21065 PyObject * obj0 = 0 ;
21066 char *kwnames[] = {
21067 (char *) "self", NULL
21068 };
21069
21070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
21071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21072 if (SWIG_arg_fail(1)) SWIG_fail;
21073 {
21074 PyThreadState* __tstate = wxPyBeginAllowThreads();
21075 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
21076
21077 wxPyEndAllowThreads(__tstate);
21078 if (PyErr_Occurred()) SWIG_fail;
21079 }
21080 {
21081 resultobj = wxPyMake_wxObject(result, (bool)0);
21082 }
21083 return resultobj;
21084 fail:
21085 return NULL;
21086 }
21087
21088
21089 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21090 PyObject *obj;
21091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21092 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21093 Py_INCREF(obj);
21094 return Py_BuildValue((char *)"");
21095 }
21096 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj = NULL;
21098 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21099 int arg2 = (int) 0 ;
21100 wxCloseEvent *result;
21101 PyObject * obj0 = 0 ;
21102 PyObject * obj1 = 0 ;
21103 char *kwnames[] = {
21104 (char *) "type",(char *) "winid", NULL
21105 };
21106
21107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21108 if (obj0) {
21109 {
21110 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21111 if (SWIG_arg_fail(1)) SWIG_fail;
21112 }
21113 }
21114 if (obj1) {
21115 {
21116 arg2 = static_cast<int >(SWIG_As_int(obj1));
21117 if (SWIG_arg_fail(2)) SWIG_fail;
21118 }
21119 }
21120 {
21121 PyThreadState* __tstate = wxPyBeginAllowThreads();
21122 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21123
21124 wxPyEndAllowThreads(__tstate);
21125 if (PyErr_Occurred()) SWIG_fail;
21126 }
21127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21128 return resultobj;
21129 fail:
21130 return NULL;
21131 }
21132
21133
21134 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21135 PyObject *resultobj = NULL;
21136 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21137 bool arg2 ;
21138 PyObject * obj0 = 0 ;
21139 PyObject * obj1 = 0 ;
21140 char *kwnames[] = {
21141 (char *) "self",(char *) "logOff", NULL
21142 };
21143
21144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21146 if (SWIG_arg_fail(1)) SWIG_fail;
21147 {
21148 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21149 if (SWIG_arg_fail(2)) SWIG_fail;
21150 }
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 (arg1)->SetLoggingOff(arg2);
21154
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 Py_INCREF(Py_None); resultobj = Py_None;
21159 return resultobj;
21160 fail:
21161 return NULL;
21162 }
21163
21164
21165 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21166 PyObject *resultobj = NULL;
21167 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21168 bool result;
21169 PyObject * obj0 = 0 ;
21170 char *kwnames[] = {
21171 (char *) "self", NULL
21172 };
21173
21174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21176 if (SWIG_arg_fail(1)) SWIG_fail;
21177 {
21178 PyThreadState* __tstate = wxPyBeginAllowThreads();
21179 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21180
21181 wxPyEndAllowThreads(__tstate);
21182 if (PyErr_Occurred()) SWIG_fail;
21183 }
21184 {
21185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21186 }
21187 return resultobj;
21188 fail:
21189 return NULL;
21190 }
21191
21192
21193 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21194 PyObject *resultobj = NULL;
21195 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21196 bool arg2 = (bool) true ;
21197 PyObject * obj0 = 0 ;
21198 PyObject * obj1 = 0 ;
21199 char *kwnames[] = {
21200 (char *) "self",(char *) "veto", NULL
21201 };
21202
21203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21205 if (SWIG_arg_fail(1)) SWIG_fail;
21206 if (obj1) {
21207 {
21208 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21209 if (SWIG_arg_fail(2)) SWIG_fail;
21210 }
21211 }
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 (arg1)->Veto(arg2);
21215
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 Py_INCREF(Py_None); resultobj = Py_None;
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21227 PyObject *resultobj = NULL;
21228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21229 bool result;
21230 PyObject * obj0 = 0 ;
21231 char *kwnames[] = {
21232 (char *) "self", NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21237 if (SWIG_arg_fail(1)) SWIG_fail;
21238 {
21239 PyThreadState* __tstate = wxPyBeginAllowThreads();
21240 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21241
21242 wxPyEndAllowThreads(__tstate);
21243 if (PyErr_Occurred()) SWIG_fail;
21244 }
21245 {
21246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21247 }
21248 return resultobj;
21249 fail:
21250 return NULL;
21251 }
21252
21253
21254 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21255 PyObject *resultobj = NULL;
21256 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21257 bool arg2 ;
21258 PyObject * obj0 = 0 ;
21259 PyObject * obj1 = 0 ;
21260 char *kwnames[] = {
21261 (char *) "self",(char *) "canVeto", NULL
21262 };
21263
21264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21266 if (SWIG_arg_fail(1)) SWIG_fail;
21267 {
21268 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21269 if (SWIG_arg_fail(2)) SWIG_fail;
21270 }
21271 {
21272 PyThreadState* __tstate = wxPyBeginAllowThreads();
21273 (arg1)->SetCanVeto(arg2);
21274
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 Py_INCREF(Py_None); resultobj = Py_None;
21279 return resultobj;
21280 fail:
21281 return NULL;
21282 }
21283
21284
21285 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21286 PyObject *resultobj = NULL;
21287 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21288 bool result;
21289 PyObject * obj0 = 0 ;
21290 char *kwnames[] = {
21291 (char *) "self", NULL
21292 };
21293
21294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21296 if (SWIG_arg_fail(1)) SWIG_fail;
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21300
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 {
21305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21306 }
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21314 PyObject *obj;
21315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21316 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21317 Py_INCREF(obj);
21318 return Py_BuildValue((char *)"");
21319 }
21320 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21321 PyObject *resultobj = NULL;
21322 int arg1 = (int) 0 ;
21323 bool arg2 = (bool) false ;
21324 wxShowEvent *result;
21325 PyObject * obj0 = 0 ;
21326 PyObject * obj1 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "winid",(char *) "show", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21332 if (obj0) {
21333 {
21334 arg1 = static_cast<int >(SWIG_As_int(obj0));
21335 if (SWIG_arg_fail(1)) SWIG_fail;
21336 }
21337 }
21338 if (obj1) {
21339 {
21340 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21341 if (SWIG_arg_fail(2)) SWIG_fail;
21342 }
21343 }
21344 {
21345 PyThreadState* __tstate = wxPyBeginAllowThreads();
21346 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21347
21348 wxPyEndAllowThreads(__tstate);
21349 if (PyErr_Occurred()) SWIG_fail;
21350 }
21351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21352 return resultobj;
21353 fail:
21354 return NULL;
21355 }
21356
21357
21358 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21359 PyObject *resultobj = NULL;
21360 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21361 bool arg2 ;
21362 PyObject * obj0 = 0 ;
21363 PyObject * obj1 = 0 ;
21364 char *kwnames[] = {
21365 (char *) "self",(char *) "show", NULL
21366 };
21367
21368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21370 if (SWIG_arg_fail(1)) SWIG_fail;
21371 {
21372 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21373 if (SWIG_arg_fail(2)) SWIG_fail;
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 (arg1)->SetShow(arg2);
21378
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 Py_INCREF(Py_None); resultobj = Py_None;
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj = NULL;
21391 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21392 bool result;
21393 PyObject * obj0 = 0 ;
21394 char *kwnames[] = {
21395 (char *) "self", NULL
21396 };
21397
21398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21400 if (SWIG_arg_fail(1)) SWIG_fail;
21401 {
21402 PyThreadState* __tstate = wxPyBeginAllowThreads();
21403 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21404
21405 wxPyEndAllowThreads(__tstate);
21406 if (PyErr_Occurred()) SWIG_fail;
21407 }
21408 {
21409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21410 }
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21418 PyObject *obj;
21419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21420 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21421 Py_INCREF(obj);
21422 return Py_BuildValue((char *)"");
21423 }
21424 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21425 PyObject *resultobj = NULL;
21426 int arg1 = (int) 0 ;
21427 bool arg2 = (bool) true ;
21428 wxIconizeEvent *result;
21429 PyObject * obj0 = 0 ;
21430 PyObject * obj1 = 0 ;
21431 char *kwnames[] = {
21432 (char *) "id",(char *) "iconized", NULL
21433 };
21434
21435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21436 if (obj0) {
21437 {
21438 arg1 = static_cast<int >(SWIG_As_int(obj0));
21439 if (SWIG_arg_fail(1)) SWIG_fail;
21440 }
21441 }
21442 if (obj1) {
21443 {
21444 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21445 if (SWIG_arg_fail(2)) SWIG_fail;
21446 }
21447 }
21448 {
21449 PyThreadState* __tstate = wxPyBeginAllowThreads();
21450 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21451
21452 wxPyEndAllowThreads(__tstate);
21453 if (PyErr_Occurred()) SWIG_fail;
21454 }
21455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21456 return resultobj;
21457 fail:
21458 return NULL;
21459 }
21460
21461
21462 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21463 PyObject *resultobj = NULL;
21464 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21465 bool result;
21466 PyObject * obj0 = 0 ;
21467 char *kwnames[] = {
21468 (char *) "self", NULL
21469 };
21470
21471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21473 if (SWIG_arg_fail(1)) SWIG_fail;
21474 {
21475 PyThreadState* __tstate = wxPyBeginAllowThreads();
21476 result = (bool)(arg1)->Iconized();
21477
21478 wxPyEndAllowThreads(__tstate);
21479 if (PyErr_Occurred()) SWIG_fail;
21480 }
21481 {
21482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21483 }
21484 return resultobj;
21485 fail:
21486 return NULL;
21487 }
21488
21489
21490 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21491 PyObject *obj;
21492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21493 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21494 Py_INCREF(obj);
21495 return Py_BuildValue((char *)"");
21496 }
21497 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj = NULL;
21499 int arg1 = (int) 0 ;
21500 wxMaximizeEvent *result;
21501 PyObject * obj0 = 0 ;
21502 char *kwnames[] = {
21503 (char *) "id", NULL
21504 };
21505
21506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21507 if (obj0) {
21508 {
21509 arg1 = static_cast<int >(SWIG_As_int(obj0));
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 }
21512 }
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21516
21517 wxPyEndAllowThreads(__tstate);
21518 if (PyErr_Occurred()) SWIG_fail;
21519 }
21520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21528 PyObject *obj;
21529 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21530 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21531 Py_INCREF(obj);
21532 return Py_BuildValue((char *)"");
21533 }
21534 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21535 PyObject *resultobj = NULL;
21536 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21537 wxPoint result;
21538 PyObject * obj0 = 0 ;
21539 char *kwnames[] = {
21540 (char *) "self", NULL
21541 };
21542
21543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21545 if (SWIG_arg_fail(1)) SWIG_fail;
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 result = (arg1)->GetPosition();
21549
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 {
21554 wxPoint * resultptr;
21555 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21557 }
21558 return resultobj;
21559 fail:
21560 return NULL;
21561 }
21562
21563
21564 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21565 PyObject *resultobj = NULL;
21566 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21567 int result;
21568 PyObject * obj0 = 0 ;
21569 char *kwnames[] = {
21570 (char *) "self", NULL
21571 };
21572
21573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21575 if (SWIG_arg_fail(1)) SWIG_fail;
21576 {
21577 PyThreadState* __tstate = wxPyBeginAllowThreads();
21578 result = (int)(arg1)->GetNumberOfFiles();
21579
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 {
21584 resultobj = SWIG_From_int(static_cast<int >(result));
21585 }
21586 return resultobj;
21587 fail:
21588 return NULL;
21589 }
21590
21591
21592 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj = NULL;
21594 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21595 PyObject *result;
21596 PyObject * obj0 = 0 ;
21597 char *kwnames[] = {
21598 (char *) "self", NULL
21599 };
21600
21601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21603 if (SWIG_arg_fail(1)) SWIG_fail;
21604 {
21605 PyThreadState* __tstate = wxPyBeginAllowThreads();
21606 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21607
21608 wxPyEndAllowThreads(__tstate);
21609 if (PyErr_Occurred()) SWIG_fail;
21610 }
21611 resultobj = result;
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21619 PyObject *obj;
21620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21621 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21622 Py_INCREF(obj);
21623 return Py_BuildValue((char *)"");
21624 }
21625 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21626 PyObject *resultobj = NULL;
21627 int arg1 = (int) 0 ;
21628 wxUpdateUIEvent *result;
21629 PyObject * obj0 = 0 ;
21630 char *kwnames[] = {
21631 (char *) "commandId", NULL
21632 };
21633
21634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21635 if (obj0) {
21636 {
21637 arg1 = static_cast<int >(SWIG_As_int(obj0));
21638 if (SWIG_arg_fail(1)) SWIG_fail;
21639 }
21640 }
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21649 return resultobj;
21650 fail:
21651 return NULL;
21652 }
21653
21654
21655 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21656 PyObject *resultobj = NULL;
21657 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21658 bool result;
21659 PyObject * obj0 = 0 ;
21660 char *kwnames[] = {
21661 (char *) "self", NULL
21662 };
21663
21664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21666 if (SWIG_arg_fail(1)) SWIG_fail;
21667 {
21668 PyThreadState* __tstate = wxPyBeginAllowThreads();
21669 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21670
21671 wxPyEndAllowThreads(__tstate);
21672 if (PyErr_Occurred()) SWIG_fail;
21673 }
21674 {
21675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21676 }
21677 return resultobj;
21678 fail:
21679 return NULL;
21680 }
21681
21682
21683 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21684 PyObject *resultobj = NULL;
21685 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21686 bool result;
21687 PyObject * obj0 = 0 ;
21688 char *kwnames[] = {
21689 (char *) "self", NULL
21690 };
21691
21692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21694 if (SWIG_arg_fail(1)) SWIG_fail;
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21698
21699 wxPyEndAllowThreads(__tstate);
21700 if (PyErr_Occurred()) SWIG_fail;
21701 }
21702 {
21703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21704 }
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 static PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *, PyObject *args, PyObject *kwargs) {
21712 PyObject *resultobj = NULL;
21713 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21714 bool result;
21715 PyObject * obj0 = 0 ;
21716 char *kwnames[] = {
21717 (char *) "self", NULL
21718 };
21719
21720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetShown",kwnames,&obj0)) goto fail;
21721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21722 if (SWIG_arg_fail(1)) SWIG_fail;
21723 {
21724 PyThreadState* __tstate = wxPyBeginAllowThreads();
21725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
21726
21727 wxPyEndAllowThreads(__tstate);
21728 if (PyErr_Occurred()) SWIG_fail;
21729 }
21730 {
21731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21732 }
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj = NULL;
21741 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21742 wxString result;
21743 PyObject * obj0 = 0 ;
21744 char *kwnames[] = {
21745 (char *) "self", NULL
21746 };
21747
21748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21750 if (SWIG_arg_fail(1)) SWIG_fail;
21751 {
21752 PyThreadState* __tstate = wxPyBeginAllowThreads();
21753 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21754
21755 wxPyEndAllowThreads(__tstate);
21756 if (PyErr_Occurred()) SWIG_fail;
21757 }
21758 {
21759 #if wxUSE_UNICODE
21760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21761 #else
21762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21763 #endif
21764 }
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21772 PyObject *resultobj = NULL;
21773 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21774 bool result;
21775 PyObject * obj0 = 0 ;
21776 char *kwnames[] = {
21777 (char *) "self", NULL
21778 };
21779
21780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21782 if (SWIG_arg_fail(1)) SWIG_fail;
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21786
21787 wxPyEndAllowThreads(__tstate);
21788 if (PyErr_Occurred()) SWIG_fail;
21789 }
21790 {
21791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21792 }
21793 return resultobj;
21794 fail:
21795 return NULL;
21796 }
21797
21798
21799 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21800 PyObject *resultobj = NULL;
21801 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21802 bool result;
21803 PyObject * obj0 = 0 ;
21804 char *kwnames[] = {
21805 (char *) "self", NULL
21806 };
21807
21808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21810 if (SWIG_arg_fail(1)) SWIG_fail;
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21814
21815 wxPyEndAllowThreads(__tstate);
21816 if (PyErr_Occurred()) SWIG_fail;
21817 }
21818 {
21819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21820 }
21821 return resultobj;
21822 fail:
21823 return NULL;
21824 }
21825
21826
21827 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21828 PyObject *resultobj = NULL;
21829 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21830 bool result;
21831 PyObject * obj0 = 0 ;
21832 char *kwnames[] = {
21833 (char *) "self", NULL
21834 };
21835
21836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21838 if (SWIG_arg_fail(1)) SWIG_fail;
21839 {
21840 PyThreadState* __tstate = wxPyBeginAllowThreads();
21841 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21842
21843 wxPyEndAllowThreads(__tstate);
21844 if (PyErr_Occurred()) SWIG_fail;
21845 }
21846 {
21847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21848 }
21849 return resultobj;
21850 fail:
21851 return NULL;
21852 }
21853
21854
21855 static PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *, PyObject *args, PyObject *kwargs) {
21856 PyObject *resultobj = NULL;
21857 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21858 bool result;
21859 PyObject * obj0 = 0 ;
21860 char *kwnames[] = {
21861 (char *) "self", NULL
21862 };
21863
21864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetShown",kwnames,&obj0)) goto fail;
21865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21866 if (SWIG_arg_fail(1)) SWIG_fail;
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
21870
21871 wxPyEndAllowThreads(__tstate);
21872 if (PyErr_Occurred()) SWIG_fail;
21873 }
21874 {
21875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21876 }
21877 return resultobj;
21878 fail:
21879 return NULL;
21880 }
21881
21882
21883 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21884 PyObject *resultobj = NULL;
21885 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21886 bool arg2 ;
21887 PyObject * obj0 = 0 ;
21888 PyObject * obj1 = 0 ;
21889 char *kwnames[] = {
21890 (char *) "self",(char *) "check", NULL
21891 };
21892
21893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 {
21897 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21898 if (SWIG_arg_fail(2)) SWIG_fail;
21899 }
21900 {
21901 PyThreadState* __tstate = wxPyBeginAllowThreads();
21902 (arg1)->Check(arg2);
21903
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 Py_INCREF(Py_None); resultobj = Py_None;
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21915 PyObject *resultobj = NULL;
21916 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21917 bool arg2 ;
21918 PyObject * obj0 = 0 ;
21919 PyObject * obj1 = 0 ;
21920 char *kwnames[] = {
21921 (char *) "self",(char *) "enable", NULL
21922 };
21923
21924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21926 if (SWIG_arg_fail(1)) SWIG_fail;
21927 {
21928 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21929 if (SWIG_arg_fail(2)) SWIG_fail;
21930 }
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 (arg1)->Enable(arg2);
21934
21935 wxPyEndAllowThreads(__tstate);
21936 if (PyErr_Occurred()) SWIG_fail;
21937 }
21938 Py_INCREF(Py_None); resultobj = Py_None;
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 static PyObject *_wrap_UpdateUIEvent_Show(PyObject *, PyObject *args, PyObject *kwargs) {
21946 PyObject *resultobj = NULL;
21947 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21948 bool arg2 ;
21949 PyObject * obj0 = 0 ;
21950 PyObject * obj1 = 0 ;
21951 char *kwnames[] = {
21952 (char *) "self",(char *) "show", NULL
21953 };
21954
21955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) goto fail;
21956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21957 if (SWIG_arg_fail(1)) SWIG_fail;
21958 {
21959 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21960 if (SWIG_arg_fail(2)) SWIG_fail;
21961 }
21962 {
21963 PyThreadState* __tstate = wxPyBeginAllowThreads();
21964 (arg1)->Show(arg2);
21965
21966 wxPyEndAllowThreads(__tstate);
21967 if (PyErr_Occurred()) SWIG_fail;
21968 }
21969 Py_INCREF(Py_None); resultobj = Py_None;
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21977 PyObject *resultobj = NULL;
21978 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21979 wxString *arg2 = 0 ;
21980 bool temp2 = false ;
21981 PyObject * obj0 = 0 ;
21982 PyObject * obj1 = 0 ;
21983 char *kwnames[] = {
21984 (char *) "self",(char *) "text", NULL
21985 };
21986
21987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21989 if (SWIG_arg_fail(1)) SWIG_fail;
21990 {
21991 arg2 = wxString_in_helper(obj1);
21992 if (arg2 == NULL) SWIG_fail;
21993 temp2 = true;
21994 }
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 (arg1)->SetText((wxString const &)*arg2);
21998
21999 wxPyEndAllowThreads(__tstate);
22000 if (PyErr_Occurred()) SWIG_fail;
22001 }
22002 Py_INCREF(Py_None); resultobj = Py_None;
22003 {
22004 if (temp2)
22005 delete arg2;
22006 }
22007 return resultobj;
22008 fail:
22009 {
22010 if (temp2)
22011 delete arg2;
22012 }
22013 return NULL;
22014 }
22015
22016
22017 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj = NULL;
22019 long arg1 ;
22020 PyObject * obj0 = 0 ;
22021 char *kwnames[] = {
22022 (char *) "updateInterval", NULL
22023 };
22024
22025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
22026 {
22027 arg1 = static_cast<long >(SWIG_As_long(obj0));
22028 if (SWIG_arg_fail(1)) SWIG_fail;
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 wxUpdateUIEvent::SetUpdateInterval(arg1);
22033
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 Py_INCREF(Py_None); resultobj = Py_None;
22038 return resultobj;
22039 fail:
22040 return NULL;
22041 }
22042
22043
22044 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj = NULL;
22046 long result;
22047 char *kwnames[] = {
22048 NULL
22049 };
22050
22051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
22052 {
22053 PyThreadState* __tstate = wxPyBeginAllowThreads();
22054 result = (long)wxUpdateUIEvent::GetUpdateInterval();
22055
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 {
22060 resultobj = SWIG_From_long(static_cast<long >(result));
22061 }
22062 return resultobj;
22063 fail:
22064 return NULL;
22065 }
22066
22067
22068 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
22069 PyObject *resultobj = NULL;
22070 wxWindow *arg1 = (wxWindow *) 0 ;
22071 bool result;
22072 PyObject * obj0 = 0 ;
22073 char *kwnames[] = {
22074 (char *) "win", NULL
22075 };
22076
22077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
22078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22079 if (SWIG_arg_fail(1)) SWIG_fail;
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
22083
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
22097 PyObject *resultobj = NULL;
22098 char *kwnames[] = {
22099 NULL
22100 };
22101
22102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
22103 {
22104 PyThreadState* __tstate = wxPyBeginAllowThreads();
22105 wxUpdateUIEvent::ResetUpdateTime();
22106
22107 wxPyEndAllowThreads(__tstate);
22108 if (PyErr_Occurred()) SWIG_fail;
22109 }
22110 Py_INCREF(Py_None); resultobj = Py_None;
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22118 PyObject *resultobj = NULL;
22119 wxUpdateUIMode arg1 ;
22120 PyObject * obj0 = 0 ;
22121 char *kwnames[] = {
22122 (char *) "mode", NULL
22123 };
22124
22125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
22126 {
22127 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
22128 if (SWIG_arg_fail(1)) SWIG_fail;
22129 }
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 wxUpdateUIEvent::SetMode(arg1);
22133
22134 wxPyEndAllowThreads(__tstate);
22135 if (PyErr_Occurred()) SWIG_fail;
22136 }
22137 Py_INCREF(Py_None); resultobj = Py_None;
22138 return resultobj;
22139 fail:
22140 return NULL;
22141 }
22142
22143
22144 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22145 PyObject *resultobj = NULL;
22146 wxUpdateUIMode result;
22147 char *kwnames[] = {
22148 NULL
22149 };
22150
22151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
22155
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 resultobj = SWIG_From_int((result));
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
22167 PyObject *obj;
22168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22169 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22170 Py_INCREF(obj);
22171 return Py_BuildValue((char *)"");
22172 }
22173 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj = NULL;
22175 wxSysColourChangedEvent *result;
22176 char *kwnames[] = {
22177 NULL
22178 };
22179
22180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22184
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22196 PyObject *obj;
22197 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22198 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22199 Py_INCREF(obj);
22200 return Py_BuildValue((char *)"");
22201 }
22202 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22203 PyObject *resultobj = NULL;
22204 int arg1 = (int) 0 ;
22205 wxWindow *arg2 = (wxWindow *) NULL ;
22206 wxMouseCaptureChangedEvent *result;
22207 PyObject * obj0 = 0 ;
22208 PyObject * obj1 = 0 ;
22209 char *kwnames[] = {
22210 (char *) "winid",(char *) "gainedCapture", NULL
22211 };
22212
22213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22214 if (obj0) {
22215 {
22216 arg1 = static_cast<int >(SWIG_As_int(obj0));
22217 if (SWIG_arg_fail(1)) SWIG_fail;
22218 }
22219 }
22220 if (obj1) {
22221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22222 if (SWIG_arg_fail(2)) SWIG_fail;
22223 }
22224 {
22225 PyThreadState* __tstate = wxPyBeginAllowThreads();
22226 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22227
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22239 PyObject *resultobj = NULL;
22240 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22241 wxWindow *result;
22242 PyObject * obj0 = 0 ;
22243 char *kwnames[] = {
22244 (char *) "self", NULL
22245 };
22246
22247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22249 if (SWIG_arg_fail(1)) SWIG_fail;
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22253
22254 wxPyEndAllowThreads(__tstate);
22255 if (PyErr_Occurred()) SWIG_fail;
22256 }
22257 {
22258 resultobj = wxPyMake_wxObject(result, (bool)0);
22259 }
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22267 PyObject *obj;
22268 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22269 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22270 Py_INCREF(obj);
22271 return Py_BuildValue((char *)"");
22272 }
22273 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22274 PyObject *resultobj = NULL;
22275 wxDisplayChangedEvent *result;
22276 char *kwnames[] = {
22277 NULL
22278 };
22279
22280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22281 {
22282 PyThreadState* __tstate = wxPyBeginAllowThreads();
22283 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22284
22285 wxPyEndAllowThreads(__tstate);
22286 if (PyErr_Occurred()) SWIG_fail;
22287 }
22288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22296 PyObject *obj;
22297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22298 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22299 Py_INCREF(obj);
22300 return Py_BuildValue((char *)"");
22301 }
22302 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22303 PyObject *resultobj = NULL;
22304 int arg1 = (int) 0 ;
22305 wxPaletteChangedEvent *result;
22306 PyObject * obj0 = 0 ;
22307 char *kwnames[] = {
22308 (char *) "id", NULL
22309 };
22310
22311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22312 if (obj0) {
22313 {
22314 arg1 = static_cast<int >(SWIG_As_int(obj0));
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 }
22317 }
22318 {
22319 PyThreadState* __tstate = wxPyBeginAllowThreads();
22320 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22321
22322 wxPyEndAllowThreads(__tstate);
22323 if (PyErr_Occurred()) SWIG_fail;
22324 }
22325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22326 return resultobj;
22327 fail:
22328 return NULL;
22329 }
22330
22331
22332 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22333 PyObject *resultobj = NULL;
22334 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22335 wxWindow *arg2 = (wxWindow *) 0 ;
22336 PyObject * obj0 = 0 ;
22337 PyObject * obj1 = 0 ;
22338 char *kwnames[] = {
22339 (char *) "self",(char *) "win", NULL
22340 };
22341
22342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22344 if (SWIG_arg_fail(1)) SWIG_fail;
22345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22346 if (SWIG_arg_fail(2)) SWIG_fail;
22347 {
22348 PyThreadState* __tstate = wxPyBeginAllowThreads();
22349 (arg1)->SetChangedWindow(arg2);
22350
22351 wxPyEndAllowThreads(__tstate);
22352 if (PyErr_Occurred()) SWIG_fail;
22353 }
22354 Py_INCREF(Py_None); resultobj = Py_None;
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22362 PyObject *resultobj = NULL;
22363 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22364 wxWindow *result;
22365 PyObject * obj0 = 0 ;
22366 char *kwnames[] = {
22367 (char *) "self", NULL
22368 };
22369
22370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22372 if (SWIG_arg_fail(1)) SWIG_fail;
22373 {
22374 PyThreadState* __tstate = wxPyBeginAllowThreads();
22375 result = (wxWindow *)(arg1)->GetChangedWindow();
22376
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 {
22381 resultobj = wxPyMake_wxObject(result, (bool)0);
22382 }
22383 return resultobj;
22384 fail:
22385 return NULL;
22386 }
22387
22388
22389 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22390 PyObject *obj;
22391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22392 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22393 Py_INCREF(obj);
22394 return Py_BuildValue((char *)"");
22395 }
22396 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22397 PyObject *resultobj = NULL;
22398 int arg1 = (int) 0 ;
22399 wxQueryNewPaletteEvent *result;
22400 PyObject * obj0 = 0 ;
22401 char *kwnames[] = {
22402 (char *) "winid", NULL
22403 };
22404
22405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22406 if (obj0) {
22407 {
22408 arg1 = static_cast<int >(SWIG_As_int(obj0));
22409 if (SWIG_arg_fail(1)) SWIG_fail;
22410 }
22411 }
22412 {
22413 PyThreadState* __tstate = wxPyBeginAllowThreads();
22414 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22415
22416 wxPyEndAllowThreads(__tstate);
22417 if (PyErr_Occurred()) SWIG_fail;
22418 }
22419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22427 PyObject *resultobj = NULL;
22428 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22429 bool arg2 ;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 char *kwnames[] = {
22433 (char *) "self",(char *) "realized", NULL
22434 };
22435
22436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(1)) SWIG_fail;
22439 {
22440 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22441 if (SWIG_arg_fail(2)) SWIG_fail;
22442 }
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 (arg1)->SetPaletteRealized(arg2);
22446
22447 wxPyEndAllowThreads(__tstate);
22448 if (PyErr_Occurred()) SWIG_fail;
22449 }
22450 Py_INCREF(Py_None); resultobj = Py_None;
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22458 PyObject *resultobj = NULL;
22459 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22460 bool result;
22461 PyObject * obj0 = 0 ;
22462 char *kwnames[] = {
22463 (char *) "self", NULL
22464 };
22465
22466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22468 if (SWIG_arg_fail(1)) SWIG_fail;
22469 {
22470 PyThreadState* __tstate = wxPyBeginAllowThreads();
22471 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22472
22473 wxPyEndAllowThreads(__tstate);
22474 if (PyErr_Occurred()) SWIG_fail;
22475 }
22476 {
22477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22478 }
22479 return resultobj;
22480 fail:
22481 return NULL;
22482 }
22483
22484
22485 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22486 PyObject *obj;
22487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22488 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22489 Py_INCREF(obj);
22490 return Py_BuildValue((char *)"");
22491 }
22492 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22493 PyObject *resultobj = NULL;
22494 wxNavigationKeyEvent *result;
22495 char *kwnames[] = {
22496 NULL
22497 };
22498
22499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22500 {
22501 PyThreadState* __tstate = wxPyBeginAllowThreads();
22502 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22503
22504 wxPyEndAllowThreads(__tstate);
22505 if (PyErr_Occurred()) SWIG_fail;
22506 }
22507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22508 return resultobj;
22509 fail:
22510 return NULL;
22511 }
22512
22513
22514 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22515 PyObject *resultobj = NULL;
22516 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22517 bool result;
22518 PyObject * obj0 = 0 ;
22519 char *kwnames[] = {
22520 (char *) "self", NULL
22521 };
22522
22523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22525 if (SWIG_arg_fail(1)) SWIG_fail;
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22529
22530 wxPyEndAllowThreads(__tstate);
22531 if (PyErr_Occurred()) SWIG_fail;
22532 }
22533 {
22534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22535 }
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22543 PyObject *resultobj = NULL;
22544 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22545 bool arg2 ;
22546 PyObject * obj0 = 0 ;
22547 PyObject * obj1 = 0 ;
22548 char *kwnames[] = {
22549 (char *) "self",(char *) "forward", NULL
22550 };
22551
22552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22554 if (SWIG_arg_fail(1)) SWIG_fail;
22555 {
22556 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22557 if (SWIG_arg_fail(2)) SWIG_fail;
22558 }
22559 {
22560 PyThreadState* __tstate = wxPyBeginAllowThreads();
22561 (arg1)->SetDirection(arg2);
22562
22563 wxPyEndAllowThreads(__tstate);
22564 if (PyErr_Occurred()) SWIG_fail;
22565 }
22566 Py_INCREF(Py_None); resultobj = Py_None;
22567 return resultobj;
22568 fail:
22569 return NULL;
22570 }
22571
22572
22573 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22574 PyObject *resultobj = NULL;
22575 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22576 bool result;
22577 PyObject * obj0 = 0 ;
22578 char *kwnames[] = {
22579 (char *) "self", NULL
22580 };
22581
22582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22584 if (SWIG_arg_fail(1)) SWIG_fail;
22585 {
22586 PyThreadState* __tstate = wxPyBeginAllowThreads();
22587 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22588
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 {
22593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22594 }
22595 return resultobj;
22596 fail:
22597 return NULL;
22598 }
22599
22600
22601 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22602 PyObject *resultobj = NULL;
22603 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22604 bool arg2 ;
22605 PyObject * obj0 = 0 ;
22606 PyObject * obj1 = 0 ;
22607 char *kwnames[] = {
22608 (char *) "self",(char *) "ischange", NULL
22609 };
22610
22611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22613 if (SWIG_arg_fail(1)) SWIG_fail;
22614 {
22615 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22616 if (SWIG_arg_fail(2)) SWIG_fail;
22617 }
22618 {
22619 PyThreadState* __tstate = wxPyBeginAllowThreads();
22620 (arg1)->SetWindowChange(arg2);
22621
22622 wxPyEndAllowThreads(__tstate);
22623 if (PyErr_Occurred()) SWIG_fail;
22624 }
22625 Py_INCREF(Py_None); resultobj = Py_None;
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22633 PyObject *resultobj = NULL;
22634 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22635 bool result;
22636 PyObject * obj0 = 0 ;
22637 char *kwnames[] = {
22638 (char *) "self", NULL
22639 };
22640
22641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22643 if (SWIG_arg_fail(1)) SWIG_fail;
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22647
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 {
22652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22653 }
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22661 PyObject *resultobj = NULL;
22662 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22663 bool arg2 ;
22664 PyObject * obj0 = 0 ;
22665 PyObject * obj1 = 0 ;
22666 char *kwnames[] = {
22667 (char *) "self",(char *) "bIs", NULL
22668 };
22669
22670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 {
22674 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22675 if (SWIG_arg_fail(2)) SWIG_fail;
22676 }
22677 {
22678 PyThreadState* __tstate = wxPyBeginAllowThreads();
22679 (arg1)->SetFromTab(arg2);
22680
22681 wxPyEndAllowThreads(__tstate);
22682 if (PyErr_Occurred()) SWIG_fail;
22683 }
22684 Py_INCREF(Py_None); resultobj = Py_None;
22685 return resultobj;
22686 fail:
22687 return NULL;
22688 }
22689
22690
22691 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22692 PyObject *resultobj = NULL;
22693 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22694 long arg2 ;
22695 PyObject * obj0 = 0 ;
22696 PyObject * obj1 = 0 ;
22697 char *kwnames[] = {
22698 (char *) "self",(char *) "flags", NULL
22699 };
22700
22701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22703 if (SWIG_arg_fail(1)) SWIG_fail;
22704 {
22705 arg2 = static_cast<long >(SWIG_As_long(obj1));
22706 if (SWIG_arg_fail(2)) SWIG_fail;
22707 }
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 (arg1)->SetFlags(arg2);
22711
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 Py_INCREF(Py_None); resultobj = Py_None;
22716 return resultobj;
22717 fail:
22718 return NULL;
22719 }
22720
22721
22722 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22723 PyObject *resultobj = NULL;
22724 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22725 wxWindow *result;
22726 PyObject * obj0 = 0 ;
22727 char *kwnames[] = {
22728 (char *) "self", NULL
22729 };
22730
22731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22733 if (SWIG_arg_fail(1)) SWIG_fail;
22734 {
22735 PyThreadState* __tstate = wxPyBeginAllowThreads();
22736 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22737
22738 wxPyEndAllowThreads(__tstate);
22739 if (PyErr_Occurred()) SWIG_fail;
22740 }
22741 {
22742 resultobj = wxPyMake_wxObject(result, (bool)0);
22743 }
22744 return resultobj;
22745 fail:
22746 return NULL;
22747 }
22748
22749
22750 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22751 PyObject *resultobj = NULL;
22752 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22753 wxWindow *arg2 = (wxWindow *) 0 ;
22754 PyObject * obj0 = 0 ;
22755 PyObject * obj1 = 0 ;
22756 char *kwnames[] = {
22757 (char *) "self",(char *) "win", NULL
22758 };
22759
22760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22762 if (SWIG_arg_fail(1)) SWIG_fail;
22763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22764 if (SWIG_arg_fail(2)) SWIG_fail;
22765 {
22766 PyThreadState* __tstate = wxPyBeginAllowThreads();
22767 (arg1)->SetCurrentFocus(arg2);
22768
22769 wxPyEndAllowThreads(__tstate);
22770 if (PyErr_Occurred()) SWIG_fail;
22771 }
22772 Py_INCREF(Py_None); resultobj = Py_None;
22773 return resultobj;
22774 fail:
22775 return NULL;
22776 }
22777
22778
22779 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22780 PyObject *obj;
22781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22782 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22783 Py_INCREF(obj);
22784 return Py_BuildValue((char *)"");
22785 }
22786 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22787 PyObject *resultobj = NULL;
22788 wxWindow *arg1 = (wxWindow *) NULL ;
22789 wxWindowCreateEvent *result;
22790 PyObject * obj0 = 0 ;
22791 char *kwnames[] = {
22792 (char *) "win", NULL
22793 };
22794
22795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22796 if (obj0) {
22797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22798 if (SWIG_arg_fail(1)) SWIG_fail;
22799 }
22800 {
22801 PyThreadState* __tstate = wxPyBeginAllowThreads();
22802 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22803
22804 wxPyEndAllowThreads(__tstate);
22805 if (PyErr_Occurred()) SWIG_fail;
22806 }
22807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22808 return resultobj;
22809 fail:
22810 return NULL;
22811 }
22812
22813
22814 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22815 PyObject *resultobj = NULL;
22816 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22817 wxWindow *result;
22818 PyObject * obj0 = 0 ;
22819 char *kwnames[] = {
22820 (char *) "self", NULL
22821 };
22822
22823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22825 if (SWIG_arg_fail(1)) SWIG_fail;
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22829
22830 wxPyEndAllowThreads(__tstate);
22831 if (PyErr_Occurred()) SWIG_fail;
22832 }
22833 {
22834 resultobj = wxPyMake_wxObject(result, (bool)0);
22835 }
22836 return resultobj;
22837 fail:
22838 return NULL;
22839 }
22840
22841
22842 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22843 PyObject *obj;
22844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22845 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22846 Py_INCREF(obj);
22847 return Py_BuildValue((char *)"");
22848 }
22849 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22850 PyObject *resultobj = NULL;
22851 wxWindow *arg1 = (wxWindow *) NULL ;
22852 wxWindowDestroyEvent *result;
22853 PyObject * obj0 = 0 ;
22854 char *kwnames[] = {
22855 (char *) "win", NULL
22856 };
22857
22858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22859 if (obj0) {
22860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22861 if (SWIG_arg_fail(1)) SWIG_fail;
22862 }
22863 {
22864 PyThreadState* __tstate = wxPyBeginAllowThreads();
22865 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22866
22867 wxPyEndAllowThreads(__tstate);
22868 if (PyErr_Occurred()) SWIG_fail;
22869 }
22870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22871 return resultobj;
22872 fail:
22873 return NULL;
22874 }
22875
22876
22877 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22878 PyObject *resultobj = NULL;
22879 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22880 wxWindow *result;
22881 PyObject * obj0 = 0 ;
22882 char *kwnames[] = {
22883 (char *) "self", NULL
22884 };
22885
22886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22888 if (SWIG_arg_fail(1)) SWIG_fail;
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 {
22897 resultobj = wxPyMake_wxObject(result, (bool)0);
22898 }
22899 return resultobj;
22900 fail:
22901 return NULL;
22902 }
22903
22904
22905 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22906 PyObject *obj;
22907 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22908 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22909 Py_INCREF(obj);
22910 return Py_BuildValue((char *)"");
22911 }
22912 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22913 PyObject *resultobj = NULL;
22914 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22915 int arg2 = (int) 0 ;
22916 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22917 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22918 wxContextMenuEvent *result;
22919 wxPoint temp3 ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 PyObject * obj2 = 0 ;
22923 char *kwnames[] = {
22924 (char *) "type",(char *) "winid",(char *) "pt", NULL
22925 };
22926
22927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22928 if (obj0) {
22929 {
22930 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22931 if (SWIG_arg_fail(1)) SWIG_fail;
22932 }
22933 }
22934 if (obj1) {
22935 {
22936 arg2 = static_cast<int >(SWIG_As_int(obj1));
22937 if (SWIG_arg_fail(2)) SWIG_fail;
22938 }
22939 }
22940 if (obj2) {
22941 {
22942 arg3 = &temp3;
22943 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22944 }
22945 }
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22961 PyObject *resultobj = NULL;
22962 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22963 wxPoint *result;
22964 PyObject * obj0 = 0 ;
22965 char *kwnames[] = {
22966 (char *) "self", NULL
22967 };
22968
22969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22971 if (SWIG_arg_fail(1)) SWIG_fail;
22972 {
22973 PyThreadState* __tstate = wxPyBeginAllowThreads();
22974 {
22975 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22976 result = (wxPoint *) &_result_ref;
22977 }
22978
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22983 return resultobj;
22984 fail:
22985 return NULL;
22986 }
22987
22988
22989 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22990 PyObject *resultobj = NULL;
22991 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22992 wxPoint *arg2 = 0 ;
22993 wxPoint temp2 ;
22994 PyObject * obj0 = 0 ;
22995 PyObject * obj1 = 0 ;
22996 char *kwnames[] = {
22997 (char *) "self",(char *) "pos", NULL
22998 };
22999
23000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
23001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
23002 if (SWIG_arg_fail(1)) SWIG_fail;
23003 {
23004 arg2 = &temp2;
23005 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23006 }
23007 {
23008 PyThreadState* __tstate = wxPyBeginAllowThreads();
23009 (arg1)->SetPosition((wxPoint const &)*arg2);
23010
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 Py_INCREF(Py_None); resultobj = Py_None;
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
23022 PyObject *obj;
23023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23024 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
23025 Py_INCREF(obj);
23026 return Py_BuildValue((char *)"");
23027 }
23028 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23029 PyObject *resultobj = NULL;
23030 wxIdleEvent *result;
23031 char *kwnames[] = {
23032 NULL
23033 };
23034
23035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
23036 {
23037 PyThreadState* __tstate = wxPyBeginAllowThreads();
23038 result = (wxIdleEvent *)new wxIdleEvent();
23039
23040 wxPyEndAllowThreads(__tstate);
23041 if (PyErr_Occurred()) SWIG_fail;
23042 }
23043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
23044 return resultobj;
23045 fail:
23046 return NULL;
23047 }
23048
23049
23050 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
23051 PyObject *resultobj = NULL;
23052 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
23053 bool arg2 = (bool) true ;
23054 PyObject * obj0 = 0 ;
23055 PyObject * obj1 = 0 ;
23056 char *kwnames[] = {
23057 (char *) "self",(char *) "needMore", NULL
23058 };
23059
23060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
23061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23062 if (SWIG_arg_fail(1)) SWIG_fail;
23063 if (obj1) {
23064 {
23065 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23066 if (SWIG_arg_fail(2)) SWIG_fail;
23067 }
23068 }
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 (arg1)->RequestMore(arg2);
23072
23073 wxPyEndAllowThreads(__tstate);
23074 if (PyErr_Occurred()) SWIG_fail;
23075 }
23076 Py_INCREF(Py_None); resultobj = Py_None;
23077 return resultobj;
23078 fail:
23079 return NULL;
23080 }
23081
23082
23083 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
23084 PyObject *resultobj = NULL;
23085 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
23086 bool result;
23087 PyObject * obj0 = 0 ;
23088 char *kwnames[] = {
23089 (char *) "self", NULL
23090 };
23091
23092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
23093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23094 if (SWIG_arg_fail(1)) SWIG_fail;
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
23098
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 {
23103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23104 }
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
23112 PyObject *resultobj = NULL;
23113 wxIdleMode arg1 ;
23114 PyObject * obj0 = 0 ;
23115 char *kwnames[] = {
23116 (char *) "mode", NULL
23117 };
23118
23119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
23120 {
23121 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
23122 if (SWIG_arg_fail(1)) SWIG_fail;
23123 }
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 wxIdleEvent::SetMode(arg1);
23127
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 Py_INCREF(Py_None); resultobj = Py_None;
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj = NULL;
23140 wxIdleMode result;
23141 char *kwnames[] = {
23142 NULL
23143 };
23144
23145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
23146 {
23147 PyThreadState* __tstate = wxPyBeginAllowThreads();
23148 result = (wxIdleMode)wxIdleEvent::GetMode();
23149
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 resultobj = SWIG_From_int((result));
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj = NULL;
23162 wxWindow *arg1 = (wxWindow *) 0 ;
23163 bool result;
23164 PyObject * obj0 = 0 ;
23165 char *kwnames[] = {
23166 (char *) "win", NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)wxIdleEvent::CanSend(arg1);
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 {
23180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23181 }
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23189 PyObject *obj;
23190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23191 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23192 Py_INCREF(obj);
23193 return Py_BuildValue((char *)"");
23194 }
23195 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23196 PyObject *resultobj = NULL;
23197 int arg1 = (int) 0 ;
23198 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23199 wxPyEvent *result;
23200 PyObject * obj0 = 0 ;
23201 PyObject * obj1 = 0 ;
23202 char *kwnames[] = {
23203 (char *) "winid",(char *) "eventType", NULL
23204 };
23205
23206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23207 if (obj0) {
23208 {
23209 arg1 = static_cast<int >(SWIG_As_int(obj0));
23210 if (SWIG_arg_fail(1)) SWIG_fail;
23211 }
23212 }
23213 if (obj1) {
23214 {
23215 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23216 if (SWIG_arg_fail(2)) SWIG_fail;
23217 }
23218 }
23219 {
23220 PyThreadState* __tstate = wxPyBeginAllowThreads();
23221 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23222
23223 wxPyEndAllowThreads(__tstate);
23224 if (PyErr_Occurred()) SWIG_fail;
23225 }
23226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23234 PyObject *resultobj = NULL;
23235 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23236 PyObject * obj0 = 0 ;
23237 char *kwnames[] = {
23238 (char *) "self", NULL
23239 };
23240
23241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23243 if (SWIG_arg_fail(1)) SWIG_fail;
23244 {
23245 PyThreadState* __tstate = wxPyBeginAllowThreads();
23246 delete arg1;
23247
23248 wxPyEndAllowThreads(__tstate);
23249 if (PyErr_Occurred()) SWIG_fail;
23250 }
23251 Py_INCREF(Py_None); resultobj = Py_None;
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj = NULL;
23260 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23261 PyObject *arg2 = (PyObject *) 0 ;
23262 PyObject * obj0 = 0 ;
23263 PyObject * obj1 = 0 ;
23264 char *kwnames[] = {
23265 (char *) "self",(char *) "self", NULL
23266 };
23267
23268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23270 if (SWIG_arg_fail(1)) SWIG_fail;
23271 arg2 = obj1;
23272 {
23273 PyThreadState* __tstate = wxPyBeginAllowThreads();
23274 (arg1)->SetSelf(arg2);
23275
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 Py_INCREF(Py_None); resultobj = Py_None;
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj = NULL;
23288 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23289 PyObject *result;
23290 PyObject * obj0 = 0 ;
23291 char *kwnames[] = {
23292 (char *) "self", NULL
23293 };
23294
23295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23297 if (SWIG_arg_fail(1)) SWIG_fail;
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 result = (PyObject *)(arg1)->GetSelf();
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 resultobj = result;
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23313 PyObject *obj;
23314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23315 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23316 Py_INCREF(obj);
23317 return Py_BuildValue((char *)"");
23318 }
23319 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23320 PyObject *resultobj = NULL;
23321 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23322 int arg2 = (int) 0 ;
23323 wxPyCommandEvent *result;
23324 PyObject * obj0 = 0 ;
23325 PyObject * obj1 = 0 ;
23326 char *kwnames[] = {
23327 (char *) "eventType",(char *) "id", NULL
23328 };
23329
23330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23331 if (obj0) {
23332 {
23333 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23334 if (SWIG_arg_fail(1)) SWIG_fail;
23335 }
23336 }
23337 if (obj1) {
23338 {
23339 arg2 = static_cast<int >(SWIG_As_int(obj1));
23340 if (SWIG_arg_fail(2)) SWIG_fail;
23341 }
23342 }
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23346
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23351 return resultobj;
23352 fail:
23353 return NULL;
23354 }
23355
23356
23357 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23358 PyObject *resultobj = NULL;
23359 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23360 PyObject * obj0 = 0 ;
23361 char *kwnames[] = {
23362 (char *) "self", NULL
23363 };
23364
23365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23367 if (SWIG_arg_fail(1)) SWIG_fail;
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 delete arg1;
23371
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 Py_INCREF(Py_None); resultobj = Py_None;
23376 return resultobj;
23377 fail:
23378 return NULL;
23379 }
23380
23381
23382 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23383 PyObject *resultobj = NULL;
23384 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23385 PyObject *arg2 = (PyObject *) 0 ;
23386 PyObject * obj0 = 0 ;
23387 PyObject * obj1 = 0 ;
23388 char *kwnames[] = {
23389 (char *) "self",(char *) "self", NULL
23390 };
23391
23392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23394 if (SWIG_arg_fail(1)) SWIG_fail;
23395 arg2 = obj1;
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 (arg1)->SetSelf(arg2);
23399
23400 wxPyEndAllowThreads(__tstate);
23401 if (PyErr_Occurred()) SWIG_fail;
23402 }
23403 Py_INCREF(Py_None); resultobj = Py_None;
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23411 PyObject *resultobj = NULL;
23412 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23413 PyObject *result;
23414 PyObject * obj0 = 0 ;
23415 char *kwnames[] = {
23416 (char *) "self", NULL
23417 };
23418
23419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23421 if (SWIG_arg_fail(1)) SWIG_fail;
23422 {
23423 PyThreadState* __tstate = wxPyBeginAllowThreads();
23424 result = (PyObject *)(arg1)->GetSelf();
23425
23426 wxPyEndAllowThreads(__tstate);
23427 if (PyErr_Occurred()) SWIG_fail;
23428 }
23429 resultobj = result;
23430 return resultobj;
23431 fail:
23432 return NULL;
23433 }
23434
23435
23436 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23437 PyObject *obj;
23438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23439 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23440 Py_INCREF(obj);
23441 return Py_BuildValue((char *)"");
23442 }
23443 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23444 PyObject *resultobj = NULL;
23445 wxWindow *arg1 = (wxWindow *) 0 ;
23446 wxDateTime *arg2 = 0 ;
23447 wxEventType arg3 ;
23448 wxDateEvent *result;
23449 PyObject * obj0 = 0 ;
23450 PyObject * obj1 = 0 ;
23451 PyObject * obj2 = 0 ;
23452 char *kwnames[] = {
23453 (char *) "win",(char *) "dt",(char *) "type", NULL
23454 };
23455
23456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23458 if (SWIG_arg_fail(1)) SWIG_fail;
23459 {
23460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23461 if (SWIG_arg_fail(2)) SWIG_fail;
23462 if (arg2 == NULL) {
23463 SWIG_null_ref("wxDateTime");
23464 }
23465 if (SWIG_arg_fail(2)) SWIG_fail;
23466 }
23467 {
23468 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23469 if (SWIG_arg_fail(3)) SWIG_fail;
23470 }
23471 {
23472 PyThreadState* __tstate = wxPyBeginAllowThreads();
23473 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23474
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = NULL;
23487 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23488 wxDateTime *result;
23489 PyObject * obj0 = 0 ;
23490 char *kwnames[] = {
23491 (char *) "self", NULL
23492 };
23493
23494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23496 if (SWIG_arg_fail(1)) SWIG_fail;
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 {
23500 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23501 result = (wxDateTime *) &_result_ref;
23502 }
23503
23504 wxPyEndAllowThreads(__tstate);
23505 if (PyErr_Occurred()) SWIG_fail;
23506 }
23507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23508 return resultobj;
23509 fail:
23510 return NULL;
23511 }
23512
23513
23514 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23515 PyObject *resultobj = NULL;
23516 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23517 wxDateTime *arg2 = 0 ;
23518 PyObject * obj0 = 0 ;
23519 PyObject * obj1 = 0 ;
23520 char *kwnames[] = {
23521 (char *) "self",(char *) "date", NULL
23522 };
23523
23524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23526 if (SWIG_arg_fail(1)) SWIG_fail;
23527 {
23528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23529 if (SWIG_arg_fail(2)) SWIG_fail;
23530 if (arg2 == NULL) {
23531 SWIG_null_ref("wxDateTime");
23532 }
23533 if (SWIG_arg_fail(2)) SWIG_fail;
23534 }
23535 {
23536 PyThreadState* __tstate = wxPyBeginAllowThreads();
23537 (arg1)->SetDate((wxDateTime const &)*arg2);
23538
23539 wxPyEndAllowThreads(__tstate);
23540 if (PyErr_Occurred()) SWIG_fail;
23541 }
23542 Py_INCREF(Py_None); resultobj = Py_None;
23543 return resultobj;
23544 fail:
23545 return NULL;
23546 }
23547
23548
23549 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23550 PyObject *obj;
23551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23552 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23553 Py_INCREF(obj);
23554 return Py_BuildValue((char *)"");
23555 }
23556 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23557 PyObject *resultobj = NULL;
23558 wxPyApp *result;
23559 char *kwnames[] = {
23560 NULL
23561 };
23562
23563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23564 {
23565 PyThreadState* __tstate = wxPyBeginAllowThreads();
23566 result = (wxPyApp *)new_wxPyApp();
23567
23568 wxPyEndAllowThreads(__tstate);
23569 if (PyErr_Occurred()) SWIG_fail;
23570 }
23571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23572 return resultobj;
23573 fail:
23574 return NULL;
23575 }
23576
23577
23578 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23579 PyObject *resultobj = NULL;
23580 wxPyApp *arg1 = (wxPyApp *) 0 ;
23581 PyObject * obj0 = 0 ;
23582 char *kwnames[] = {
23583 (char *) "self", NULL
23584 };
23585
23586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23588 if (SWIG_arg_fail(1)) SWIG_fail;
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 delete arg1;
23592
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 Py_INCREF(Py_None); resultobj = Py_None;
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23604 PyObject *resultobj = NULL;
23605 wxPyApp *arg1 = (wxPyApp *) 0 ;
23606 PyObject *arg2 = (PyObject *) 0 ;
23607 PyObject *arg3 = (PyObject *) 0 ;
23608 bool arg4 ;
23609 PyObject * obj0 = 0 ;
23610 PyObject * obj1 = 0 ;
23611 PyObject * obj2 = 0 ;
23612 PyObject * obj3 = 0 ;
23613 char *kwnames[] = {
23614 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23615 };
23616
23617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23619 if (SWIG_arg_fail(1)) SWIG_fail;
23620 arg2 = obj1;
23621 arg3 = obj2;
23622 {
23623 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23624 if (SWIG_arg_fail(4)) SWIG_fail;
23625 }
23626 {
23627 PyThreadState* __tstate = wxPyBeginAllowThreads();
23628 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23629
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 Py_INCREF(Py_None); resultobj = Py_None;
23634 return resultobj;
23635 fail:
23636 return NULL;
23637 }
23638
23639
23640 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23641 PyObject *resultobj = NULL;
23642 wxPyApp *arg1 = (wxPyApp *) 0 ;
23643 wxString result;
23644 PyObject * obj0 = 0 ;
23645 char *kwnames[] = {
23646 (char *) "self", NULL
23647 };
23648
23649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23651 if (SWIG_arg_fail(1)) SWIG_fail;
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = ((wxPyApp const *)arg1)->GetAppName();
23655
23656 wxPyEndAllowThreads(__tstate);
23657 if (PyErr_Occurred()) SWIG_fail;
23658 }
23659 {
23660 #if wxUSE_UNICODE
23661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23662 #else
23663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23664 #endif
23665 }
23666 return resultobj;
23667 fail:
23668 return NULL;
23669 }
23670
23671
23672 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23673 PyObject *resultobj = NULL;
23674 wxPyApp *arg1 = (wxPyApp *) 0 ;
23675 wxString *arg2 = 0 ;
23676 bool temp2 = false ;
23677 PyObject * obj0 = 0 ;
23678 PyObject * obj1 = 0 ;
23679 char *kwnames[] = {
23680 (char *) "self",(char *) "name", NULL
23681 };
23682
23683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23685 if (SWIG_arg_fail(1)) SWIG_fail;
23686 {
23687 arg2 = wxString_in_helper(obj1);
23688 if (arg2 == NULL) SWIG_fail;
23689 temp2 = true;
23690 }
23691 {
23692 PyThreadState* __tstate = wxPyBeginAllowThreads();
23693 (arg1)->SetAppName((wxString const &)*arg2);
23694
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 Py_INCREF(Py_None); resultobj = Py_None;
23699 {
23700 if (temp2)
23701 delete arg2;
23702 }
23703 return resultobj;
23704 fail:
23705 {
23706 if (temp2)
23707 delete arg2;
23708 }
23709 return NULL;
23710 }
23711
23712
23713 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23714 PyObject *resultobj = NULL;
23715 wxPyApp *arg1 = (wxPyApp *) 0 ;
23716 wxString result;
23717 PyObject * obj0 = 0 ;
23718 char *kwnames[] = {
23719 (char *) "self", NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23724 if (SWIG_arg_fail(1)) SWIG_fail;
23725 {
23726 PyThreadState* __tstate = wxPyBeginAllowThreads();
23727 result = ((wxPyApp const *)arg1)->GetClassName();
23728
23729 wxPyEndAllowThreads(__tstate);
23730 if (PyErr_Occurred()) SWIG_fail;
23731 }
23732 {
23733 #if wxUSE_UNICODE
23734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23735 #else
23736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23737 #endif
23738 }
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23746 PyObject *resultobj = NULL;
23747 wxPyApp *arg1 = (wxPyApp *) 0 ;
23748 wxString *arg2 = 0 ;
23749 bool temp2 = false ;
23750 PyObject * obj0 = 0 ;
23751 PyObject * obj1 = 0 ;
23752 char *kwnames[] = {
23753 (char *) "self",(char *) "name", NULL
23754 };
23755
23756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23758 if (SWIG_arg_fail(1)) SWIG_fail;
23759 {
23760 arg2 = wxString_in_helper(obj1);
23761 if (arg2 == NULL) SWIG_fail;
23762 temp2 = true;
23763 }
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 (arg1)->SetClassName((wxString const &)*arg2);
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 Py_INCREF(Py_None); resultobj = Py_None;
23772 {
23773 if (temp2)
23774 delete arg2;
23775 }
23776 return resultobj;
23777 fail:
23778 {
23779 if (temp2)
23780 delete arg2;
23781 }
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj = NULL;
23788 wxPyApp *arg1 = (wxPyApp *) 0 ;
23789 wxString *result;
23790 PyObject * obj0 = 0 ;
23791 char *kwnames[] = {
23792 (char *) "self", NULL
23793 };
23794
23795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23797 if (SWIG_arg_fail(1)) SWIG_fail;
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 {
23801 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23802 result = (wxString *) &_result_ref;
23803 }
23804
23805 wxPyEndAllowThreads(__tstate);
23806 if (PyErr_Occurred()) SWIG_fail;
23807 }
23808 {
23809 #if wxUSE_UNICODE
23810 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23811 #else
23812 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23813 #endif
23814 }
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj = NULL;
23823 wxPyApp *arg1 = (wxPyApp *) 0 ;
23824 wxString *arg2 = 0 ;
23825 bool temp2 = false ;
23826 PyObject * obj0 = 0 ;
23827 PyObject * obj1 = 0 ;
23828 char *kwnames[] = {
23829 (char *) "self",(char *) "name", NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23834 if (SWIG_arg_fail(1)) SWIG_fail;
23835 {
23836 arg2 = wxString_in_helper(obj1);
23837 if (arg2 == NULL) SWIG_fail;
23838 temp2 = true;
23839 }
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 (arg1)->SetVendorName((wxString const &)*arg2);
23843
23844 wxPyEndAllowThreads(__tstate);
23845 if (PyErr_Occurred()) SWIG_fail;
23846 }
23847 Py_INCREF(Py_None); resultobj = Py_None;
23848 {
23849 if (temp2)
23850 delete arg2;
23851 }
23852 return resultobj;
23853 fail:
23854 {
23855 if (temp2)
23856 delete arg2;
23857 }
23858 return NULL;
23859 }
23860
23861
23862 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23863 PyObject *resultobj = NULL;
23864 wxPyApp *arg1 = (wxPyApp *) 0 ;
23865 wxAppTraits *result;
23866 PyObject * obj0 = 0 ;
23867 char *kwnames[] = {
23868 (char *) "self", NULL
23869 };
23870
23871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23873 if (SWIG_arg_fail(1)) SWIG_fail;
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = (wxAppTraits *)(arg1)->GetTraits();
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23889 PyObject *resultobj = NULL;
23890 wxPyApp *arg1 = (wxPyApp *) 0 ;
23891 PyObject * obj0 = 0 ;
23892 char *kwnames[] = {
23893 (char *) "self", NULL
23894 };
23895
23896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23898 if (SWIG_arg_fail(1)) SWIG_fail;
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 (arg1)->ProcessPendingEvents();
23902
23903 wxPyEndAllowThreads(__tstate);
23904 if (PyErr_Occurred()) SWIG_fail;
23905 }
23906 Py_INCREF(Py_None); resultobj = Py_None;
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj = NULL;
23915 wxPyApp *arg1 = (wxPyApp *) 0 ;
23916 bool arg2 = (bool) false ;
23917 bool result;
23918 PyObject * obj0 = 0 ;
23919 PyObject * obj1 = 0 ;
23920 char *kwnames[] = {
23921 (char *) "self",(char *) "onlyIfNeeded", NULL
23922 };
23923
23924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23926 if (SWIG_arg_fail(1)) SWIG_fail;
23927 if (obj1) {
23928 {
23929 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23930 if (SWIG_arg_fail(2)) SWIG_fail;
23931 }
23932 }
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = (bool)(arg1)->Yield(arg2);
23936
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 {
23941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23942 }
23943 return resultobj;
23944 fail:
23945 return NULL;
23946 }
23947
23948
23949 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23950 PyObject *resultobj = NULL;
23951 wxPyApp *arg1 = (wxPyApp *) 0 ;
23952 PyObject * obj0 = 0 ;
23953 char *kwnames[] = {
23954 (char *) "self", NULL
23955 };
23956
23957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23959 if (SWIG_arg_fail(1)) SWIG_fail;
23960 {
23961 PyThreadState* __tstate = wxPyBeginAllowThreads();
23962 (arg1)->WakeUpIdle();
23963
23964 wxPyEndAllowThreads(__tstate);
23965 if (PyErr_Occurred()) SWIG_fail;
23966 }
23967 Py_INCREF(Py_None); resultobj = Py_None;
23968 return resultobj;
23969 fail:
23970 return NULL;
23971 }
23972
23973
23974 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23975 PyObject *resultobj = NULL;
23976 bool result;
23977 char *kwnames[] = {
23978 NULL
23979 };
23980
23981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (bool)wxPyApp::IsMainLoopRunning();
23985
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 {
23990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23991 }
23992 return resultobj;
23993 fail:
23994 return NULL;
23995 }
23996
23997
23998 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj = NULL;
24000 wxPyApp *arg1 = (wxPyApp *) 0 ;
24001 int result;
24002 PyObject * obj0 = 0 ;
24003 char *kwnames[] = {
24004 (char *) "self", NULL
24005 };
24006
24007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
24008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24009 if (SWIG_arg_fail(1)) SWIG_fail;
24010 {
24011 PyThreadState* __tstate = wxPyBeginAllowThreads();
24012 result = (int)(arg1)->MainLoop();
24013
24014 wxPyEndAllowThreads(__tstate);
24015 if (PyErr_Occurred()) SWIG_fail;
24016 }
24017 {
24018 resultobj = SWIG_From_int(static_cast<int >(result));
24019 }
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj = NULL;
24028 wxPyApp *arg1 = (wxPyApp *) 0 ;
24029 PyObject * obj0 = 0 ;
24030 char *kwnames[] = {
24031 (char *) "self", NULL
24032 };
24033
24034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
24035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24036 if (SWIG_arg_fail(1)) SWIG_fail;
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 (arg1)->Exit();
24040
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 Py_INCREF(Py_None); resultobj = Py_None;
24045 return resultobj;
24046 fail:
24047 return NULL;
24048 }
24049
24050
24051 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24052 PyObject *resultobj = NULL;
24053 wxPyApp *arg1 = (wxPyApp *) 0 ;
24054 PyObject * obj0 = 0 ;
24055 char *kwnames[] = {
24056 (char *) "self", NULL
24057 };
24058
24059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
24060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24061 if (SWIG_arg_fail(1)) SWIG_fail;
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 (arg1)->ExitMainLoop();
24065
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 Py_INCREF(Py_None); resultobj = Py_None;
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj = NULL;
24078 wxPyApp *arg1 = (wxPyApp *) 0 ;
24079 bool result;
24080 PyObject * obj0 = 0 ;
24081 char *kwnames[] = {
24082 (char *) "self", NULL
24083 };
24084
24085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
24086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24087 if (SWIG_arg_fail(1)) SWIG_fail;
24088 {
24089 PyThreadState* __tstate = wxPyBeginAllowThreads();
24090 result = (bool)(arg1)->Pending();
24091
24092 wxPyEndAllowThreads(__tstate);
24093 if (PyErr_Occurred()) SWIG_fail;
24094 }
24095 {
24096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24097 }
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24105 PyObject *resultobj = NULL;
24106 wxPyApp *arg1 = (wxPyApp *) 0 ;
24107 bool result;
24108 PyObject * obj0 = 0 ;
24109 char *kwnames[] = {
24110 (char *) "self", NULL
24111 };
24112
24113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
24114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24115 if (SWIG_arg_fail(1)) SWIG_fail;
24116 {
24117 PyThreadState* __tstate = wxPyBeginAllowThreads();
24118 result = (bool)(arg1)->Dispatch();
24119
24120 wxPyEndAllowThreads(__tstate);
24121 if (PyErr_Occurred()) SWIG_fail;
24122 }
24123 {
24124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24125 }
24126 return resultobj;
24127 fail:
24128 return NULL;
24129 }
24130
24131
24132 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24133 PyObject *resultobj = NULL;
24134 wxPyApp *arg1 = (wxPyApp *) 0 ;
24135 bool result;
24136 PyObject * obj0 = 0 ;
24137 char *kwnames[] = {
24138 (char *) "self", NULL
24139 };
24140
24141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
24142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24143 if (SWIG_arg_fail(1)) SWIG_fail;
24144 {
24145 PyThreadState* __tstate = wxPyBeginAllowThreads();
24146 result = (bool)(arg1)->ProcessIdle();
24147
24148 wxPyEndAllowThreads(__tstate);
24149 if (PyErr_Occurred()) SWIG_fail;
24150 }
24151 {
24152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24153 }
24154 return resultobj;
24155 fail:
24156 return NULL;
24157 }
24158
24159
24160 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
24161 PyObject *resultobj = NULL;
24162 wxPyApp *arg1 = (wxPyApp *) 0 ;
24163 wxWindow *arg2 = (wxWindow *) 0 ;
24164 wxIdleEvent *arg3 = 0 ;
24165 bool result;
24166 PyObject * obj0 = 0 ;
24167 PyObject * obj1 = 0 ;
24168 PyObject * obj2 = 0 ;
24169 char *kwnames[] = {
24170 (char *) "self",(char *) "win",(char *) "event", NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
24174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(1)) SWIG_fail;
24176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24177 if (SWIG_arg_fail(2)) SWIG_fail;
24178 {
24179 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24180 if (SWIG_arg_fail(3)) SWIG_fail;
24181 if (arg3 == NULL) {
24182 SWIG_null_ref("wxIdleEvent");
24183 }
24184 if (SWIG_arg_fail(3)) SWIG_fail;
24185 }
24186 {
24187 PyThreadState* __tstate = wxPyBeginAllowThreads();
24188 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24189
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 {
24194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24195 }
24196 return resultobj;
24197 fail:
24198 return NULL;
24199 }
24200
24201
24202 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24203 PyObject *resultobj = NULL;
24204 wxPyApp *arg1 = (wxPyApp *) 0 ;
24205 bool result;
24206 PyObject * obj0 = 0 ;
24207 char *kwnames[] = {
24208 (char *) "self", NULL
24209 };
24210
24211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24213 if (SWIG_arg_fail(1)) SWIG_fail;
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 result = (bool)((wxPyApp const *)arg1)->IsActive();
24217
24218 wxPyEndAllowThreads(__tstate);
24219 if (PyErr_Occurred()) SWIG_fail;
24220 }
24221 {
24222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24223 }
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj = NULL;
24232 wxPyApp *arg1 = (wxPyApp *) 0 ;
24233 wxWindow *arg2 = (wxWindow *) 0 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 char *kwnames[] = {
24237 (char *) "self",(char *) "win", NULL
24238 };
24239
24240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24242 if (SWIG_arg_fail(1)) SWIG_fail;
24243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24244 if (SWIG_arg_fail(2)) SWIG_fail;
24245 {
24246 PyThreadState* __tstate = wxPyBeginAllowThreads();
24247 (arg1)->SetTopWindow(arg2);
24248
24249 wxPyEndAllowThreads(__tstate);
24250 if (PyErr_Occurred()) SWIG_fail;
24251 }
24252 Py_INCREF(Py_None); resultobj = Py_None;
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24260 PyObject *resultobj = NULL;
24261 wxPyApp *arg1 = (wxPyApp *) 0 ;
24262 wxWindow *result;
24263 PyObject * obj0 = 0 ;
24264 char *kwnames[] = {
24265 (char *) "self", NULL
24266 };
24267
24268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24270 if (SWIG_arg_fail(1)) SWIG_fail;
24271 {
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24274
24275 wxPyEndAllowThreads(__tstate);
24276 if (PyErr_Occurred()) SWIG_fail;
24277 }
24278 {
24279 resultobj = wxPyMake_wxObject(result, (bool)0);
24280 }
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24288 PyObject *resultobj = NULL;
24289 wxPyApp *arg1 = (wxPyApp *) 0 ;
24290 bool arg2 ;
24291 PyObject * obj0 = 0 ;
24292 PyObject * obj1 = 0 ;
24293 char *kwnames[] = {
24294 (char *) "self",(char *) "flag", NULL
24295 };
24296
24297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24299 if (SWIG_arg_fail(1)) SWIG_fail;
24300 {
24301 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24302 if (SWIG_arg_fail(2)) SWIG_fail;
24303 }
24304 {
24305 PyThreadState* __tstate = wxPyBeginAllowThreads();
24306 (arg1)->SetExitOnFrameDelete(arg2);
24307
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 Py_INCREF(Py_None); resultobj = Py_None;
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj = NULL;
24320 wxPyApp *arg1 = (wxPyApp *) 0 ;
24321 bool result;
24322 PyObject * obj0 = 0 ;
24323 char *kwnames[] = {
24324 (char *) "self", NULL
24325 };
24326
24327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24329 if (SWIG_arg_fail(1)) SWIG_fail;
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24333
24334 wxPyEndAllowThreads(__tstate);
24335 if (PyErr_Occurred()) SWIG_fail;
24336 }
24337 {
24338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24339 }
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24347 PyObject *resultobj = NULL;
24348 wxPyApp *arg1 = (wxPyApp *) 0 ;
24349 bool arg2 ;
24350 PyObject * obj0 = 0 ;
24351 PyObject * obj1 = 0 ;
24352 char *kwnames[] = {
24353 (char *) "self",(char *) "flag", NULL
24354 };
24355
24356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24358 if (SWIG_arg_fail(1)) SWIG_fail;
24359 {
24360 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24361 if (SWIG_arg_fail(2)) SWIG_fail;
24362 }
24363 {
24364 PyThreadState* __tstate = wxPyBeginAllowThreads();
24365 (arg1)->SetUseBestVisual(arg2);
24366
24367 wxPyEndAllowThreads(__tstate);
24368 if (PyErr_Occurred()) SWIG_fail;
24369 }
24370 Py_INCREF(Py_None); resultobj = Py_None;
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj = NULL;
24379 wxPyApp *arg1 = (wxPyApp *) 0 ;
24380 bool result;
24381 PyObject * obj0 = 0 ;
24382 char *kwnames[] = {
24383 (char *) "self", NULL
24384 };
24385
24386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24388 if (SWIG_arg_fail(1)) SWIG_fail;
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24392
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 {
24397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24398 }
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj = NULL;
24407 wxPyApp *arg1 = (wxPyApp *) 0 ;
24408 int arg2 ;
24409 PyObject * obj0 = 0 ;
24410 PyObject * obj1 = 0 ;
24411 char *kwnames[] = {
24412 (char *) "self",(char *) "mode", NULL
24413 };
24414
24415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24417 if (SWIG_arg_fail(1)) SWIG_fail;
24418 {
24419 arg2 = static_cast<int >(SWIG_As_int(obj1));
24420 if (SWIG_arg_fail(2)) SWIG_fail;
24421 }
24422 {
24423 PyThreadState* __tstate = wxPyBeginAllowThreads();
24424 (arg1)->SetPrintMode(arg2);
24425
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 Py_INCREF(Py_None); resultobj = Py_None;
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24437 PyObject *resultobj = NULL;
24438 wxPyApp *arg1 = (wxPyApp *) 0 ;
24439 int result;
24440 PyObject * obj0 = 0 ;
24441 char *kwnames[] = {
24442 (char *) "self", NULL
24443 };
24444
24445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24447 if (SWIG_arg_fail(1)) SWIG_fail;
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24451
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 {
24456 resultobj = SWIG_From_int(static_cast<int >(result));
24457 }
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24465 PyObject *resultobj = NULL;
24466 wxPyApp *arg1 = (wxPyApp *) 0 ;
24467 int arg2 ;
24468 PyObject * obj0 = 0 ;
24469 PyObject * obj1 = 0 ;
24470 char *kwnames[] = {
24471 (char *) "self",(char *) "mode", NULL
24472 };
24473
24474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24476 if (SWIG_arg_fail(1)) SWIG_fail;
24477 {
24478 arg2 = static_cast<int >(SWIG_As_int(obj1));
24479 if (SWIG_arg_fail(2)) SWIG_fail;
24480 }
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 (arg1)->SetAssertMode(arg2);
24484
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 Py_INCREF(Py_None); resultobj = Py_None;
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj = NULL;
24497 wxPyApp *arg1 = (wxPyApp *) 0 ;
24498 int result;
24499 PyObject * obj0 = 0 ;
24500 char *kwnames[] = {
24501 (char *) "self", NULL
24502 };
24503
24504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24506 if (SWIG_arg_fail(1)) SWIG_fail;
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = (int)(arg1)->GetAssertMode();
24510
24511 wxPyEndAllowThreads(__tstate);
24512 if (PyErr_Occurred()) SWIG_fail;
24513 }
24514 {
24515 resultobj = SWIG_From_int(static_cast<int >(result));
24516 }
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj = NULL;
24525 bool result;
24526 char *kwnames[] = {
24527 NULL
24528 };
24529
24530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24534
24535 wxPyEndAllowThreads(__tstate);
24536 if (PyErr_Occurred()) SWIG_fail;
24537 }
24538 {
24539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24540 }
24541 return resultobj;
24542 fail:
24543 return NULL;
24544 }
24545
24546
24547 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24548 PyObject *resultobj = NULL;
24549 long result;
24550 char *kwnames[] = {
24551 NULL
24552 };
24553
24554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24555 {
24556 PyThreadState* __tstate = wxPyBeginAllowThreads();
24557 result = (long)wxPyApp::GetMacAboutMenuItemId();
24558
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 {
24563 resultobj = SWIG_From_long(static_cast<long >(result));
24564 }
24565 return resultobj;
24566 fail:
24567 return NULL;
24568 }
24569
24570
24571 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24572 PyObject *resultobj = NULL;
24573 long result;
24574 char *kwnames[] = {
24575 NULL
24576 };
24577
24578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24579 {
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24582
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 {
24587 resultobj = SWIG_From_long(static_cast<long >(result));
24588 }
24589 return resultobj;
24590 fail:
24591 return NULL;
24592 }
24593
24594
24595 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24596 PyObject *resultobj = NULL;
24597 long result;
24598 char *kwnames[] = {
24599 NULL
24600 };
24601
24602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = (long)wxPyApp::GetMacExitMenuItemId();
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 {
24611 resultobj = SWIG_From_long(static_cast<long >(result));
24612 }
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24620 PyObject *resultobj = NULL;
24621 wxString result;
24622 char *kwnames[] = {
24623 NULL
24624 };
24625
24626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24627 {
24628 PyThreadState* __tstate = wxPyBeginAllowThreads();
24629 result = wxPyApp::GetMacHelpMenuTitleName();
24630
24631 wxPyEndAllowThreads(__tstate);
24632 if (PyErr_Occurred()) SWIG_fail;
24633 }
24634 {
24635 #if wxUSE_UNICODE
24636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24637 #else
24638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24639 #endif
24640 }
24641 return resultobj;
24642 fail:
24643 return NULL;
24644 }
24645
24646
24647 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24648 PyObject *resultobj = NULL;
24649 bool arg1 ;
24650 PyObject * obj0 = 0 ;
24651 char *kwnames[] = {
24652 (char *) "val", NULL
24653 };
24654
24655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24656 {
24657 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24658 if (SWIG_arg_fail(1)) SWIG_fail;
24659 }
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24663
24664 wxPyEndAllowThreads(__tstate);
24665 if (PyErr_Occurred()) SWIG_fail;
24666 }
24667 Py_INCREF(Py_None); resultobj = Py_None;
24668 return resultobj;
24669 fail:
24670 return NULL;
24671 }
24672
24673
24674 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24675 PyObject *resultobj = NULL;
24676 long arg1 ;
24677 PyObject * obj0 = 0 ;
24678 char *kwnames[] = {
24679 (char *) "val", NULL
24680 };
24681
24682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24683 {
24684 arg1 = static_cast<long >(SWIG_As_long(obj0));
24685 if (SWIG_arg_fail(1)) SWIG_fail;
24686 }
24687 {
24688 PyThreadState* __tstate = wxPyBeginAllowThreads();
24689 wxPyApp::SetMacAboutMenuItemId(arg1);
24690
24691 wxPyEndAllowThreads(__tstate);
24692 if (PyErr_Occurred()) SWIG_fail;
24693 }
24694 Py_INCREF(Py_None); resultobj = Py_None;
24695 return resultobj;
24696 fail:
24697 return NULL;
24698 }
24699
24700
24701 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24702 PyObject *resultobj = NULL;
24703 long arg1 ;
24704 PyObject * obj0 = 0 ;
24705 char *kwnames[] = {
24706 (char *) "val", NULL
24707 };
24708
24709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24710 {
24711 arg1 = static_cast<long >(SWIG_As_long(obj0));
24712 if (SWIG_arg_fail(1)) SWIG_fail;
24713 }
24714 {
24715 PyThreadState* __tstate = wxPyBeginAllowThreads();
24716 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24717
24718 wxPyEndAllowThreads(__tstate);
24719 if (PyErr_Occurred()) SWIG_fail;
24720 }
24721 Py_INCREF(Py_None); resultobj = Py_None;
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24729 PyObject *resultobj = NULL;
24730 long arg1 ;
24731 PyObject * obj0 = 0 ;
24732 char *kwnames[] = {
24733 (char *) "val", NULL
24734 };
24735
24736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24737 {
24738 arg1 = static_cast<long >(SWIG_As_long(obj0));
24739 if (SWIG_arg_fail(1)) SWIG_fail;
24740 }
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 wxPyApp::SetMacExitMenuItemId(arg1);
24744
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 Py_INCREF(Py_None); resultobj = Py_None;
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj = NULL;
24757 wxString *arg1 = 0 ;
24758 bool temp1 = false ;
24759 PyObject * obj0 = 0 ;
24760 char *kwnames[] = {
24761 (char *) "val", NULL
24762 };
24763
24764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24765 {
24766 arg1 = wxString_in_helper(obj0);
24767 if (arg1 == NULL) SWIG_fail;
24768 temp1 = true;
24769 }
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24773
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 Py_INCREF(Py_None); resultobj = Py_None;
24778 {
24779 if (temp1)
24780 delete arg1;
24781 }
24782 return resultobj;
24783 fail:
24784 {
24785 if (temp1)
24786 delete arg1;
24787 }
24788 return NULL;
24789 }
24790
24791
24792 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24793 PyObject *resultobj = NULL;
24794 wxPyApp *arg1 = (wxPyApp *) 0 ;
24795 PyObject * obj0 = 0 ;
24796 char *kwnames[] = {
24797 (char *) "self", NULL
24798 };
24799
24800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24802 if (SWIG_arg_fail(1)) SWIG_fail;
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 (arg1)->_BootstrapApp();
24806
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 Py_INCREF(Py_None); resultobj = Py_None;
24811 return resultobj;
24812 fail:
24813 return NULL;
24814 }
24815
24816
24817 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24818 PyObject *resultobj = NULL;
24819 int result;
24820 char *kwnames[] = {
24821 NULL
24822 };
24823
24824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24825 {
24826 PyThreadState* __tstate = wxPyBeginAllowThreads();
24827 result = (int)wxPyApp_GetComCtl32Version();
24828
24829 wxPyEndAllowThreads(__tstate);
24830 if (PyErr_Occurred()) SWIG_fail;
24831 }
24832 {
24833 resultobj = SWIG_From_int(static_cast<int >(result));
24834 }
24835 return resultobj;
24836 fail:
24837 return NULL;
24838 }
24839
24840
24841 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24842 PyObject *obj;
24843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24844 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24845 Py_INCREF(obj);
24846 return Py_BuildValue((char *)"");
24847 }
24848 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24849 PyObject *resultobj = NULL;
24850 char *kwnames[] = {
24851 NULL
24852 };
24853
24854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 wxExit();
24858
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 Py_INCREF(Py_None); resultobj = Py_None;
24863 return resultobj;
24864 fail:
24865 return NULL;
24866 }
24867
24868
24869 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24870 PyObject *resultobj = NULL;
24871 bool result;
24872 char *kwnames[] = {
24873 NULL
24874 };
24875
24876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (bool)wxYield();
24880
24881 wxPyEndAllowThreads(__tstate);
24882 if (PyErr_Occurred()) SWIG_fail;
24883 }
24884 {
24885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24886 }
24887 return resultobj;
24888 fail:
24889 return NULL;
24890 }
24891
24892
24893 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24894 PyObject *resultobj = NULL;
24895 bool result;
24896 char *kwnames[] = {
24897 NULL
24898 };
24899
24900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24901 {
24902 PyThreadState* __tstate = wxPyBeginAllowThreads();
24903 result = (bool)wxYieldIfNeeded();
24904
24905 wxPyEndAllowThreads(__tstate);
24906 if (PyErr_Occurred()) SWIG_fail;
24907 }
24908 {
24909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24910 }
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24918 PyObject *resultobj = NULL;
24919 wxWindow *arg1 = (wxWindow *) NULL ;
24920 bool arg2 = (bool) false ;
24921 bool result;
24922 PyObject * obj0 = 0 ;
24923 PyObject * obj1 = 0 ;
24924 char *kwnames[] = {
24925 (char *) "win",(char *) "onlyIfNeeded", NULL
24926 };
24927
24928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24929 if (obj0) {
24930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24931 if (SWIG_arg_fail(1)) SWIG_fail;
24932 }
24933 if (obj1) {
24934 {
24935 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24936 if (SWIG_arg_fail(2)) SWIG_fail;
24937 }
24938 }
24939 {
24940 PyThreadState* __tstate = wxPyBeginAllowThreads();
24941 result = (bool)wxSafeYield(arg1,arg2);
24942
24943 wxPyEndAllowThreads(__tstate);
24944 if (PyErr_Occurred()) SWIG_fail;
24945 }
24946 {
24947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24948 }
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24956 PyObject *resultobj = NULL;
24957 char *kwnames[] = {
24958 NULL
24959 };
24960
24961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 wxWakeUpIdle();
24965
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 Py_INCREF(Py_None); resultobj = Py_None;
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24977 PyObject *resultobj = NULL;
24978 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24979 wxEvent *arg2 = 0 ;
24980 PyObject * obj0 = 0 ;
24981 PyObject * obj1 = 0 ;
24982 char *kwnames[] = {
24983 (char *) "dest",(char *) "event", NULL
24984 };
24985
24986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24988 if (SWIG_arg_fail(1)) SWIG_fail;
24989 {
24990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24991 if (SWIG_arg_fail(2)) SWIG_fail;
24992 if (arg2 == NULL) {
24993 SWIG_null_ref("wxEvent");
24994 }
24995 if (SWIG_arg_fail(2)) SWIG_fail;
24996 }
24997 {
24998 PyThreadState* __tstate = wxPyBeginAllowThreads();
24999 wxPostEvent(arg1,*arg2);
25000
25001 wxPyEndAllowThreads(__tstate);
25002 if (PyErr_Occurred()) SWIG_fail;
25003 }
25004 Py_INCREF(Py_None); resultobj = Py_None;
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj = NULL;
25013 char *kwnames[] = {
25014 NULL
25015 };
25016
25017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 wxApp_CleanUp();
25021
25022 wxPyEndAllowThreads(__tstate);
25023 if (PyErr_Occurred()) SWIG_fail;
25024 }
25025 Py_INCREF(Py_None); resultobj = Py_None;
25026 return resultobj;
25027 fail:
25028 return NULL;
25029 }
25030
25031
25032 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
25033 PyObject *resultobj = NULL;
25034 wxPyApp *result;
25035 char *kwnames[] = {
25036 NULL
25037 };
25038
25039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
25040 {
25041 PyThreadState* __tstate = wxPyBeginAllowThreads();
25042 result = (wxPyApp *)wxPyGetApp();
25043
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 {
25048 resultobj = wxPyMake_wxObject(result, 0);
25049 }
25050 return resultobj;
25051 fail:
25052 return NULL;
25053 }
25054
25055
25056 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
25057 PyObject *resultobj = NULL;
25058 char *arg1 = (char *) 0 ;
25059 PyObject * obj0 = 0 ;
25060 char *kwnames[] = {
25061 (char *) "encoding", NULL
25062 };
25063
25064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
25065 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
25066 SWIG_arg_fail(1);SWIG_fail;
25067 }
25068 {
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 wxSetDefaultPyEncoding((char const *)arg1);
25071
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 Py_INCREF(Py_None); resultobj = Py_None;
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj = NULL;
25084 char *result;
25085 char *kwnames[] = {
25086 NULL
25087 };
25088
25089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 result = (char *)wxGetDefaultPyEncoding();
25093
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 resultobj = SWIG_FromCharPtr(result);
25098 return resultobj;
25099 fail:
25100 return NULL;
25101 }
25102
25103
25104 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
25105 PyObject *resultobj = NULL;
25106 wxEventLoop *result;
25107 char *kwnames[] = {
25108 NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 result = (wxEventLoop *)new wxEventLoop();
25115
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj = NULL;
25128 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25129 PyObject * obj0 = 0 ;
25130 char *kwnames[] = {
25131 (char *) "self", NULL
25132 };
25133
25134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
25135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25136 if (SWIG_arg_fail(1)) SWIG_fail;
25137 {
25138 PyThreadState* __tstate = wxPyBeginAllowThreads();
25139 delete arg1;
25140
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 Py_INCREF(Py_None); resultobj = Py_None;
25145 return resultobj;
25146 fail:
25147 return NULL;
25148 }
25149
25150
25151 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
25152 PyObject *resultobj = NULL;
25153 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25154 int result;
25155 PyObject * obj0 = 0 ;
25156 char *kwnames[] = {
25157 (char *) "self", NULL
25158 };
25159
25160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
25161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25162 if (SWIG_arg_fail(1)) SWIG_fail;
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 result = (int)(arg1)->Run();
25166
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 {
25171 resultobj = SWIG_From_int(static_cast<int >(result));
25172 }
25173 return resultobj;
25174 fail:
25175 return NULL;
25176 }
25177
25178
25179 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25180 PyObject *resultobj = NULL;
25181 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25182 int arg2 = (int) 0 ;
25183 PyObject * obj0 = 0 ;
25184 PyObject * obj1 = 0 ;
25185 char *kwnames[] = {
25186 (char *) "self",(char *) "rc", NULL
25187 };
25188
25189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25191 if (SWIG_arg_fail(1)) SWIG_fail;
25192 if (obj1) {
25193 {
25194 arg2 = static_cast<int >(SWIG_As_int(obj1));
25195 if (SWIG_arg_fail(2)) SWIG_fail;
25196 }
25197 }
25198 {
25199 PyThreadState* __tstate = wxPyBeginAllowThreads();
25200 (arg1)->Exit(arg2);
25201
25202 wxPyEndAllowThreads(__tstate);
25203 if (PyErr_Occurred()) SWIG_fail;
25204 }
25205 Py_INCREF(Py_None); resultobj = Py_None;
25206 return resultobj;
25207 fail:
25208 return NULL;
25209 }
25210
25211
25212 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25213 PyObject *resultobj = NULL;
25214 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25215 bool result;
25216 PyObject * obj0 = 0 ;
25217 char *kwnames[] = {
25218 (char *) "self", NULL
25219 };
25220
25221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25223 if (SWIG_arg_fail(1)) SWIG_fail;
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 result = (bool)((wxEventLoop const *)arg1)->Pending();
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 {
25232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25233 }
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25241 PyObject *resultobj = NULL;
25242 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25243 bool result;
25244 PyObject * obj0 = 0 ;
25245 char *kwnames[] = {
25246 (char *) "self", NULL
25247 };
25248
25249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25251 if (SWIG_arg_fail(1)) SWIG_fail;
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (bool)(arg1)->Dispatch();
25255
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 {
25260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25261 }
25262 return resultobj;
25263 fail:
25264 return NULL;
25265 }
25266
25267
25268 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25269 PyObject *resultobj = NULL;
25270 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25271 bool result;
25272 PyObject * obj0 = 0 ;
25273 char *kwnames[] = {
25274 (char *) "self", NULL
25275 };
25276
25277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25279 if (SWIG_arg_fail(1)) SWIG_fail;
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25283
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 {
25288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25289 }
25290 return resultobj;
25291 fail:
25292 return NULL;
25293 }
25294
25295
25296 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25297 PyObject *resultobj = NULL;
25298 wxEventLoop *result;
25299 char *kwnames[] = {
25300 NULL
25301 };
25302
25303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25304 {
25305 PyThreadState* __tstate = wxPyBeginAllowThreads();
25306 result = (wxEventLoop *)wxEventLoop::GetActive();
25307
25308 wxPyEndAllowThreads(__tstate);
25309 if (PyErr_Occurred()) SWIG_fail;
25310 }
25311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25319 PyObject *resultobj = NULL;
25320 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25321 PyObject * obj0 = 0 ;
25322 char *kwnames[] = {
25323 (char *) "loop", NULL
25324 };
25325
25326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25328 if (SWIG_arg_fail(1)) SWIG_fail;
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 wxEventLoop::SetActive(arg1);
25332
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 Py_INCREF(Py_None); resultobj = Py_None;
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25344 PyObject *obj;
25345 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25346 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25347 Py_INCREF(obj);
25348 return Py_BuildValue((char *)"");
25349 }
25350 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj = NULL;
25352 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25353 wxEventLoopActivator *result;
25354 PyObject * obj0 = 0 ;
25355 char *kwnames[] = {
25356 (char *) "evtLoop", NULL
25357 };
25358
25359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25361 if (SWIG_arg_fail(1)) SWIG_fail;
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25365
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25370 return resultobj;
25371 fail:
25372 return NULL;
25373 }
25374
25375
25376 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25377 PyObject *resultobj = NULL;
25378 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25379 PyObject * obj0 = 0 ;
25380 char *kwnames[] = {
25381 (char *) "self", NULL
25382 };
25383
25384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25386 if (SWIG_arg_fail(1)) SWIG_fail;
25387 {
25388 PyThreadState* __tstate = wxPyBeginAllowThreads();
25389 delete arg1;
25390
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 Py_INCREF(Py_None); resultobj = Py_None;
25395 return resultobj;
25396 fail:
25397 return NULL;
25398 }
25399
25400
25401 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25402 PyObject *obj;
25403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25404 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25405 Py_INCREF(obj);
25406 return Py_BuildValue((char *)"");
25407 }
25408 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25409 PyObject *resultobj = NULL;
25410 int arg1 = (int) 0 ;
25411 int arg2 = (int) 0 ;
25412 int arg3 = (int) 0 ;
25413 wxAcceleratorEntry *result;
25414 PyObject * obj0 = 0 ;
25415 PyObject * obj1 = 0 ;
25416 PyObject * obj2 = 0 ;
25417 char *kwnames[] = {
25418 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25419 };
25420
25421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25422 if (obj0) {
25423 {
25424 arg1 = static_cast<int >(SWIG_As_int(obj0));
25425 if (SWIG_arg_fail(1)) SWIG_fail;
25426 }
25427 }
25428 if (obj1) {
25429 {
25430 arg2 = static_cast<int >(SWIG_As_int(obj1));
25431 if (SWIG_arg_fail(2)) SWIG_fail;
25432 }
25433 }
25434 if (obj2) {
25435 {
25436 arg3 = static_cast<int >(SWIG_As_int(obj2));
25437 if (SWIG_arg_fail(3)) SWIG_fail;
25438 }
25439 }
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25443
25444 wxPyEndAllowThreads(__tstate);
25445 if (PyErr_Occurred()) SWIG_fail;
25446 }
25447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25455 PyObject *resultobj = NULL;
25456 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25457 PyObject * obj0 = 0 ;
25458 char *kwnames[] = {
25459 (char *) "self", NULL
25460 };
25461
25462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25464 if (SWIG_arg_fail(1)) SWIG_fail;
25465 {
25466 PyThreadState* __tstate = wxPyBeginAllowThreads();
25467 delete arg1;
25468
25469 wxPyEndAllowThreads(__tstate);
25470 if (PyErr_Occurred()) SWIG_fail;
25471 }
25472 Py_INCREF(Py_None); resultobj = Py_None;
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj = NULL;
25481 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25482 int arg2 ;
25483 int arg3 ;
25484 int arg4 ;
25485 PyObject * obj0 = 0 ;
25486 PyObject * obj1 = 0 ;
25487 PyObject * obj2 = 0 ;
25488 PyObject * obj3 = 0 ;
25489 char *kwnames[] = {
25490 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25491 };
25492
25493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25495 if (SWIG_arg_fail(1)) SWIG_fail;
25496 {
25497 arg2 = static_cast<int >(SWIG_As_int(obj1));
25498 if (SWIG_arg_fail(2)) SWIG_fail;
25499 }
25500 {
25501 arg3 = static_cast<int >(SWIG_As_int(obj2));
25502 if (SWIG_arg_fail(3)) SWIG_fail;
25503 }
25504 {
25505 arg4 = static_cast<int >(SWIG_As_int(obj3));
25506 if (SWIG_arg_fail(4)) SWIG_fail;
25507 }
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 (arg1)->Set(arg2,arg3,arg4);
25511
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 Py_INCREF(Py_None); resultobj = Py_None;
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj = NULL;
25524 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25525 int result;
25526 PyObject * obj0 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 {
25535 PyThreadState* __tstate = wxPyBeginAllowThreads();
25536 result = (int)(arg1)->GetFlags();
25537
25538 wxPyEndAllowThreads(__tstate);
25539 if (PyErr_Occurred()) SWIG_fail;
25540 }
25541 {
25542 resultobj = SWIG_From_int(static_cast<int >(result));
25543 }
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25551 PyObject *resultobj = NULL;
25552 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25553 int result;
25554 PyObject * obj0 = 0 ;
25555 char *kwnames[] = {
25556 (char *) "self", NULL
25557 };
25558
25559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25561 if (SWIG_arg_fail(1)) SWIG_fail;
25562 {
25563 PyThreadState* __tstate = wxPyBeginAllowThreads();
25564 result = (int)(arg1)->GetKeyCode();
25565
25566 wxPyEndAllowThreads(__tstate);
25567 if (PyErr_Occurred()) SWIG_fail;
25568 }
25569 {
25570 resultobj = SWIG_From_int(static_cast<int >(result));
25571 }
25572 return resultobj;
25573 fail:
25574 return NULL;
25575 }
25576
25577
25578 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25579 PyObject *resultobj = NULL;
25580 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25581 int result;
25582 PyObject * obj0 = 0 ;
25583 char *kwnames[] = {
25584 (char *) "self", NULL
25585 };
25586
25587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25589 if (SWIG_arg_fail(1)) SWIG_fail;
25590 {
25591 PyThreadState* __tstate = wxPyBeginAllowThreads();
25592 result = (int)(arg1)->GetCommand();
25593
25594 wxPyEndAllowThreads(__tstate);
25595 if (PyErr_Occurred()) SWIG_fail;
25596 }
25597 {
25598 resultobj = SWIG_From_int(static_cast<int >(result));
25599 }
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25607 PyObject *obj;
25608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25609 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25610 Py_INCREF(obj);
25611 return Py_BuildValue((char *)"");
25612 }
25613 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25614 PyObject *resultobj = NULL;
25615 int arg1 ;
25616 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25617 wxAcceleratorTable *result;
25618 PyObject * obj0 = 0 ;
25619 char *kwnames[] = {
25620 (char *) "n", NULL
25621 };
25622
25623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25624 {
25625 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25626 if (arg2) arg1 = PyList_Size(obj0);
25627 else arg1 = 0;
25628 }
25629 {
25630 PyThreadState* __tstate = wxPyBeginAllowThreads();
25631 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25632
25633 wxPyEndAllowThreads(__tstate);
25634 if (PyErr_Occurred()) SWIG_fail;
25635 }
25636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25637 {
25638 delete [] arg2;
25639 }
25640 return resultobj;
25641 fail:
25642 {
25643 delete [] arg2;
25644 }
25645 return NULL;
25646 }
25647
25648
25649 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25650 PyObject *resultobj = NULL;
25651 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25652 PyObject * obj0 = 0 ;
25653 char *kwnames[] = {
25654 (char *) "self", NULL
25655 };
25656
25657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25659 if (SWIG_arg_fail(1)) SWIG_fail;
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 delete arg1;
25663
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 Py_INCREF(Py_None); resultobj = Py_None;
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25675 PyObject *resultobj = NULL;
25676 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25677 bool result;
25678 PyObject * obj0 = 0 ;
25679 char *kwnames[] = {
25680 (char *) "self", NULL
25681 };
25682
25683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25685 if (SWIG_arg_fail(1)) SWIG_fail;
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25689
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 {
25694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25695 }
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25703 PyObject *obj;
25704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25705 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25706 Py_INCREF(obj);
25707 return Py_BuildValue((char *)"");
25708 }
25709 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25710 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25711 return 1;
25712 }
25713
25714
25715 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25716 PyObject *pyobj = NULL;
25717
25718 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25719 return pyobj;
25720 }
25721
25722
25723 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25724 PyObject *resultobj = NULL;
25725 wxString *arg1 = 0 ;
25726 wxAcceleratorEntry *result;
25727 bool temp1 = false ;
25728 PyObject * obj0 = 0 ;
25729 char *kwnames[] = {
25730 (char *) "label", NULL
25731 };
25732
25733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25734 {
25735 arg1 = wxString_in_helper(obj0);
25736 if (arg1 == NULL) SWIG_fail;
25737 temp1 = true;
25738 }
25739 {
25740 PyThreadState* __tstate = wxPyBeginAllowThreads();
25741 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25742
25743 wxPyEndAllowThreads(__tstate);
25744 if (PyErr_Occurred()) SWIG_fail;
25745 }
25746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25747 {
25748 if (temp1)
25749 delete arg1;
25750 }
25751 return resultobj;
25752 fail:
25753 {
25754 if (temp1)
25755 delete arg1;
25756 }
25757 return NULL;
25758 }
25759
25760
25761 static int _wrap_PanelNameStr_set(PyObject *) {
25762 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25763 return 1;
25764 }
25765
25766
25767 static PyObject *_wrap_PanelNameStr_get(void) {
25768 PyObject *pyobj = NULL;
25769
25770 {
25771 #if wxUSE_UNICODE
25772 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25773 #else
25774 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25775 #endif
25776 }
25777 return pyobj;
25778 }
25779
25780
25781 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25782 PyObject *resultobj = NULL;
25783 wxVisualAttributes *result;
25784 char *kwnames[] = {
25785 NULL
25786 };
25787
25788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 result = (wxVisualAttributes *)new_wxVisualAttributes();
25792
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25797 return resultobj;
25798 fail:
25799 return NULL;
25800 }
25801
25802
25803 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25804 PyObject *resultobj = NULL;
25805 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25806 PyObject * obj0 = 0 ;
25807 char *kwnames[] = {
25808 (char *) "self", NULL
25809 };
25810
25811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25813 if (SWIG_arg_fail(1)) SWIG_fail;
25814 {
25815 PyThreadState* __tstate = wxPyBeginAllowThreads();
25816 delete_wxVisualAttributes(arg1);
25817
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 Py_INCREF(Py_None); resultobj = Py_None;
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj = NULL;
25830 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25831 wxFont *arg2 = (wxFont *) 0 ;
25832 PyObject * obj0 = 0 ;
25833 PyObject * obj1 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self",(char *) "font", NULL
25836 };
25837
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25842 if (SWIG_arg_fail(2)) SWIG_fail;
25843 if (arg1) (arg1)->font = *arg2;
25844
25845 Py_INCREF(Py_None); resultobj = Py_None;
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25853 PyObject *resultobj = NULL;
25854 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25855 wxFont *result;
25856 PyObject * obj0 = 0 ;
25857 char *kwnames[] = {
25858 (char *) "self", NULL
25859 };
25860
25861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25863 if (SWIG_arg_fail(1)) SWIG_fail;
25864 result = (wxFont *)& ((arg1)->font);
25865
25866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25867 return resultobj;
25868 fail:
25869 return NULL;
25870 }
25871
25872
25873 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25874 PyObject *resultobj = NULL;
25875 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25876 wxColour *arg2 = (wxColour *) 0 ;
25877 PyObject * obj0 = 0 ;
25878 PyObject * obj1 = 0 ;
25879 char *kwnames[] = {
25880 (char *) "self",(char *) "colFg", NULL
25881 };
25882
25883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25885 if (SWIG_arg_fail(1)) SWIG_fail;
25886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25887 if (SWIG_arg_fail(2)) SWIG_fail;
25888 if (arg1) (arg1)->colFg = *arg2;
25889
25890 Py_INCREF(Py_None); resultobj = Py_None;
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25898 PyObject *resultobj = NULL;
25899 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25900 wxColour *result;
25901 PyObject * obj0 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 result = (wxColour *)& ((arg1)->colFg);
25910
25911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj = NULL;
25920 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25921 wxColour *arg2 = (wxColour *) 0 ;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 char *kwnames[] = {
25925 (char *) "self",(char *) "colBg", NULL
25926 };
25927
25928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25930 if (SWIG_arg_fail(1)) SWIG_fail;
25931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(2)) SWIG_fail;
25933 if (arg1) (arg1)->colBg = *arg2;
25934
25935 Py_INCREF(Py_None); resultobj = Py_None;
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj = NULL;
25944 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25945 wxColour *result;
25946 PyObject * obj0 = 0 ;
25947 char *kwnames[] = {
25948 (char *) "self", NULL
25949 };
25950
25951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25953 if (SWIG_arg_fail(1)) SWIG_fail;
25954 result = (wxColour *)& ((arg1)->colBg);
25955
25956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25957 return resultobj;
25958 fail:
25959 return NULL;
25960 }
25961
25962
25963 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25964 PyObject *obj;
25965 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25966 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25967 Py_INCREF(obj);
25968 return Py_BuildValue((char *)"");
25969 }
25970 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25971 PyObject *resultobj = NULL;
25972 wxWindow *arg1 = (wxWindow *) 0 ;
25973 int arg2 = (int) (int)-1 ;
25974 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25975 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25976 wxSize const &arg4_defvalue = wxDefaultSize ;
25977 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25978 long arg5 = (long) 0 ;
25979 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25980 wxString *arg6 = (wxString *) &arg6_defvalue ;
25981 wxWindow *result;
25982 wxPoint temp3 ;
25983 wxSize temp4 ;
25984 bool temp6 = false ;
25985 PyObject * obj0 = 0 ;
25986 PyObject * obj1 = 0 ;
25987 PyObject * obj2 = 0 ;
25988 PyObject * obj3 = 0 ;
25989 PyObject * obj4 = 0 ;
25990 PyObject * obj5 = 0 ;
25991 char *kwnames[] = {
25992 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25993 };
25994
25995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25997 if (SWIG_arg_fail(1)) SWIG_fail;
25998 if (obj1) {
25999 {
26000 arg2 = static_cast<int const >(SWIG_As_int(obj1));
26001 if (SWIG_arg_fail(2)) SWIG_fail;
26002 }
26003 }
26004 if (obj2) {
26005 {
26006 arg3 = &temp3;
26007 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26008 }
26009 }
26010 if (obj3) {
26011 {
26012 arg4 = &temp4;
26013 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26014 }
26015 }
26016 if (obj4) {
26017 {
26018 arg5 = static_cast<long >(SWIG_As_long(obj4));
26019 if (SWIG_arg_fail(5)) SWIG_fail;
26020 }
26021 }
26022 if (obj5) {
26023 {
26024 arg6 = wxString_in_helper(obj5);
26025 if (arg6 == NULL) SWIG_fail;
26026 temp6 = true;
26027 }
26028 }
26029 {
26030 if (!wxPyCheckForApp()) SWIG_fail;
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
26033
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
26038 {
26039 if (temp6)
26040 delete arg6;
26041 }
26042 return resultobj;
26043 fail:
26044 {
26045 if (temp6)
26046 delete arg6;
26047 }
26048 return NULL;
26049 }
26050
26051
26052 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
26053 PyObject *resultobj = NULL;
26054 wxWindow *result;
26055 char *kwnames[] = {
26056 NULL
26057 };
26058
26059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
26060 {
26061 if (!wxPyCheckForApp()) SWIG_fail;
26062 PyThreadState* __tstate = wxPyBeginAllowThreads();
26063 result = (wxWindow *)new wxWindow();
26064
26065 wxPyEndAllowThreads(__tstate);
26066 if (PyErr_Occurred()) SWIG_fail;
26067 }
26068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
26069 return resultobj;
26070 fail:
26071 return NULL;
26072 }
26073
26074
26075 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
26076 PyObject *resultobj = NULL;
26077 wxWindow *arg1 = (wxWindow *) 0 ;
26078 wxWindow *arg2 = (wxWindow *) 0 ;
26079 int arg3 = (int) (int)-1 ;
26080 wxPoint const &arg4_defvalue = wxDefaultPosition ;
26081 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
26082 wxSize const &arg5_defvalue = wxDefaultSize ;
26083 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
26084 long arg6 = (long) 0 ;
26085 wxString const &arg7_defvalue = wxPyPanelNameStr ;
26086 wxString *arg7 = (wxString *) &arg7_defvalue ;
26087 bool result;
26088 wxPoint temp4 ;
26089 wxSize temp5 ;
26090 bool temp7 = false ;
26091 PyObject * obj0 = 0 ;
26092 PyObject * obj1 = 0 ;
26093 PyObject * obj2 = 0 ;
26094 PyObject * obj3 = 0 ;
26095 PyObject * obj4 = 0 ;
26096 PyObject * obj5 = 0 ;
26097 PyObject * obj6 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
26100 };
26101
26102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26104 if (SWIG_arg_fail(1)) SWIG_fail;
26105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26106 if (SWIG_arg_fail(2)) SWIG_fail;
26107 if (obj2) {
26108 {
26109 arg3 = static_cast<int const >(SWIG_As_int(obj2));
26110 if (SWIG_arg_fail(3)) SWIG_fail;
26111 }
26112 }
26113 if (obj3) {
26114 {
26115 arg4 = &temp4;
26116 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
26117 }
26118 }
26119 if (obj4) {
26120 {
26121 arg5 = &temp5;
26122 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
26123 }
26124 }
26125 if (obj5) {
26126 {
26127 arg6 = static_cast<long >(SWIG_As_long(obj5));
26128 if (SWIG_arg_fail(6)) SWIG_fail;
26129 }
26130 }
26131 if (obj6) {
26132 {
26133 arg7 = wxString_in_helper(obj6);
26134 if (arg7 == NULL) SWIG_fail;
26135 temp7 = true;
26136 }
26137 }
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
26141
26142 wxPyEndAllowThreads(__tstate);
26143 if (PyErr_Occurred()) SWIG_fail;
26144 }
26145 {
26146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26147 }
26148 {
26149 if (temp7)
26150 delete arg7;
26151 }
26152 return resultobj;
26153 fail:
26154 {
26155 if (temp7)
26156 delete arg7;
26157 }
26158 return NULL;
26159 }
26160
26161
26162 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
26163 PyObject *resultobj = NULL;
26164 wxWindow *arg1 = (wxWindow *) 0 ;
26165 bool arg2 = (bool) false ;
26166 bool result;
26167 PyObject * obj0 = 0 ;
26168 PyObject * obj1 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self",(char *) "force", NULL
26171 };
26172
26173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26175 if (SWIG_arg_fail(1)) SWIG_fail;
26176 if (obj1) {
26177 {
26178 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26179 if (SWIG_arg_fail(2)) SWIG_fail;
26180 }
26181 }
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = (bool)(arg1)->Close(arg2);
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 {
26190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26191 }
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26199 PyObject *resultobj = NULL;
26200 wxWindow *arg1 = (wxWindow *) 0 ;
26201 bool result;
26202 PyObject * obj0 = 0 ;
26203 char *kwnames[] = {
26204 (char *) "self", NULL
26205 };
26206
26207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26209 if (SWIG_arg_fail(1)) SWIG_fail;
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 result = (bool)(arg1)->Destroy();
26213
26214 wxPyEndAllowThreads(__tstate);
26215 if (PyErr_Occurred()) SWIG_fail;
26216 }
26217 {
26218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26219 }
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26227 PyObject *resultobj = NULL;
26228 wxWindow *arg1 = (wxWindow *) 0 ;
26229 bool result;
26230 PyObject * obj0 = 0 ;
26231 char *kwnames[] = {
26232 (char *) "self", NULL
26233 };
26234
26235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26237 if (SWIG_arg_fail(1)) SWIG_fail;
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (bool)(arg1)->DestroyChildren();
26241
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 {
26246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26247 }
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26255 PyObject *resultobj = NULL;
26256 wxWindow *arg1 = (wxWindow *) 0 ;
26257 bool result;
26258 PyObject * obj0 = 0 ;
26259 char *kwnames[] = {
26260 (char *) "self", NULL
26261 };
26262
26263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26265 if (SWIG_arg_fail(1)) SWIG_fail;
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26269
26270 wxPyEndAllowThreads(__tstate);
26271 if (PyErr_Occurred()) SWIG_fail;
26272 }
26273 {
26274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26275 }
26276 return resultobj;
26277 fail:
26278 return NULL;
26279 }
26280
26281
26282 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26283 PyObject *resultobj = NULL;
26284 wxWindow *arg1 = (wxWindow *) 0 ;
26285 wxString *arg2 = 0 ;
26286 bool temp2 = false ;
26287 PyObject * obj0 = 0 ;
26288 PyObject * obj1 = 0 ;
26289 char *kwnames[] = {
26290 (char *) "self",(char *) "label", NULL
26291 };
26292
26293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26295 if (SWIG_arg_fail(1)) SWIG_fail;
26296 {
26297 arg2 = wxString_in_helper(obj1);
26298 if (arg2 == NULL) SWIG_fail;
26299 temp2 = true;
26300 }
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 (arg1)->SetLabel((wxString const &)*arg2);
26304
26305 wxPyEndAllowThreads(__tstate);
26306 if (PyErr_Occurred()) SWIG_fail;
26307 }
26308 Py_INCREF(Py_None); resultobj = Py_None;
26309 {
26310 if (temp2)
26311 delete arg2;
26312 }
26313 return resultobj;
26314 fail:
26315 {
26316 if (temp2)
26317 delete arg2;
26318 }
26319 return NULL;
26320 }
26321
26322
26323 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj = NULL;
26325 wxWindow *arg1 = (wxWindow *) 0 ;
26326 wxString result;
26327 PyObject * obj0 = 0 ;
26328 char *kwnames[] = {
26329 (char *) "self", NULL
26330 };
26331
26332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26334 if (SWIG_arg_fail(1)) SWIG_fail;
26335 {
26336 PyThreadState* __tstate = wxPyBeginAllowThreads();
26337 result = ((wxWindow const *)arg1)->GetLabel();
26338
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 {
26343 #if wxUSE_UNICODE
26344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26345 #else
26346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26347 #endif
26348 }
26349 return resultobj;
26350 fail:
26351 return NULL;
26352 }
26353
26354
26355 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26356 PyObject *resultobj = NULL;
26357 wxWindow *arg1 = (wxWindow *) 0 ;
26358 wxString *arg2 = 0 ;
26359 bool temp2 = false ;
26360 PyObject * obj0 = 0 ;
26361 PyObject * obj1 = 0 ;
26362 char *kwnames[] = {
26363 (char *) "self",(char *) "name", NULL
26364 };
26365
26366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26368 if (SWIG_arg_fail(1)) SWIG_fail;
26369 {
26370 arg2 = wxString_in_helper(obj1);
26371 if (arg2 == NULL) SWIG_fail;
26372 temp2 = true;
26373 }
26374 {
26375 PyThreadState* __tstate = wxPyBeginAllowThreads();
26376 (arg1)->SetName((wxString const &)*arg2);
26377
26378 wxPyEndAllowThreads(__tstate);
26379 if (PyErr_Occurred()) SWIG_fail;
26380 }
26381 Py_INCREF(Py_None); resultobj = Py_None;
26382 {
26383 if (temp2)
26384 delete arg2;
26385 }
26386 return resultobj;
26387 fail:
26388 {
26389 if (temp2)
26390 delete arg2;
26391 }
26392 return NULL;
26393 }
26394
26395
26396 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26397 PyObject *resultobj = NULL;
26398 wxWindow *arg1 = (wxWindow *) 0 ;
26399 wxString result;
26400 PyObject * obj0 = 0 ;
26401 char *kwnames[] = {
26402 (char *) "self", NULL
26403 };
26404
26405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26407 if (SWIG_arg_fail(1)) SWIG_fail;
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 result = ((wxWindow const *)arg1)->GetName();
26411
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 {
26416 #if wxUSE_UNICODE
26417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26418 #else
26419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26420 #endif
26421 }
26422 return resultobj;
26423 fail:
26424 return NULL;
26425 }
26426
26427
26428 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26429 PyObject *resultobj = NULL;
26430 wxWindow *arg1 = (wxWindow *) 0 ;
26431 wxWindowVariant arg2 ;
26432 PyObject * obj0 = 0 ;
26433 PyObject * obj1 = 0 ;
26434 char *kwnames[] = {
26435 (char *) "self",(char *) "variant", NULL
26436 };
26437
26438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26440 if (SWIG_arg_fail(1)) SWIG_fail;
26441 {
26442 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26443 if (SWIG_arg_fail(2)) SWIG_fail;
26444 }
26445 {
26446 PyThreadState* __tstate = wxPyBeginAllowThreads();
26447 (arg1)->SetWindowVariant(arg2);
26448
26449 wxPyEndAllowThreads(__tstate);
26450 if (PyErr_Occurred()) SWIG_fail;
26451 }
26452 Py_INCREF(Py_None); resultobj = Py_None;
26453 return resultobj;
26454 fail:
26455 return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26460 PyObject *resultobj = NULL;
26461 wxWindow *arg1 = (wxWindow *) 0 ;
26462 wxWindowVariant result;
26463 PyObject * obj0 = 0 ;
26464 char *kwnames[] = {
26465 (char *) "self", NULL
26466 };
26467
26468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26470 if (SWIG_arg_fail(1)) SWIG_fail;
26471 {
26472 PyThreadState* __tstate = wxPyBeginAllowThreads();
26473 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26474
26475 wxPyEndAllowThreads(__tstate);
26476 if (PyErr_Occurred()) SWIG_fail;
26477 }
26478 resultobj = SWIG_From_int((result));
26479 return resultobj;
26480 fail:
26481 return NULL;
26482 }
26483
26484
26485 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26486 PyObject *resultobj = NULL;
26487 wxWindow *arg1 = (wxWindow *) 0 ;
26488 int arg2 ;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491 char *kwnames[] = {
26492 (char *) "self",(char *) "winid", NULL
26493 };
26494
26495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26497 if (SWIG_arg_fail(1)) SWIG_fail;
26498 {
26499 arg2 = static_cast<int >(SWIG_As_int(obj1));
26500 if (SWIG_arg_fail(2)) SWIG_fail;
26501 }
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 (arg1)->SetId(arg2);
26505
26506 wxPyEndAllowThreads(__tstate);
26507 if (PyErr_Occurred()) SWIG_fail;
26508 }
26509 Py_INCREF(Py_None); resultobj = Py_None;
26510 return resultobj;
26511 fail:
26512 return NULL;
26513 }
26514
26515
26516 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26517 PyObject *resultobj = NULL;
26518 wxWindow *arg1 = (wxWindow *) 0 ;
26519 int result;
26520 PyObject * obj0 = 0 ;
26521 char *kwnames[] = {
26522 (char *) "self", NULL
26523 };
26524
26525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26527 if (SWIG_arg_fail(1)) SWIG_fail;
26528 {
26529 PyThreadState* __tstate = wxPyBeginAllowThreads();
26530 result = (int)((wxWindow const *)arg1)->GetId();
26531
26532 wxPyEndAllowThreads(__tstate);
26533 if (PyErr_Occurred()) SWIG_fail;
26534 }
26535 {
26536 resultobj = SWIG_From_int(static_cast<int >(result));
26537 }
26538 return resultobj;
26539 fail:
26540 return NULL;
26541 }
26542
26543
26544 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26545 PyObject *resultobj = NULL;
26546 int result;
26547 char *kwnames[] = {
26548 NULL
26549 };
26550
26551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (int)wxWindow::NewControlId();
26555
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 {
26560 resultobj = SWIG_From_int(static_cast<int >(result));
26561 }
26562 return resultobj;
26563 fail:
26564 return NULL;
26565 }
26566
26567
26568 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26569 PyObject *resultobj = NULL;
26570 int arg1 ;
26571 int result;
26572 PyObject * obj0 = 0 ;
26573 char *kwnames[] = {
26574 (char *) "winid", NULL
26575 };
26576
26577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26578 {
26579 arg1 = static_cast<int >(SWIG_As_int(obj0));
26580 if (SWIG_arg_fail(1)) SWIG_fail;
26581 }
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = (int)wxWindow::NextControlId(arg1);
26585
26586 wxPyEndAllowThreads(__tstate);
26587 if (PyErr_Occurred()) SWIG_fail;
26588 }
26589 {
26590 resultobj = SWIG_From_int(static_cast<int >(result));
26591 }
26592 return resultobj;
26593 fail:
26594 return NULL;
26595 }
26596
26597
26598 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26599 PyObject *resultobj = NULL;
26600 int arg1 ;
26601 int result;
26602 PyObject * obj0 = 0 ;
26603 char *kwnames[] = {
26604 (char *) "winid", NULL
26605 };
26606
26607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26608 {
26609 arg1 = static_cast<int >(SWIG_As_int(obj0));
26610 if (SWIG_arg_fail(1)) SWIG_fail;
26611 }
26612 {
26613 PyThreadState* __tstate = wxPyBeginAllowThreads();
26614 result = (int)wxWindow::PrevControlId(arg1);
26615
26616 wxPyEndAllowThreads(__tstate);
26617 if (PyErr_Occurred()) SWIG_fail;
26618 }
26619 {
26620 resultobj = SWIG_From_int(static_cast<int >(result));
26621 }
26622 return resultobj;
26623 fail:
26624 return NULL;
26625 }
26626
26627
26628 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26629 PyObject *resultobj = NULL;
26630 wxWindow *arg1 = (wxWindow *) 0 ;
26631 wxSize *arg2 = 0 ;
26632 wxSize temp2 ;
26633 PyObject * obj0 = 0 ;
26634 PyObject * obj1 = 0 ;
26635 char *kwnames[] = {
26636 (char *) "self",(char *) "size", NULL
26637 };
26638
26639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26641 if (SWIG_arg_fail(1)) SWIG_fail;
26642 {
26643 arg2 = &temp2;
26644 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26645 }
26646 {
26647 PyThreadState* __tstate = wxPyBeginAllowThreads();
26648 (arg1)->SetSize((wxSize const &)*arg2);
26649
26650 wxPyEndAllowThreads(__tstate);
26651 if (PyErr_Occurred()) SWIG_fail;
26652 }
26653 Py_INCREF(Py_None); resultobj = Py_None;
26654 return resultobj;
26655 fail:
26656 return NULL;
26657 }
26658
26659
26660 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj = NULL;
26662 wxWindow *arg1 = (wxWindow *) 0 ;
26663 int arg2 ;
26664 int arg3 ;
26665 int arg4 ;
26666 int arg5 ;
26667 int arg6 = (int) wxSIZE_AUTO ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 PyObject * obj2 = 0 ;
26671 PyObject * obj3 = 0 ;
26672 PyObject * obj4 = 0 ;
26673 PyObject * obj5 = 0 ;
26674 char *kwnames[] = {
26675 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26676 };
26677
26678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26680 if (SWIG_arg_fail(1)) SWIG_fail;
26681 {
26682 arg2 = static_cast<int >(SWIG_As_int(obj1));
26683 if (SWIG_arg_fail(2)) SWIG_fail;
26684 }
26685 {
26686 arg3 = static_cast<int >(SWIG_As_int(obj2));
26687 if (SWIG_arg_fail(3)) SWIG_fail;
26688 }
26689 {
26690 arg4 = static_cast<int >(SWIG_As_int(obj3));
26691 if (SWIG_arg_fail(4)) SWIG_fail;
26692 }
26693 {
26694 arg5 = static_cast<int >(SWIG_As_int(obj4));
26695 if (SWIG_arg_fail(5)) SWIG_fail;
26696 }
26697 if (obj5) {
26698 {
26699 arg6 = static_cast<int >(SWIG_As_int(obj5));
26700 if (SWIG_arg_fail(6)) SWIG_fail;
26701 }
26702 }
26703 {
26704 PyThreadState* __tstate = wxPyBeginAllowThreads();
26705 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26706
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 Py_INCREF(Py_None); resultobj = Py_None;
26711 return resultobj;
26712 fail:
26713 return NULL;
26714 }
26715
26716
26717 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26718 PyObject *resultobj = NULL;
26719 wxWindow *arg1 = (wxWindow *) 0 ;
26720 wxRect *arg2 = 0 ;
26721 int arg3 = (int) wxSIZE_AUTO ;
26722 wxRect temp2 ;
26723 PyObject * obj0 = 0 ;
26724 PyObject * obj1 = 0 ;
26725 PyObject * obj2 = 0 ;
26726 char *kwnames[] = {
26727 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26728 };
26729
26730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26732 if (SWIG_arg_fail(1)) SWIG_fail;
26733 {
26734 arg2 = &temp2;
26735 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26736 }
26737 if (obj2) {
26738 {
26739 arg3 = static_cast<int >(SWIG_As_int(obj2));
26740 if (SWIG_arg_fail(3)) SWIG_fail;
26741 }
26742 }
26743 {
26744 PyThreadState* __tstate = wxPyBeginAllowThreads();
26745 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26746
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 Py_INCREF(Py_None); resultobj = Py_None;
26751 return resultobj;
26752 fail:
26753 return NULL;
26754 }
26755
26756
26757 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26758 PyObject *resultobj = NULL;
26759 wxWindow *arg1 = (wxWindow *) 0 ;
26760 int arg2 ;
26761 int arg3 ;
26762 PyObject * obj0 = 0 ;
26763 PyObject * obj1 = 0 ;
26764 PyObject * obj2 = 0 ;
26765 char *kwnames[] = {
26766 (char *) "self",(char *) "width",(char *) "height", NULL
26767 };
26768
26769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26771 if (SWIG_arg_fail(1)) SWIG_fail;
26772 {
26773 arg2 = static_cast<int >(SWIG_As_int(obj1));
26774 if (SWIG_arg_fail(2)) SWIG_fail;
26775 }
26776 {
26777 arg3 = static_cast<int >(SWIG_As_int(obj2));
26778 if (SWIG_arg_fail(3)) SWIG_fail;
26779 }
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 (arg1)->SetSize(arg2,arg3);
26783
26784 wxPyEndAllowThreads(__tstate);
26785 if (PyErr_Occurred()) SWIG_fail;
26786 }
26787 Py_INCREF(Py_None); resultobj = Py_None;
26788 return resultobj;
26789 fail:
26790 return NULL;
26791 }
26792
26793
26794 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26795 PyObject *resultobj = NULL;
26796 wxWindow *arg1 = (wxWindow *) 0 ;
26797 wxPoint *arg2 = 0 ;
26798 int arg3 = (int) wxSIZE_USE_EXISTING ;
26799 wxPoint temp2 ;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 PyObject * obj2 = 0 ;
26803 char *kwnames[] = {
26804 (char *) "self",(char *) "pt",(char *) "flags", NULL
26805 };
26806
26807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26809 if (SWIG_arg_fail(1)) SWIG_fail;
26810 {
26811 arg2 = &temp2;
26812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26813 }
26814 if (obj2) {
26815 {
26816 arg3 = static_cast<int >(SWIG_As_int(obj2));
26817 if (SWIG_arg_fail(3)) SWIG_fail;
26818 }
26819 }
26820 {
26821 PyThreadState* __tstate = wxPyBeginAllowThreads();
26822 (arg1)->Move((wxPoint const &)*arg2,arg3);
26823
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 Py_INCREF(Py_None); resultobj = Py_None;
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj = NULL;
26836 wxWindow *arg1 = (wxWindow *) 0 ;
26837 int arg2 ;
26838 int arg3 ;
26839 int arg4 = (int) wxSIZE_USE_EXISTING ;
26840 PyObject * obj0 = 0 ;
26841 PyObject * obj1 = 0 ;
26842 PyObject * obj2 = 0 ;
26843 PyObject * obj3 = 0 ;
26844 char *kwnames[] = {
26845 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26846 };
26847
26848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26850 if (SWIG_arg_fail(1)) SWIG_fail;
26851 {
26852 arg2 = static_cast<int >(SWIG_As_int(obj1));
26853 if (SWIG_arg_fail(2)) SWIG_fail;
26854 }
26855 {
26856 arg3 = static_cast<int >(SWIG_As_int(obj2));
26857 if (SWIG_arg_fail(3)) SWIG_fail;
26858 }
26859 if (obj3) {
26860 {
26861 arg4 = static_cast<int >(SWIG_As_int(obj3));
26862 if (SWIG_arg_fail(4)) SWIG_fail;
26863 }
26864 }
26865 {
26866 PyThreadState* __tstate = wxPyBeginAllowThreads();
26867 (arg1)->Move(arg2,arg3,arg4);
26868
26869 wxPyEndAllowThreads(__tstate);
26870 if (PyErr_Occurred()) SWIG_fail;
26871 }
26872 Py_INCREF(Py_None); resultobj = Py_None;
26873 return resultobj;
26874 fail:
26875 return NULL;
26876 }
26877
26878
26879 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26880 PyObject *resultobj = NULL;
26881 wxWindow *arg1 = (wxWindow *) 0 ;
26882 wxSize const &arg2_defvalue = wxDefaultSize ;
26883 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26884 wxSize temp2 ;
26885 PyObject * obj0 = 0 ;
26886 PyObject * obj1 = 0 ;
26887 char *kwnames[] = {
26888 (char *) "self",(char *) "size", NULL
26889 };
26890
26891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26893 if (SWIG_arg_fail(1)) SWIG_fail;
26894 if (obj1) {
26895 {
26896 arg2 = &temp2;
26897 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26898 }
26899 }
26900 {
26901 PyThreadState* __tstate = wxPyBeginAllowThreads();
26902 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26903
26904 wxPyEndAllowThreads(__tstate);
26905 if (PyErr_Occurred()) SWIG_fail;
26906 }
26907 Py_INCREF(Py_None); resultobj = Py_None;
26908 return resultobj;
26909 fail:
26910 return NULL;
26911 }
26912
26913
26914 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26915 PyObject *resultobj = NULL;
26916 wxWindow *arg1 = (wxWindow *) 0 ;
26917 PyObject * obj0 = 0 ;
26918 char *kwnames[] = {
26919 (char *) "self", NULL
26920 };
26921
26922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26924 if (SWIG_arg_fail(1)) SWIG_fail;
26925 {
26926 PyThreadState* __tstate = wxPyBeginAllowThreads();
26927 (arg1)->Raise();
26928
26929 wxPyEndAllowThreads(__tstate);
26930 if (PyErr_Occurred()) SWIG_fail;
26931 }
26932 Py_INCREF(Py_None); resultobj = Py_None;
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26940 PyObject *resultobj = NULL;
26941 wxWindow *arg1 = (wxWindow *) 0 ;
26942 PyObject * obj0 = 0 ;
26943 char *kwnames[] = {
26944 (char *) "self", NULL
26945 };
26946
26947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26949 if (SWIG_arg_fail(1)) SWIG_fail;
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 (arg1)->Lower();
26953
26954 wxPyEndAllowThreads(__tstate);
26955 if (PyErr_Occurred()) SWIG_fail;
26956 }
26957 Py_INCREF(Py_None); resultobj = Py_None;
26958 return resultobj;
26959 fail:
26960 return NULL;
26961 }
26962
26963
26964 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26965 PyObject *resultobj = NULL;
26966 wxWindow *arg1 = (wxWindow *) 0 ;
26967 wxSize *arg2 = 0 ;
26968 wxSize temp2 ;
26969 PyObject * obj0 = 0 ;
26970 PyObject * obj1 = 0 ;
26971 char *kwnames[] = {
26972 (char *) "self",(char *) "size", NULL
26973 };
26974
26975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26977 if (SWIG_arg_fail(1)) SWIG_fail;
26978 {
26979 arg2 = &temp2;
26980 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26981 }
26982 {
26983 PyThreadState* __tstate = wxPyBeginAllowThreads();
26984 (arg1)->SetClientSize((wxSize const &)*arg2);
26985
26986 wxPyEndAllowThreads(__tstate);
26987 if (PyErr_Occurred()) SWIG_fail;
26988 }
26989 Py_INCREF(Py_None); resultobj = Py_None;
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj = NULL;
26998 wxWindow *arg1 = (wxWindow *) 0 ;
26999 int arg2 ;
27000 int arg3 ;
27001 PyObject * obj0 = 0 ;
27002 PyObject * obj1 = 0 ;
27003 PyObject * obj2 = 0 ;
27004 char *kwnames[] = {
27005 (char *) "self",(char *) "width",(char *) "height", NULL
27006 };
27007
27008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27010 if (SWIG_arg_fail(1)) SWIG_fail;
27011 {
27012 arg2 = static_cast<int >(SWIG_As_int(obj1));
27013 if (SWIG_arg_fail(2)) SWIG_fail;
27014 }
27015 {
27016 arg3 = static_cast<int >(SWIG_As_int(obj2));
27017 if (SWIG_arg_fail(3)) SWIG_fail;
27018 }
27019 {
27020 PyThreadState* __tstate = wxPyBeginAllowThreads();
27021 (arg1)->SetClientSize(arg2,arg3);
27022
27023 wxPyEndAllowThreads(__tstate);
27024 if (PyErr_Occurred()) SWIG_fail;
27025 }
27026 Py_INCREF(Py_None); resultobj = Py_None;
27027 return resultobj;
27028 fail:
27029 return NULL;
27030 }
27031
27032
27033 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27034 PyObject *resultobj = NULL;
27035 wxWindow *arg1 = (wxWindow *) 0 ;
27036 wxRect *arg2 = 0 ;
27037 wxRect temp2 ;
27038 PyObject * obj0 = 0 ;
27039 PyObject * obj1 = 0 ;
27040 char *kwnames[] = {
27041 (char *) "self",(char *) "rect", NULL
27042 };
27043
27044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
27045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27046 if (SWIG_arg_fail(1)) SWIG_fail;
27047 {
27048 arg2 = &temp2;
27049 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
27050 }
27051 {
27052 PyThreadState* __tstate = wxPyBeginAllowThreads();
27053 (arg1)->SetClientSize((wxRect const &)*arg2);
27054
27055 wxPyEndAllowThreads(__tstate);
27056 if (PyErr_Occurred()) SWIG_fail;
27057 }
27058 Py_INCREF(Py_None); resultobj = Py_None;
27059 return resultobj;
27060 fail:
27061 return NULL;
27062 }
27063
27064
27065 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj = NULL;
27067 wxWindow *arg1 = (wxWindow *) 0 ;
27068 wxPoint result;
27069 PyObject * obj0 = 0 ;
27070 char *kwnames[] = {
27071 (char *) "self", NULL
27072 };
27073
27074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
27075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27076 if (SWIG_arg_fail(1)) SWIG_fail;
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 result = (arg1)->GetPosition();
27080
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 {
27085 wxPoint * resultptr;
27086 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27088 }
27089 return resultobj;
27090 fail:
27091 return NULL;
27092 }
27093
27094
27095 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27096 PyObject *resultobj = NULL;
27097 wxWindow *arg1 = (wxWindow *) 0 ;
27098 int *arg2 = (int *) 0 ;
27099 int *arg3 = (int *) 0 ;
27100 int temp2 ;
27101 int res2 = 0 ;
27102 int temp3 ;
27103 int res3 = 0 ;
27104 PyObject * obj0 = 0 ;
27105 char *kwnames[] = {
27106 (char *) "self", NULL
27107 };
27108
27109 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27110 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
27112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27113 if (SWIG_arg_fail(1)) SWIG_fail;
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 (arg1)->GetPosition(arg2,arg3);
27117
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 Py_INCREF(Py_None); resultobj = Py_None;
27122 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27123 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27124 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27125 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj = NULL;
27134 wxWindow *arg1 = (wxWindow *) 0 ;
27135 wxSize result;
27136 PyObject * obj0 = 0 ;
27137 char *kwnames[] = {
27138 (char *) "self", NULL
27139 };
27140
27141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
27142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(1)) SWIG_fail;
27144 {
27145 PyThreadState* __tstate = wxPyBeginAllowThreads();
27146 result = ((wxWindow const *)arg1)->GetSize();
27147
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 {
27152 wxSize * resultptr;
27153 resultptr = new wxSize(static_cast<wxSize & >(result));
27154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27155 }
27156 return resultobj;
27157 fail:
27158 return NULL;
27159 }
27160
27161
27162 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27163 PyObject *resultobj = NULL;
27164 wxWindow *arg1 = (wxWindow *) 0 ;
27165 int *arg2 = (int *) 0 ;
27166 int *arg3 = (int *) 0 ;
27167 int temp2 ;
27168 int res2 = 0 ;
27169 int temp3 ;
27170 int res3 = 0 ;
27171 PyObject * obj0 = 0 ;
27172 char *kwnames[] = {
27173 (char *) "self", NULL
27174 };
27175
27176 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27177 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27180 if (SWIG_arg_fail(1)) SWIG_fail;
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27184
27185 wxPyEndAllowThreads(__tstate);
27186 if (PyErr_Occurred()) SWIG_fail;
27187 }
27188 Py_INCREF(Py_None); resultobj = Py_None;
27189 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27190 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27191 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27192 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27193 return resultobj;
27194 fail:
27195 return NULL;
27196 }
27197
27198
27199 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27200 PyObject *resultobj = NULL;
27201 wxWindow *arg1 = (wxWindow *) 0 ;
27202 wxRect result;
27203 PyObject * obj0 = 0 ;
27204 char *kwnames[] = {
27205 (char *) "self", NULL
27206 };
27207
27208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27210 if (SWIG_arg_fail(1)) SWIG_fail;
27211 {
27212 PyThreadState* __tstate = wxPyBeginAllowThreads();
27213 result = ((wxWindow const *)arg1)->GetRect();
27214
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 {
27219 wxRect * resultptr;
27220 resultptr = new wxRect(static_cast<wxRect & >(result));
27221 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27222 }
27223 return resultobj;
27224 fail:
27225 return NULL;
27226 }
27227
27228
27229 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27230 PyObject *resultobj = NULL;
27231 wxWindow *arg1 = (wxWindow *) 0 ;
27232 wxSize result;
27233 PyObject * obj0 = 0 ;
27234 char *kwnames[] = {
27235 (char *) "self", NULL
27236 };
27237
27238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27240 if (SWIG_arg_fail(1)) SWIG_fail;
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = ((wxWindow const *)arg1)->GetClientSize();
27244
27245 wxPyEndAllowThreads(__tstate);
27246 if (PyErr_Occurred()) SWIG_fail;
27247 }
27248 {
27249 wxSize * resultptr;
27250 resultptr = new wxSize(static_cast<wxSize & >(result));
27251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27252 }
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27260 PyObject *resultobj = NULL;
27261 wxWindow *arg1 = (wxWindow *) 0 ;
27262 int *arg2 = (int *) 0 ;
27263 int *arg3 = (int *) 0 ;
27264 int temp2 ;
27265 int res2 = 0 ;
27266 int temp3 ;
27267 int res3 = 0 ;
27268 PyObject * obj0 = 0 ;
27269 char *kwnames[] = {
27270 (char *) "self", NULL
27271 };
27272
27273 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27274 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27277 if (SWIG_arg_fail(1)) SWIG_fail;
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27281
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 Py_INCREF(Py_None); resultobj = Py_None;
27286 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27287 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27288 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27289 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27297 PyObject *resultobj = NULL;
27298 wxWindow *arg1 = (wxWindow *) 0 ;
27299 wxPoint result;
27300 PyObject * obj0 = 0 ;
27301 char *kwnames[] = {
27302 (char *) "self", NULL
27303 };
27304
27305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27307 if (SWIG_arg_fail(1)) SWIG_fail;
27308 {
27309 PyThreadState* __tstate = wxPyBeginAllowThreads();
27310 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27311
27312 wxPyEndAllowThreads(__tstate);
27313 if (PyErr_Occurred()) SWIG_fail;
27314 }
27315 {
27316 wxPoint * resultptr;
27317 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27318 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27319 }
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = NULL;
27328 wxWindow *arg1 = (wxWindow *) 0 ;
27329 wxRect result;
27330 PyObject * obj0 = 0 ;
27331 char *kwnames[] = {
27332 (char *) "self", NULL
27333 };
27334
27335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27337 if (SWIG_arg_fail(1)) SWIG_fail;
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 result = ((wxWindow const *)arg1)->GetClientRect();
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 {
27346 wxRect * resultptr;
27347 resultptr = new wxRect(static_cast<wxRect & >(result));
27348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27349 }
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27357 PyObject *resultobj = NULL;
27358 wxWindow *arg1 = (wxWindow *) 0 ;
27359 wxSize result;
27360 PyObject * obj0 = 0 ;
27361 char *kwnames[] = {
27362 (char *) "self", NULL
27363 };
27364
27365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27367 if (SWIG_arg_fail(1)) SWIG_fail;
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 result = ((wxWindow const *)arg1)->GetBestSize();
27371
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 {
27376 wxSize * resultptr;
27377 resultptr = new wxSize(static_cast<wxSize & >(result));
27378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27379 }
27380 return resultobj;
27381 fail:
27382 return NULL;
27383 }
27384
27385
27386 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj = NULL;
27388 wxWindow *arg1 = (wxWindow *) 0 ;
27389 int *arg2 = (int *) 0 ;
27390 int *arg3 = (int *) 0 ;
27391 int temp2 ;
27392 int res2 = 0 ;
27393 int temp3 ;
27394 int res3 = 0 ;
27395 PyObject * obj0 = 0 ;
27396 char *kwnames[] = {
27397 (char *) "self", NULL
27398 };
27399
27400 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27401 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27404 if (SWIG_arg_fail(1)) SWIG_fail;
27405 {
27406 PyThreadState* __tstate = wxPyBeginAllowThreads();
27407 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27408
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 Py_INCREF(Py_None); resultobj = Py_None;
27413 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27414 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27415 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27416 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27417 return resultobj;
27418 fail:
27419 return NULL;
27420 }
27421
27422
27423 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj = NULL;
27425 wxWindow *arg1 = (wxWindow *) 0 ;
27426 PyObject * obj0 = 0 ;
27427 char *kwnames[] = {
27428 (char *) "self", NULL
27429 };
27430
27431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27433 if (SWIG_arg_fail(1)) SWIG_fail;
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 (arg1)->InvalidateBestSize();
27437
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 Py_INCREF(Py_None); resultobj = Py_None;
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj = NULL;
27450 wxWindow *arg1 = (wxWindow *) 0 ;
27451 wxSize *arg2 = 0 ;
27452 wxSize temp2 ;
27453 PyObject * obj0 = 0 ;
27454 PyObject * obj1 = 0 ;
27455 char *kwnames[] = {
27456 (char *) "self",(char *) "size", NULL
27457 };
27458
27459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27461 if (SWIG_arg_fail(1)) SWIG_fail;
27462 {
27463 arg2 = &temp2;
27464 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27465 }
27466 {
27467 PyThreadState* __tstate = wxPyBeginAllowThreads();
27468 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27469
27470 wxPyEndAllowThreads(__tstate);
27471 if (PyErr_Occurred()) SWIG_fail;
27472 }
27473 Py_INCREF(Py_None); resultobj = Py_None;
27474 return resultobj;
27475 fail:
27476 return NULL;
27477 }
27478
27479
27480 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27481 PyObject *resultobj = NULL;
27482 wxWindow *arg1 = (wxWindow *) 0 ;
27483 wxSize result;
27484 PyObject * obj0 = 0 ;
27485 char *kwnames[] = {
27486 (char *) "self", NULL
27487 };
27488
27489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27491 if (SWIG_arg_fail(1)) SWIG_fail;
27492 {
27493 PyThreadState* __tstate = wxPyBeginAllowThreads();
27494 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27495
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 {
27500 wxSize * resultptr;
27501 resultptr = new wxSize(static_cast<wxSize & >(result));
27502 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27503 }
27504 return resultobj;
27505 fail:
27506 return NULL;
27507 }
27508
27509
27510 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27511 PyObject *resultobj = NULL;
27512 wxWindow *arg1 = (wxWindow *) 0 ;
27513 wxSize result;
27514 PyObject * obj0 = 0 ;
27515 char *kwnames[] = {
27516 (char *) "self", NULL
27517 };
27518
27519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27521 if (SWIG_arg_fail(1)) SWIG_fail;
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27525
27526 wxPyEndAllowThreads(__tstate);
27527 if (PyErr_Occurred()) SWIG_fail;
27528 }
27529 {
27530 wxSize * resultptr;
27531 resultptr = new wxSize(static_cast<wxSize & >(result));
27532 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27533 }
27534 return resultobj;
27535 fail:
27536 return NULL;
27537 }
27538
27539
27540 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27541 PyObject *resultobj = NULL;
27542 wxWindow *arg1 = (wxWindow *) 0 ;
27543 int arg2 = (int) wxBOTH ;
27544 PyObject * obj0 = 0 ;
27545 PyObject * obj1 = 0 ;
27546 char *kwnames[] = {
27547 (char *) "self",(char *) "direction", NULL
27548 };
27549
27550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27552 if (SWIG_arg_fail(1)) SWIG_fail;
27553 if (obj1) {
27554 {
27555 arg2 = static_cast<int >(SWIG_As_int(obj1));
27556 if (SWIG_arg_fail(2)) SWIG_fail;
27557 }
27558 }
27559 {
27560 PyThreadState* __tstate = wxPyBeginAllowThreads();
27561 (arg1)->Center(arg2);
27562
27563 wxPyEndAllowThreads(__tstate);
27564 if (PyErr_Occurred()) SWIG_fail;
27565 }
27566 Py_INCREF(Py_None); resultobj = Py_None;
27567 return resultobj;
27568 fail:
27569 return NULL;
27570 }
27571
27572
27573 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27574 PyObject *resultobj = NULL;
27575 wxWindow *arg1 = (wxWindow *) 0 ;
27576 int arg2 = (int) wxBOTH ;
27577 PyObject * obj0 = 0 ;
27578 PyObject * obj1 = 0 ;
27579 char *kwnames[] = {
27580 (char *) "self",(char *) "dir", NULL
27581 };
27582
27583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27585 if (SWIG_arg_fail(1)) SWIG_fail;
27586 if (obj1) {
27587 {
27588 arg2 = static_cast<int >(SWIG_As_int(obj1));
27589 if (SWIG_arg_fail(2)) SWIG_fail;
27590 }
27591 }
27592 {
27593 PyThreadState* __tstate = wxPyBeginAllowThreads();
27594 (arg1)->CenterOnParent(arg2);
27595
27596 wxPyEndAllowThreads(__tstate);
27597 if (PyErr_Occurred()) SWIG_fail;
27598 }
27599 Py_INCREF(Py_None); resultobj = Py_None;
27600 return resultobj;
27601 fail:
27602 return NULL;
27603 }
27604
27605
27606 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27607 PyObject *resultobj = NULL;
27608 wxWindow *arg1 = (wxWindow *) 0 ;
27609 PyObject * obj0 = 0 ;
27610 char *kwnames[] = {
27611 (char *) "self", NULL
27612 };
27613
27614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27616 if (SWIG_arg_fail(1)) SWIG_fail;
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 (arg1)->Fit();
27620
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 Py_INCREF(Py_None); resultobj = Py_None;
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27632 PyObject *resultobj = NULL;
27633 wxWindow *arg1 = (wxWindow *) 0 ;
27634 PyObject * obj0 = 0 ;
27635 char *kwnames[] = {
27636 (char *) "self", NULL
27637 };
27638
27639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27641 if (SWIG_arg_fail(1)) SWIG_fail;
27642 {
27643 PyThreadState* __tstate = wxPyBeginAllowThreads();
27644 (arg1)->FitInside();
27645
27646 wxPyEndAllowThreads(__tstate);
27647 if (PyErr_Occurred()) SWIG_fail;
27648 }
27649 Py_INCREF(Py_None); resultobj = Py_None;
27650 return resultobj;
27651 fail:
27652 return NULL;
27653 }
27654
27655
27656 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27657 PyObject *resultobj = NULL;
27658 wxWindow *arg1 = (wxWindow *) 0 ;
27659 int arg2 ;
27660 int arg3 ;
27661 int arg4 = (int) -1 ;
27662 int arg5 = (int) -1 ;
27663 int arg6 = (int) -1 ;
27664 int arg7 = (int) -1 ;
27665 PyObject * obj0 = 0 ;
27666 PyObject * obj1 = 0 ;
27667 PyObject * obj2 = 0 ;
27668 PyObject * obj3 = 0 ;
27669 PyObject * obj4 = 0 ;
27670 PyObject * obj5 = 0 ;
27671 PyObject * obj6 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27678 if (SWIG_arg_fail(1)) SWIG_fail;
27679 {
27680 arg2 = static_cast<int >(SWIG_As_int(obj1));
27681 if (SWIG_arg_fail(2)) SWIG_fail;
27682 }
27683 {
27684 arg3 = static_cast<int >(SWIG_As_int(obj2));
27685 if (SWIG_arg_fail(3)) SWIG_fail;
27686 }
27687 if (obj3) {
27688 {
27689 arg4 = static_cast<int >(SWIG_As_int(obj3));
27690 if (SWIG_arg_fail(4)) SWIG_fail;
27691 }
27692 }
27693 if (obj4) {
27694 {
27695 arg5 = static_cast<int >(SWIG_As_int(obj4));
27696 if (SWIG_arg_fail(5)) SWIG_fail;
27697 }
27698 }
27699 if (obj5) {
27700 {
27701 arg6 = static_cast<int >(SWIG_As_int(obj5));
27702 if (SWIG_arg_fail(6)) SWIG_fail;
27703 }
27704 }
27705 if (obj6) {
27706 {
27707 arg7 = static_cast<int >(SWIG_As_int(obj6));
27708 if (SWIG_arg_fail(7)) SWIG_fail;
27709 }
27710 }
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27714
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 Py_INCREF(Py_None); resultobj = Py_None;
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj = NULL;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 wxSize *arg2 = 0 ;
27729 wxSize const &arg3_defvalue = wxDefaultSize ;
27730 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27731 wxSize const &arg4_defvalue = wxDefaultSize ;
27732 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27733 wxSize temp2 ;
27734 wxSize temp3 ;
27735 wxSize temp4 ;
27736 PyObject * obj0 = 0 ;
27737 PyObject * obj1 = 0 ;
27738 PyObject * obj2 = 0 ;
27739 PyObject * obj3 = 0 ;
27740 char *kwnames[] = {
27741 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27742 };
27743
27744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27746 if (SWIG_arg_fail(1)) SWIG_fail;
27747 {
27748 arg2 = &temp2;
27749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27750 }
27751 if (obj2) {
27752 {
27753 arg3 = &temp3;
27754 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27755 }
27756 }
27757 if (obj3) {
27758 {
27759 arg4 = &temp4;
27760 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27761 }
27762 }
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27766
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 Py_INCREF(Py_None); resultobj = Py_None;
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj = NULL;
27779 wxWindow *arg1 = (wxWindow *) 0 ;
27780 int arg2 ;
27781 int arg3 ;
27782 int arg4 = (int) -1 ;
27783 int arg5 = (int) -1 ;
27784 PyObject * obj0 = 0 ;
27785 PyObject * obj1 = 0 ;
27786 PyObject * obj2 = 0 ;
27787 PyObject * obj3 = 0 ;
27788 PyObject * obj4 = 0 ;
27789 char *kwnames[] = {
27790 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27791 };
27792
27793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27795 if (SWIG_arg_fail(1)) SWIG_fail;
27796 {
27797 arg2 = static_cast<int >(SWIG_As_int(obj1));
27798 if (SWIG_arg_fail(2)) SWIG_fail;
27799 }
27800 {
27801 arg3 = static_cast<int >(SWIG_As_int(obj2));
27802 if (SWIG_arg_fail(3)) SWIG_fail;
27803 }
27804 if (obj3) {
27805 {
27806 arg4 = static_cast<int >(SWIG_As_int(obj3));
27807 if (SWIG_arg_fail(4)) SWIG_fail;
27808 }
27809 }
27810 if (obj4) {
27811 {
27812 arg5 = static_cast<int >(SWIG_As_int(obj4));
27813 if (SWIG_arg_fail(5)) SWIG_fail;
27814 }
27815 }
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27819
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 Py_INCREF(Py_None); resultobj = Py_None;
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj = NULL;
27832 wxWindow *arg1 = (wxWindow *) 0 ;
27833 wxSize *arg2 = 0 ;
27834 wxSize const &arg3_defvalue = wxDefaultSize ;
27835 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27836 wxSize temp2 ;
27837 wxSize temp3 ;
27838 PyObject * obj0 = 0 ;
27839 PyObject * obj1 = 0 ;
27840 PyObject * obj2 = 0 ;
27841 char *kwnames[] = {
27842 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27843 };
27844
27845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27847 if (SWIG_arg_fail(1)) SWIG_fail;
27848 {
27849 arg2 = &temp2;
27850 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27851 }
27852 if (obj2) {
27853 {
27854 arg3 = &temp3;
27855 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27856 }
27857 }
27858 {
27859 PyThreadState* __tstate = wxPyBeginAllowThreads();
27860 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27861
27862 wxPyEndAllowThreads(__tstate);
27863 if (PyErr_Occurred()) SWIG_fail;
27864 }
27865 Py_INCREF(Py_None); resultobj = Py_None;
27866 return resultobj;
27867 fail:
27868 return NULL;
27869 }
27870
27871
27872 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27873 PyObject *resultobj = NULL;
27874 wxWindow *arg1 = (wxWindow *) 0 ;
27875 wxSize result;
27876 PyObject * obj0 = 0 ;
27877 char *kwnames[] = {
27878 (char *) "self", NULL
27879 };
27880
27881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27883 if (SWIG_arg_fail(1)) SWIG_fail;
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 result = ((wxWindow const *)arg1)->GetMaxSize();
27887
27888 wxPyEndAllowThreads(__tstate);
27889 if (PyErr_Occurred()) SWIG_fail;
27890 }
27891 {
27892 wxSize * resultptr;
27893 resultptr = new wxSize(static_cast<wxSize & >(result));
27894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj = NULL;
27904 wxWindow *arg1 = (wxWindow *) 0 ;
27905 wxSize result;
27906 PyObject * obj0 = 0 ;
27907 char *kwnames[] = {
27908 (char *) "self", NULL
27909 };
27910
27911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27913 if (SWIG_arg_fail(1)) SWIG_fail;
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = ((wxWindow const *)arg1)->GetMinSize();
27917
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 wxSize * resultptr;
27923 resultptr = new wxSize(static_cast<wxSize & >(result));
27924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27925 }
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27933 PyObject *resultobj = NULL;
27934 wxWindow *arg1 = (wxWindow *) 0 ;
27935 wxSize *arg2 = 0 ;
27936 wxSize temp2 ;
27937 PyObject * obj0 = 0 ;
27938 PyObject * obj1 = 0 ;
27939 char *kwnames[] = {
27940 (char *) "self",(char *) "minSize", NULL
27941 };
27942
27943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27945 if (SWIG_arg_fail(1)) SWIG_fail;
27946 {
27947 arg2 = &temp2;
27948 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27949 }
27950 {
27951 PyThreadState* __tstate = wxPyBeginAllowThreads();
27952 (arg1)->SetMinSize((wxSize const &)*arg2);
27953
27954 wxPyEndAllowThreads(__tstate);
27955 if (PyErr_Occurred()) SWIG_fail;
27956 }
27957 Py_INCREF(Py_None); resultobj = Py_None;
27958 return resultobj;
27959 fail:
27960 return NULL;
27961 }
27962
27963
27964 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj = NULL;
27966 wxWindow *arg1 = (wxWindow *) 0 ;
27967 wxSize *arg2 = 0 ;
27968 wxSize temp2 ;
27969 PyObject * obj0 = 0 ;
27970 PyObject * obj1 = 0 ;
27971 char *kwnames[] = {
27972 (char *) "self",(char *) "maxSize", NULL
27973 };
27974
27975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27977 if (SWIG_arg_fail(1)) SWIG_fail;
27978 {
27979 arg2 = &temp2;
27980 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27981 }
27982 {
27983 PyThreadState* __tstate = wxPyBeginAllowThreads();
27984 (arg1)->SetMaxSize((wxSize const &)*arg2);
27985
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 Py_INCREF(Py_None); resultobj = Py_None;
27990 return resultobj;
27991 fail:
27992 return NULL;
27993 }
27994
27995
27996 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27997 PyObject *resultobj = NULL;
27998 wxWindow *arg1 = (wxWindow *) 0 ;
27999 int result;
28000 PyObject * obj0 = 0 ;
28001 char *kwnames[] = {
28002 (char *) "self", NULL
28003 };
28004
28005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
28006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28007 if (SWIG_arg_fail(1)) SWIG_fail;
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = (int)((wxWindow const *)arg1)->GetMinWidth();
28011
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 {
28016 resultobj = SWIG_From_int(static_cast<int >(result));
28017 }
28018 return resultobj;
28019 fail:
28020 return NULL;
28021 }
28022
28023
28024 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
28025 PyObject *resultobj = NULL;
28026 wxWindow *arg1 = (wxWindow *) 0 ;
28027 int result;
28028 PyObject * obj0 = 0 ;
28029 char *kwnames[] = {
28030 (char *) "self", NULL
28031 };
28032
28033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
28034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28035 if (SWIG_arg_fail(1)) SWIG_fail;
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 result = (int)((wxWindow const *)arg1)->GetMinHeight();
28039
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 {
28044 resultobj = SWIG_From_int(static_cast<int >(result));
28045 }
28046 return resultobj;
28047 fail:
28048 return NULL;
28049 }
28050
28051
28052 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
28053 PyObject *resultobj = NULL;
28054 wxWindow *arg1 = (wxWindow *) 0 ;
28055 int result;
28056 PyObject * obj0 = 0 ;
28057 char *kwnames[] = {
28058 (char *) "self", NULL
28059 };
28060
28061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
28062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(1)) SWIG_fail;
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
28067
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 {
28072 resultobj = SWIG_From_int(static_cast<int >(result));
28073 }
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = NULL;
28082 wxWindow *arg1 = (wxWindow *) 0 ;
28083 int result;
28084 PyObject * obj0 = 0 ;
28085 char *kwnames[] = {
28086 (char *) "self", NULL
28087 };
28088
28089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
28090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28091 if (SWIG_arg_fail(1)) SWIG_fail;
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
28095
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 {
28100 resultobj = SWIG_From_int(static_cast<int >(result));
28101 }
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj = NULL;
28110 wxWindow *arg1 = (wxWindow *) 0 ;
28111 wxSize *arg2 = 0 ;
28112 wxSize temp2 ;
28113 PyObject * obj0 = 0 ;
28114 PyObject * obj1 = 0 ;
28115 char *kwnames[] = {
28116 (char *) "self",(char *) "size", NULL
28117 };
28118
28119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
28120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28121 if (SWIG_arg_fail(1)) SWIG_fail;
28122 {
28123 arg2 = &temp2;
28124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28125 }
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 (arg1)->SetVirtualSize((wxSize const &)*arg2);
28129
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 Py_INCREF(Py_None); resultobj = Py_None;
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28141 PyObject *resultobj = NULL;
28142 wxWindow *arg1 = (wxWindow *) 0 ;
28143 int arg2 ;
28144 int arg3 ;
28145 PyObject * obj0 = 0 ;
28146 PyObject * obj1 = 0 ;
28147 PyObject * obj2 = 0 ;
28148 char *kwnames[] = {
28149 (char *) "self",(char *) "w",(char *) "h", NULL
28150 };
28151
28152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28154 if (SWIG_arg_fail(1)) SWIG_fail;
28155 {
28156 arg2 = static_cast<int >(SWIG_As_int(obj1));
28157 if (SWIG_arg_fail(2)) SWIG_fail;
28158 }
28159 {
28160 arg3 = static_cast<int >(SWIG_As_int(obj2));
28161 if (SWIG_arg_fail(3)) SWIG_fail;
28162 }
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 (arg1)->SetVirtualSize(arg2,arg3);
28166
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 Py_INCREF(Py_None); resultobj = Py_None;
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj = NULL;
28179 wxWindow *arg1 = (wxWindow *) 0 ;
28180 wxSize result;
28181 PyObject * obj0 = 0 ;
28182 char *kwnames[] = {
28183 (char *) "self", NULL
28184 };
28185
28186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28188 if (SWIG_arg_fail(1)) SWIG_fail;
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 result = ((wxWindow const *)arg1)->GetVirtualSize();
28192
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 {
28197 wxSize * resultptr;
28198 resultptr = new wxSize(static_cast<wxSize & >(result));
28199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28200 }
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28208 PyObject *resultobj = NULL;
28209 wxWindow *arg1 = (wxWindow *) 0 ;
28210 int *arg2 = (int *) 0 ;
28211 int *arg3 = (int *) 0 ;
28212 int temp2 ;
28213 int res2 = 0 ;
28214 int temp3 ;
28215 int res3 = 0 ;
28216 PyObject * obj0 = 0 ;
28217 char *kwnames[] = {
28218 (char *) "self", NULL
28219 };
28220
28221 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28222 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28225 if (SWIG_arg_fail(1)) SWIG_fail;
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28229
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 Py_INCREF(Py_None); resultobj = Py_None;
28234 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28235 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28236 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28237 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj = NULL;
28246 wxWindow *arg1 = (wxWindow *) 0 ;
28247 wxSize result;
28248 PyObject * obj0 = 0 ;
28249 char *kwnames[] = {
28250 (char *) "self", NULL
28251 };
28252
28253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28255 if (SWIG_arg_fail(1)) SWIG_fail;
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28259
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 wxSize * resultptr;
28265 resultptr = new wxSize(static_cast<wxSize & >(result));
28266 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28267 }
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = NULL;
28276 wxWindow *arg1 = (wxWindow *) 0 ;
28277 bool arg2 = (bool) true ;
28278 bool result;
28279 PyObject * obj0 = 0 ;
28280 PyObject * obj1 = 0 ;
28281 char *kwnames[] = {
28282 (char *) "self",(char *) "show", NULL
28283 };
28284
28285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28287 if (SWIG_arg_fail(1)) SWIG_fail;
28288 if (obj1) {
28289 {
28290 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28291 if (SWIG_arg_fail(2)) SWIG_fail;
28292 }
28293 }
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (bool)(arg1)->Show(arg2);
28297
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 {
28302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28303 }
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj = NULL;
28312 wxWindow *arg1 = (wxWindow *) 0 ;
28313 bool result;
28314 PyObject * obj0 = 0 ;
28315 char *kwnames[] = {
28316 (char *) "self", NULL
28317 };
28318
28319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28321 if (SWIG_arg_fail(1)) SWIG_fail;
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (bool)(arg1)->Hide();
28325
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 {
28330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28331 }
28332 return resultobj;
28333 fail:
28334 return NULL;
28335 }
28336
28337
28338 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28339 PyObject *resultobj = NULL;
28340 wxWindow *arg1 = (wxWindow *) 0 ;
28341 bool arg2 = (bool) true ;
28342 bool result;
28343 PyObject * obj0 = 0 ;
28344 PyObject * obj1 = 0 ;
28345 char *kwnames[] = {
28346 (char *) "self",(char *) "enable", NULL
28347 };
28348
28349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28351 if (SWIG_arg_fail(1)) SWIG_fail;
28352 if (obj1) {
28353 {
28354 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28355 if (SWIG_arg_fail(2)) SWIG_fail;
28356 }
28357 }
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (bool)(arg1)->Enable(arg2);
28361
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 {
28366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28367 }
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj = NULL;
28376 wxWindow *arg1 = (wxWindow *) 0 ;
28377 bool result;
28378 PyObject * obj0 = 0 ;
28379 char *kwnames[] = {
28380 (char *) "self", NULL
28381 };
28382
28383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28385 if (SWIG_arg_fail(1)) SWIG_fail;
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = (bool)(arg1)->Disable();
28389
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 {
28394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28395 }
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28403 PyObject *resultobj = NULL;
28404 wxWindow *arg1 = (wxWindow *) 0 ;
28405 bool result;
28406 PyObject * obj0 = 0 ;
28407 char *kwnames[] = {
28408 (char *) "self", NULL
28409 };
28410
28411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28413 if (SWIG_arg_fail(1)) SWIG_fail;
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = (bool)((wxWindow const *)arg1)->IsShown();
28417
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28423 }
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj = NULL;
28432 wxWindow *arg1 = (wxWindow *) 0 ;
28433 bool result;
28434 PyObject * obj0 = 0 ;
28435 char *kwnames[] = {
28436 (char *) "self", NULL
28437 };
28438
28439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28441 if (SWIG_arg_fail(1)) SWIG_fail;
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28445
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28459 PyObject *resultobj = NULL;
28460 wxWindow *arg1 = (wxWindow *) 0 ;
28461 long arg2 ;
28462 PyObject * obj0 = 0 ;
28463 PyObject * obj1 = 0 ;
28464 char *kwnames[] = {
28465 (char *) "self",(char *) "style", NULL
28466 };
28467
28468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28470 if (SWIG_arg_fail(1)) SWIG_fail;
28471 {
28472 arg2 = static_cast<long >(SWIG_As_long(obj1));
28473 if (SWIG_arg_fail(2)) SWIG_fail;
28474 }
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 (arg1)->SetWindowStyleFlag(arg2);
28478
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 Py_INCREF(Py_None); resultobj = Py_None;
28483 return resultobj;
28484 fail:
28485 return NULL;
28486 }
28487
28488
28489 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28490 PyObject *resultobj = NULL;
28491 wxWindow *arg1 = (wxWindow *) 0 ;
28492 long result;
28493 PyObject * obj0 = 0 ;
28494 char *kwnames[] = {
28495 (char *) "self", NULL
28496 };
28497
28498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28500 if (SWIG_arg_fail(1)) SWIG_fail;
28501 {
28502 PyThreadState* __tstate = wxPyBeginAllowThreads();
28503 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28504
28505 wxPyEndAllowThreads(__tstate);
28506 if (PyErr_Occurred()) SWIG_fail;
28507 }
28508 {
28509 resultobj = SWIG_From_long(static_cast<long >(result));
28510 }
28511 return resultobj;
28512 fail:
28513 return NULL;
28514 }
28515
28516
28517 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28518 PyObject *resultobj = NULL;
28519 wxWindow *arg1 = (wxWindow *) 0 ;
28520 int arg2 ;
28521 bool result;
28522 PyObject * obj0 = 0 ;
28523 PyObject * obj1 = 0 ;
28524 char *kwnames[] = {
28525 (char *) "self",(char *) "flag", NULL
28526 };
28527
28528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28530 if (SWIG_arg_fail(1)) SWIG_fail;
28531 {
28532 arg2 = static_cast<int >(SWIG_As_int(obj1));
28533 if (SWIG_arg_fail(2)) SWIG_fail;
28534 }
28535 {
28536 PyThreadState* __tstate = wxPyBeginAllowThreads();
28537 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28538
28539 wxPyEndAllowThreads(__tstate);
28540 if (PyErr_Occurred()) SWIG_fail;
28541 }
28542 {
28543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28544 }
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj = NULL;
28553 wxWindow *arg1 = (wxWindow *) 0 ;
28554 bool result;
28555 PyObject * obj0 = 0 ;
28556 char *kwnames[] = {
28557 (char *) "self", NULL
28558 };
28559
28560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28562 if (SWIG_arg_fail(1)) SWIG_fail;
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 result = (bool)((wxWindow const *)arg1)->IsRetained();
28566
28567 wxPyEndAllowThreads(__tstate);
28568 if (PyErr_Occurred()) SWIG_fail;
28569 }
28570 {
28571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28572 }
28573 return resultobj;
28574 fail:
28575 return NULL;
28576 }
28577
28578
28579 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28580 PyObject *resultobj = NULL;
28581 wxWindow *arg1 = (wxWindow *) 0 ;
28582 long arg2 ;
28583 PyObject * obj0 = 0 ;
28584 PyObject * obj1 = 0 ;
28585 char *kwnames[] = {
28586 (char *) "self",(char *) "exStyle", NULL
28587 };
28588
28589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(1)) SWIG_fail;
28592 {
28593 arg2 = static_cast<long >(SWIG_As_long(obj1));
28594 if (SWIG_arg_fail(2)) SWIG_fail;
28595 }
28596 {
28597 PyThreadState* __tstate = wxPyBeginAllowThreads();
28598 (arg1)->SetExtraStyle(arg2);
28599
28600 wxPyEndAllowThreads(__tstate);
28601 if (PyErr_Occurred()) SWIG_fail;
28602 }
28603 Py_INCREF(Py_None); resultobj = Py_None;
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28611 PyObject *resultobj = NULL;
28612 wxWindow *arg1 = (wxWindow *) 0 ;
28613 long result;
28614 PyObject * obj0 = 0 ;
28615 char *kwnames[] = {
28616 (char *) "self", NULL
28617 };
28618
28619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28621 if (SWIG_arg_fail(1)) SWIG_fail;
28622 {
28623 PyThreadState* __tstate = wxPyBeginAllowThreads();
28624 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28625
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 {
28630 resultobj = SWIG_From_long(static_cast<long >(result));
28631 }
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj = NULL;
28640 wxWindow *arg1 = (wxWindow *) 0 ;
28641 bool arg2 = (bool) true ;
28642 PyObject * obj0 = 0 ;
28643 PyObject * obj1 = 0 ;
28644 char *kwnames[] = {
28645 (char *) "self",(char *) "modal", NULL
28646 };
28647
28648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28650 if (SWIG_arg_fail(1)) SWIG_fail;
28651 if (obj1) {
28652 {
28653 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28654 if (SWIG_arg_fail(2)) SWIG_fail;
28655 }
28656 }
28657 {
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 (arg1)->MakeModal(arg2);
28660
28661 wxPyEndAllowThreads(__tstate);
28662 if (PyErr_Occurred()) SWIG_fail;
28663 }
28664 Py_INCREF(Py_None); resultobj = Py_None;
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28672 PyObject *resultobj = NULL;
28673 wxWindow *arg1 = (wxWindow *) 0 ;
28674 bool arg2 ;
28675 PyObject * obj0 = 0 ;
28676 PyObject * obj1 = 0 ;
28677 char *kwnames[] = {
28678 (char *) "self",(char *) "enableTheme", NULL
28679 };
28680
28681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28683 if (SWIG_arg_fail(1)) SWIG_fail;
28684 {
28685 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28686 if (SWIG_arg_fail(2)) SWIG_fail;
28687 }
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 (arg1)->SetThemeEnabled(arg2);
28691
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 Py_INCREF(Py_None); resultobj = Py_None;
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28703 PyObject *resultobj = NULL;
28704 wxWindow *arg1 = (wxWindow *) 0 ;
28705 bool result;
28706 PyObject * obj0 = 0 ;
28707 char *kwnames[] = {
28708 (char *) "self", NULL
28709 };
28710
28711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28713 if (SWIG_arg_fail(1)) SWIG_fail;
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28717
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 {
28722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28723 }
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28731 PyObject *resultobj = NULL;
28732 wxWindow *arg1 = (wxWindow *) 0 ;
28733 PyObject * obj0 = 0 ;
28734 char *kwnames[] = {
28735 (char *) "self", NULL
28736 };
28737
28738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 (arg1)->SetFocus();
28744
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 Py_INCREF(Py_None); resultobj = Py_None;
28749 return resultobj;
28750 fail:
28751 return NULL;
28752 }
28753
28754
28755 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28756 PyObject *resultobj = NULL;
28757 wxWindow *arg1 = (wxWindow *) 0 ;
28758 PyObject * obj0 = 0 ;
28759 char *kwnames[] = {
28760 (char *) "self", NULL
28761 };
28762
28763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28765 if (SWIG_arg_fail(1)) SWIG_fail;
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 (arg1)->SetFocusFromKbd();
28769
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 Py_INCREF(Py_None); resultobj = Py_None;
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28781 PyObject *resultobj = NULL;
28782 wxWindow *result;
28783 char *kwnames[] = {
28784 NULL
28785 };
28786
28787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28788 {
28789 if (!wxPyCheckForApp()) SWIG_fail;
28790 PyThreadState* __tstate = wxPyBeginAllowThreads();
28791 result = (wxWindow *)wxWindow::FindFocus();
28792
28793 wxPyEndAllowThreads(__tstate);
28794 if (PyErr_Occurred()) SWIG_fail;
28795 }
28796 {
28797 resultobj = wxPyMake_wxObject(result, 0);
28798 }
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28806 PyObject *resultobj = NULL;
28807 wxWindow *arg1 = (wxWindow *) 0 ;
28808 bool result;
28809 PyObject * obj0 = 0 ;
28810 char *kwnames[] = {
28811 (char *) "self", NULL
28812 };
28813
28814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28816 if (SWIG_arg_fail(1)) SWIG_fail;
28817 {
28818 PyThreadState* __tstate = wxPyBeginAllowThreads();
28819 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28820
28821 wxPyEndAllowThreads(__tstate);
28822 if (PyErr_Occurred()) SWIG_fail;
28823 }
28824 {
28825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28826 }
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28834 PyObject *resultobj = NULL;
28835 wxWindow *arg1 = (wxWindow *) 0 ;
28836 bool result;
28837 PyObject * obj0 = 0 ;
28838 char *kwnames[] = {
28839 (char *) "self", NULL
28840 };
28841
28842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28844 if (SWIG_arg_fail(1)) SWIG_fail;
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28848
28849 wxPyEndAllowThreads(__tstate);
28850 if (PyErr_Occurred()) SWIG_fail;
28851 }
28852 {
28853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28854 }
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj = NULL;
28863 wxWindow *arg1 = (wxWindow *) 0 ;
28864 wxWindow *result;
28865 PyObject * obj0 = 0 ;
28866 char *kwnames[] = {
28867 (char *) "self", NULL
28868 };
28869
28870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28872 if (SWIG_arg_fail(1)) SWIG_fail;
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 resultobj = wxPyMake_wxObject(result, 0);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj = NULL;
28891 wxWindow *arg1 = (wxWindow *) 0 ;
28892 wxWindow *arg2 = (wxWindow *) 0 ;
28893 wxWindow *result;
28894 PyObject * obj0 = 0 ;
28895 PyObject * obj1 = 0 ;
28896 char *kwnames[] = {
28897 (char *) "self",(char *) "child", NULL
28898 };
28899
28900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28902 if (SWIG_arg_fail(1)) SWIG_fail;
28903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28904 if (SWIG_arg_fail(2)) SWIG_fail;
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28908
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 {
28913 resultobj = wxPyMake_wxObject(result, 0);
28914 }
28915 return resultobj;
28916 fail:
28917 return NULL;
28918 }
28919
28920
28921 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28922 PyObject *resultobj = NULL;
28923 wxWindow *arg1 = (wxWindow *) 0 ;
28924 wxWindow *arg2 = (wxWindow *) 0 ;
28925 PyObject * obj0 = 0 ;
28926 PyObject * obj1 = 0 ;
28927 char *kwnames[] = {
28928 (char *) "self",(char *) "win", NULL
28929 };
28930
28931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28933 if (SWIG_arg_fail(1)) SWIG_fail;
28934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28935 if (SWIG_arg_fail(2)) SWIG_fail;
28936 {
28937 PyThreadState* __tstate = wxPyBeginAllowThreads();
28938 (arg1)->SetTmpDefaultItem(arg2);
28939
28940 wxPyEndAllowThreads(__tstate);
28941 if (PyErr_Occurred()) SWIG_fail;
28942 }
28943 Py_INCREF(Py_None); resultobj = Py_None;
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj = NULL;
28952 wxWindow *arg1 = (wxWindow *) 0 ;
28953 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28954 bool result;
28955 PyObject * obj0 = 0 ;
28956 PyObject * obj1 = 0 ;
28957 char *kwnames[] = {
28958 (char *) "self",(char *) "flags", NULL
28959 };
28960
28961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28963 if (SWIG_arg_fail(1)) SWIG_fail;
28964 if (obj1) {
28965 {
28966 arg2 = static_cast<int >(SWIG_As_int(obj1));
28967 if (SWIG_arg_fail(2)) SWIG_fail;
28968 }
28969 }
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (bool)(arg1)->Navigate(arg2);
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 {
28978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28979 }
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj = NULL;
28988 wxWindow *arg1 = (wxWindow *) 0 ;
28989 wxWindow *arg2 = (wxWindow *) 0 ;
28990 PyObject * obj0 = 0 ;
28991 PyObject * obj1 = 0 ;
28992 char *kwnames[] = {
28993 (char *) "self",(char *) "win", NULL
28994 };
28995
28996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28998 if (SWIG_arg_fail(1)) SWIG_fail;
28999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29000 if (SWIG_arg_fail(2)) SWIG_fail;
29001 {
29002 PyThreadState* __tstate = wxPyBeginAllowThreads();
29003 (arg1)->MoveAfterInTabOrder(arg2);
29004
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 Py_INCREF(Py_None); resultobj = Py_None;
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
29016 PyObject *resultobj = NULL;
29017 wxWindow *arg1 = (wxWindow *) 0 ;
29018 wxWindow *arg2 = (wxWindow *) 0 ;
29019 PyObject * obj0 = 0 ;
29020 PyObject * obj1 = 0 ;
29021 char *kwnames[] = {
29022 (char *) "self",(char *) "win", NULL
29023 };
29024
29025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
29026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29027 if (SWIG_arg_fail(1)) SWIG_fail;
29028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29029 if (SWIG_arg_fail(2)) SWIG_fail;
29030 {
29031 PyThreadState* __tstate = wxPyBeginAllowThreads();
29032 (arg1)->MoveBeforeInTabOrder(arg2);
29033
29034 wxPyEndAllowThreads(__tstate);
29035 if (PyErr_Occurred()) SWIG_fail;
29036 }
29037 Py_INCREF(Py_None); resultobj = Py_None;
29038 return resultobj;
29039 fail:
29040 return NULL;
29041 }
29042
29043
29044 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
29045 PyObject *resultobj = NULL;
29046 wxWindow *arg1 = (wxWindow *) 0 ;
29047 PyObject *result;
29048 PyObject * obj0 = 0 ;
29049 char *kwnames[] = {
29050 (char *) "self", NULL
29051 };
29052
29053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
29054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29055 if (SWIG_arg_fail(1)) SWIG_fail;
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 result = (PyObject *)wxWindow_GetChildren(arg1);
29059
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = result;
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj = NULL;
29072 wxWindow *arg1 = (wxWindow *) 0 ;
29073 wxWindow *result;
29074 PyObject * obj0 = 0 ;
29075 char *kwnames[] = {
29076 (char *) "self", NULL
29077 };
29078
29079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
29080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29081 if (SWIG_arg_fail(1)) SWIG_fail;
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
29085
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 {
29090 resultobj = wxPyMake_wxObject(result, 0);
29091 }
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
29099 PyObject *resultobj = NULL;
29100 wxWindow *arg1 = (wxWindow *) 0 ;
29101 wxWindow *result;
29102 PyObject * obj0 = 0 ;
29103 char *kwnames[] = {
29104 (char *) "self", NULL
29105 };
29106
29107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
29108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29109 if (SWIG_arg_fail(1)) SWIG_fail;
29110 {
29111 PyThreadState* __tstate = wxPyBeginAllowThreads();
29112 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
29113
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 {
29118 resultobj = wxPyMake_wxObject(result, 0);
29119 }
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj = NULL;
29128 wxWindow *arg1 = (wxWindow *) 0 ;
29129 bool result;
29130 PyObject * obj0 = 0 ;
29131 char *kwnames[] = {
29132 (char *) "self", NULL
29133 };
29134
29135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29137 if (SWIG_arg_fail(1)) SWIG_fail;
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29141
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 {
29146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29147 }
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj = NULL;
29156 wxWindow *arg1 = (wxWindow *) 0 ;
29157 wxWindow *arg2 = (wxWindow *) 0 ;
29158 bool result;
29159 PyObject * obj0 = 0 ;
29160 PyObject * obj1 = 0 ;
29161 char *kwnames[] = {
29162 (char *) "self",(char *) "newParent", NULL
29163 };
29164
29165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29167 if (SWIG_arg_fail(1)) SWIG_fail;
29168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29169 if (SWIG_arg_fail(2)) SWIG_fail;
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 result = (bool)(arg1)->Reparent(arg2);
29173
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 {
29178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29179 }
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29187 PyObject *resultobj = NULL;
29188 wxWindow *arg1 = (wxWindow *) 0 ;
29189 wxWindow *arg2 = (wxWindow *) 0 ;
29190 PyObject * obj0 = 0 ;
29191 PyObject * obj1 = 0 ;
29192 char *kwnames[] = {
29193 (char *) "self",(char *) "child", NULL
29194 };
29195
29196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29198 if (SWIG_arg_fail(1)) SWIG_fail;
29199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29200 if (SWIG_arg_fail(2)) SWIG_fail;
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 (arg1)->AddChild(arg2);
29204
29205 wxPyEndAllowThreads(__tstate);
29206 if (PyErr_Occurred()) SWIG_fail;
29207 }
29208 Py_INCREF(Py_None); resultobj = Py_None;
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29216 PyObject *resultobj = NULL;
29217 wxWindow *arg1 = (wxWindow *) 0 ;
29218 wxWindow *arg2 = (wxWindow *) 0 ;
29219 PyObject * obj0 = 0 ;
29220 PyObject * obj1 = 0 ;
29221 char *kwnames[] = {
29222 (char *) "self",(char *) "child", NULL
29223 };
29224
29225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29227 if (SWIG_arg_fail(1)) SWIG_fail;
29228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29229 if (SWIG_arg_fail(2)) SWIG_fail;
29230 {
29231 PyThreadState* __tstate = wxPyBeginAllowThreads();
29232 (arg1)->RemoveChild(arg2);
29233
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 Py_INCREF(Py_None); resultobj = Py_None;
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj = NULL;
29246 wxWindow *arg1 = (wxWindow *) 0 ;
29247 long arg2 ;
29248 wxWindow *result;
29249 PyObject * obj0 = 0 ;
29250 PyObject * obj1 = 0 ;
29251 char *kwnames[] = {
29252 (char *) "self",(char *) "winid", NULL
29253 };
29254
29255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(1)) SWIG_fail;
29258 {
29259 arg2 = static_cast<long >(SWIG_As_long(obj1));
29260 if (SWIG_arg_fail(2)) SWIG_fail;
29261 }
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 result = (wxWindow *)(arg1)->FindWindow(arg2);
29265
29266 wxPyEndAllowThreads(__tstate);
29267 if (PyErr_Occurred()) SWIG_fail;
29268 }
29269 {
29270 resultobj = wxPyMake_wxObject(result, 0);
29271 }
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29279 PyObject *resultobj = NULL;
29280 wxWindow *arg1 = (wxWindow *) 0 ;
29281 wxString *arg2 = 0 ;
29282 wxWindow *result;
29283 bool temp2 = false ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char *kwnames[] = {
29287 (char *) "self",(char *) "name", NULL
29288 };
29289
29290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29292 if (SWIG_arg_fail(1)) SWIG_fail;
29293 {
29294 arg2 = wxString_in_helper(obj1);
29295 if (arg2 == NULL) SWIG_fail;
29296 temp2 = true;
29297 }
29298 {
29299 PyThreadState* __tstate = wxPyBeginAllowThreads();
29300 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29301
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 {
29306 resultobj = wxPyMake_wxObject(result, 0);
29307 }
29308 {
29309 if (temp2)
29310 delete arg2;
29311 }
29312 return resultobj;
29313 fail:
29314 {
29315 if (temp2)
29316 delete arg2;
29317 }
29318 return NULL;
29319 }
29320
29321
29322 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj = NULL;
29324 wxWindow *arg1 = (wxWindow *) 0 ;
29325 wxEvtHandler *result;
29326 PyObject * obj0 = 0 ;
29327 char *kwnames[] = {
29328 (char *) "self", NULL
29329 };
29330
29331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29333 if (SWIG_arg_fail(1)) SWIG_fail;
29334 {
29335 PyThreadState* __tstate = wxPyBeginAllowThreads();
29336 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29337
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 {
29342 resultobj = wxPyMake_wxObject(result, 0);
29343 }
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29351 PyObject *resultobj = NULL;
29352 wxWindow *arg1 = (wxWindow *) 0 ;
29353 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29354 PyObject * obj0 = 0 ;
29355 PyObject * obj1 = 0 ;
29356 char *kwnames[] = {
29357 (char *) "self",(char *) "handler", NULL
29358 };
29359
29360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29362 if (SWIG_arg_fail(1)) SWIG_fail;
29363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29364 if (SWIG_arg_fail(2)) SWIG_fail;
29365 {
29366 PyThreadState* __tstate = wxPyBeginAllowThreads();
29367 (arg1)->SetEventHandler(arg2);
29368
29369 wxPyEndAllowThreads(__tstate);
29370 if (PyErr_Occurred()) SWIG_fail;
29371 }
29372 Py_INCREF(Py_None); resultobj = Py_None;
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj = NULL;
29381 wxWindow *arg1 = (wxWindow *) 0 ;
29382 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29383 PyObject * obj0 = 0 ;
29384 PyObject * obj1 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self",(char *) "handler", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29393 if (SWIG_arg_fail(2)) SWIG_fail;
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 (arg1)->PushEventHandler(arg2);
29397
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 Py_INCREF(Py_None); resultobj = Py_None;
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29409 PyObject *resultobj = NULL;
29410 wxWindow *arg1 = (wxWindow *) 0 ;
29411 bool arg2 = (bool) false ;
29412 wxEvtHandler *result;
29413 PyObject * obj0 = 0 ;
29414 PyObject * obj1 = 0 ;
29415 char *kwnames[] = {
29416 (char *) "self",(char *) "deleteHandler", NULL
29417 };
29418
29419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29421 if (SWIG_arg_fail(1)) SWIG_fail;
29422 if (obj1) {
29423 {
29424 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29425 if (SWIG_arg_fail(2)) SWIG_fail;
29426 }
29427 }
29428 {
29429 PyThreadState* __tstate = wxPyBeginAllowThreads();
29430 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29431
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 {
29436 resultobj = wxPyMake_wxObject(result, 0);
29437 }
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29445 PyObject *resultobj = NULL;
29446 wxWindow *arg1 = (wxWindow *) 0 ;
29447 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29448 bool result;
29449 PyObject * obj0 = 0 ;
29450 PyObject * obj1 = 0 ;
29451 char *kwnames[] = {
29452 (char *) "self",(char *) "handler", NULL
29453 };
29454
29455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29457 if (SWIG_arg_fail(1)) SWIG_fail;
29458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(2)) SWIG_fail;
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (bool)(arg1)->RemoveEventHandler(arg2);
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = NULL;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 wxValidator *arg2 = 0 ;
29480 PyObject * obj0 = 0 ;
29481 PyObject * obj1 = 0 ;
29482 char *kwnames[] = {
29483 (char *) "self",(char *) "validator", NULL
29484 };
29485
29486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29488 if (SWIG_arg_fail(1)) SWIG_fail;
29489 {
29490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29491 if (SWIG_arg_fail(2)) SWIG_fail;
29492 if (arg2 == NULL) {
29493 SWIG_null_ref("wxValidator");
29494 }
29495 if (SWIG_arg_fail(2)) SWIG_fail;
29496 }
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 (arg1)->SetValidator((wxValidator const &)*arg2);
29500
29501 wxPyEndAllowThreads(__tstate);
29502 if (PyErr_Occurred()) SWIG_fail;
29503 }
29504 Py_INCREF(Py_None); resultobj = Py_None;
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29512 PyObject *resultobj = NULL;
29513 wxWindow *arg1 = (wxWindow *) 0 ;
29514 wxValidator *result;
29515 PyObject * obj0 = 0 ;
29516 char *kwnames[] = {
29517 (char *) "self", NULL
29518 };
29519
29520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29522 if (SWIG_arg_fail(1)) SWIG_fail;
29523 {
29524 PyThreadState* __tstate = wxPyBeginAllowThreads();
29525 result = (wxValidator *)(arg1)->GetValidator();
29526
29527 wxPyEndAllowThreads(__tstate);
29528 if (PyErr_Occurred()) SWIG_fail;
29529 }
29530 {
29531 resultobj = wxPyMake_wxObject(result, (bool)0);
29532 }
29533 return resultobj;
29534 fail:
29535 return NULL;
29536 }
29537
29538
29539 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29540 PyObject *resultobj = NULL;
29541 wxWindow *arg1 = (wxWindow *) 0 ;
29542 bool result;
29543 PyObject * obj0 = 0 ;
29544 char *kwnames[] = {
29545 (char *) "self", NULL
29546 };
29547
29548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29550 if (SWIG_arg_fail(1)) SWIG_fail;
29551 {
29552 PyThreadState* __tstate = wxPyBeginAllowThreads();
29553 result = (bool)(arg1)->Validate();
29554
29555 wxPyEndAllowThreads(__tstate);
29556 if (PyErr_Occurred()) SWIG_fail;
29557 }
29558 {
29559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29560 }
29561 return resultobj;
29562 fail:
29563 return NULL;
29564 }
29565
29566
29567 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29568 PyObject *resultobj = NULL;
29569 wxWindow *arg1 = (wxWindow *) 0 ;
29570 bool result;
29571 PyObject * obj0 = 0 ;
29572 char *kwnames[] = {
29573 (char *) "self", NULL
29574 };
29575
29576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29578 if (SWIG_arg_fail(1)) SWIG_fail;
29579 {
29580 PyThreadState* __tstate = wxPyBeginAllowThreads();
29581 result = (bool)(arg1)->TransferDataToWindow();
29582
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 {
29587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29588 }
29589 return resultobj;
29590 fail:
29591 return NULL;
29592 }
29593
29594
29595 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29596 PyObject *resultobj = NULL;
29597 wxWindow *arg1 = (wxWindow *) 0 ;
29598 bool result;
29599 PyObject * obj0 = 0 ;
29600 char *kwnames[] = {
29601 (char *) "self", NULL
29602 };
29603
29604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29606 if (SWIG_arg_fail(1)) SWIG_fail;
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = (bool)(arg1)->TransferDataFromWindow();
29610
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 {
29615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29616 }
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj = NULL;
29625 wxWindow *arg1 = (wxWindow *) 0 ;
29626 PyObject * obj0 = 0 ;
29627 char *kwnames[] = {
29628 (char *) "self", NULL
29629 };
29630
29631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29633 if (SWIG_arg_fail(1)) SWIG_fail;
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 (arg1)->InitDialog();
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 Py_INCREF(Py_None); resultobj = Py_None;
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj = NULL;
29650 wxWindow *arg1 = (wxWindow *) 0 ;
29651 wxAcceleratorTable *arg2 = 0 ;
29652 PyObject * obj0 = 0 ;
29653 PyObject * obj1 = 0 ;
29654 char *kwnames[] = {
29655 (char *) "self",(char *) "accel", NULL
29656 };
29657
29658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29660 if (SWIG_arg_fail(1)) SWIG_fail;
29661 {
29662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29663 if (SWIG_arg_fail(2)) SWIG_fail;
29664 if (arg2 == NULL) {
29665 SWIG_null_ref("wxAcceleratorTable");
29666 }
29667 if (SWIG_arg_fail(2)) SWIG_fail;
29668 }
29669 {
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29672
29673 wxPyEndAllowThreads(__tstate);
29674 if (PyErr_Occurred()) SWIG_fail;
29675 }
29676 Py_INCREF(Py_None); resultobj = Py_None;
29677 return resultobj;
29678 fail:
29679 return NULL;
29680 }
29681
29682
29683 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29684 PyObject *resultobj = NULL;
29685 wxWindow *arg1 = (wxWindow *) 0 ;
29686 wxAcceleratorTable *result;
29687 PyObject * obj0 = 0 ;
29688 char *kwnames[] = {
29689 (char *) "self", NULL
29690 };
29691
29692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29694 if (SWIG_arg_fail(1)) SWIG_fail;
29695 {
29696 PyThreadState* __tstate = wxPyBeginAllowThreads();
29697 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29698
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj = NULL;
29711 wxWindow *arg1 = (wxWindow *) 0 ;
29712 int arg2 ;
29713 int arg3 ;
29714 int arg4 ;
29715 bool result;
29716 PyObject * obj0 = 0 ;
29717 PyObject * obj1 = 0 ;
29718 PyObject * obj2 = 0 ;
29719 PyObject * obj3 = 0 ;
29720 char *kwnames[] = {
29721 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29722 };
29723
29724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29726 if (SWIG_arg_fail(1)) SWIG_fail;
29727 {
29728 arg2 = static_cast<int >(SWIG_As_int(obj1));
29729 if (SWIG_arg_fail(2)) SWIG_fail;
29730 }
29731 {
29732 arg3 = static_cast<int >(SWIG_As_int(obj2));
29733 if (SWIG_arg_fail(3)) SWIG_fail;
29734 }
29735 {
29736 arg4 = static_cast<int >(SWIG_As_int(obj3));
29737 if (SWIG_arg_fail(4)) SWIG_fail;
29738 }
29739 {
29740 PyThreadState* __tstate = wxPyBeginAllowThreads();
29741 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29742
29743 wxPyEndAllowThreads(__tstate);
29744 if (PyErr_Occurred()) SWIG_fail;
29745 }
29746 {
29747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29748 }
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj = NULL;
29757 wxWindow *arg1 = (wxWindow *) 0 ;
29758 int arg2 ;
29759 bool result;
29760 PyObject * obj0 = 0 ;
29761 PyObject * obj1 = 0 ;
29762 char *kwnames[] = {
29763 (char *) "self",(char *) "hotkeyId", NULL
29764 };
29765
29766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29768 if (SWIG_arg_fail(1)) SWIG_fail;
29769 {
29770 arg2 = static_cast<int >(SWIG_As_int(obj1));
29771 if (SWIG_arg_fail(2)) SWIG_fail;
29772 }
29773 {
29774 PyThreadState* __tstate = wxPyBeginAllowThreads();
29775 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29776
29777 wxPyEndAllowThreads(__tstate);
29778 if (PyErr_Occurred()) SWIG_fail;
29779 }
29780 {
29781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29782 }
29783 return resultobj;
29784 fail:
29785 return NULL;
29786 }
29787
29788
29789 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29790 PyObject *resultobj = NULL;
29791 wxWindow *arg1 = (wxWindow *) 0 ;
29792 wxPoint *arg2 = 0 ;
29793 wxPoint result;
29794 wxPoint temp2 ;
29795 PyObject * obj0 = 0 ;
29796 PyObject * obj1 = 0 ;
29797 char *kwnames[] = {
29798 (char *) "self",(char *) "pt", NULL
29799 };
29800
29801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29803 if (SWIG_arg_fail(1)) SWIG_fail;
29804 {
29805 arg2 = &temp2;
29806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29807 }
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29811
29812 wxPyEndAllowThreads(__tstate);
29813 if (PyErr_Occurred()) SWIG_fail;
29814 }
29815 {
29816 wxPoint * resultptr;
29817 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29819 }
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = NULL;
29828 wxWindow *arg1 = (wxWindow *) 0 ;
29829 wxSize *arg2 = 0 ;
29830 wxSize result;
29831 wxSize temp2 ;
29832 PyObject * obj0 = 0 ;
29833 PyObject * obj1 = 0 ;
29834 char *kwnames[] = {
29835 (char *) "self",(char *) "sz", NULL
29836 };
29837
29838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29840 if (SWIG_arg_fail(1)) SWIG_fail;
29841 {
29842 arg2 = &temp2;
29843 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29844 }
29845 {
29846 PyThreadState* __tstate = wxPyBeginAllowThreads();
29847 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29848
29849 wxPyEndAllowThreads(__tstate);
29850 if (PyErr_Occurred()) SWIG_fail;
29851 }
29852 {
29853 wxSize * resultptr;
29854 resultptr = new wxSize(static_cast<wxSize & >(result));
29855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29856 }
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj = NULL;
29865 wxWindow *arg1 = (wxWindow *) 0 ;
29866 wxPoint *arg2 = 0 ;
29867 wxPoint result;
29868 wxPoint temp2 ;
29869 PyObject * obj0 = 0 ;
29870 PyObject * obj1 = 0 ;
29871 char *kwnames[] = {
29872 (char *) "self",(char *) "pt", NULL
29873 };
29874
29875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29877 if (SWIG_arg_fail(1)) SWIG_fail;
29878 {
29879 arg2 = &temp2;
29880 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29881 }
29882 {
29883 PyThreadState* __tstate = wxPyBeginAllowThreads();
29884 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29885
29886 wxPyEndAllowThreads(__tstate);
29887 if (PyErr_Occurred()) SWIG_fail;
29888 }
29889 {
29890 wxPoint * resultptr;
29891 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29893 }
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29901 PyObject *resultobj = NULL;
29902 wxWindow *arg1 = (wxWindow *) 0 ;
29903 wxSize *arg2 = 0 ;
29904 wxSize result;
29905 wxSize temp2 ;
29906 PyObject * obj0 = 0 ;
29907 PyObject * obj1 = 0 ;
29908 char *kwnames[] = {
29909 (char *) "self",(char *) "sz", NULL
29910 };
29911
29912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29914 if (SWIG_arg_fail(1)) SWIG_fail;
29915 {
29916 arg2 = &temp2;
29917 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29918 }
29919 {
29920 PyThreadState* __tstate = wxPyBeginAllowThreads();
29921 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29922
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 {
29927 wxSize * resultptr;
29928 resultptr = new wxSize(static_cast<wxSize & >(result));
29929 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29930 }
29931 return resultobj;
29932 fail:
29933 return NULL;
29934 }
29935
29936
29937 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29938 PyObject *resultobj = NULL;
29939 wxWindow *arg1 = (wxWindow *) 0 ;
29940 wxPoint *arg2 = 0 ;
29941 wxPoint result;
29942 wxPoint temp2 ;
29943 PyObject * obj0 = 0 ;
29944 PyObject * obj1 = 0 ;
29945 char *kwnames[] = {
29946 (char *) "self",(char *) "pt", NULL
29947 };
29948
29949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29951 if (SWIG_arg_fail(1)) SWIG_fail;
29952 {
29953 arg2 = &temp2;
29954 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29955 }
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29959
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 {
29964 wxPoint * resultptr;
29965 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29967 }
29968 return resultobj;
29969 fail:
29970 return NULL;
29971 }
29972
29973
29974 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29975 PyObject *resultobj = NULL;
29976 wxWindow *arg1 = (wxWindow *) 0 ;
29977 wxSize *arg2 = 0 ;
29978 wxSize result;
29979 wxSize temp2 ;
29980 PyObject * obj0 = 0 ;
29981 PyObject * obj1 = 0 ;
29982 char *kwnames[] = {
29983 (char *) "self",(char *) "sz", NULL
29984 };
29985
29986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29988 if (SWIG_arg_fail(1)) SWIG_fail;
29989 {
29990 arg2 = &temp2;
29991 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29992 }
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29996
29997 wxPyEndAllowThreads(__tstate);
29998 if (PyErr_Occurred()) SWIG_fail;
29999 }
30000 {
30001 wxSize * resultptr;
30002 resultptr = new wxSize(static_cast<wxSize & >(result));
30003 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
30004 }
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
30012 PyObject *resultobj = NULL;
30013 wxWindow *arg1 = (wxWindow *) 0 ;
30014 int arg2 ;
30015 int arg3 ;
30016 PyObject * obj0 = 0 ;
30017 PyObject * obj1 = 0 ;
30018 PyObject * obj2 = 0 ;
30019 char *kwnames[] = {
30020 (char *) "self",(char *) "x",(char *) "y", NULL
30021 };
30022
30023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
30024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30025 if (SWIG_arg_fail(1)) SWIG_fail;
30026 {
30027 arg2 = static_cast<int >(SWIG_As_int(obj1));
30028 if (SWIG_arg_fail(2)) SWIG_fail;
30029 }
30030 {
30031 arg3 = static_cast<int >(SWIG_As_int(obj2));
30032 if (SWIG_arg_fail(3)) SWIG_fail;
30033 }
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 (arg1)->WarpPointer(arg2,arg3);
30037
30038 wxPyEndAllowThreads(__tstate);
30039 if (PyErr_Occurred()) SWIG_fail;
30040 }
30041 Py_INCREF(Py_None); resultobj = Py_None;
30042 return resultobj;
30043 fail:
30044 return NULL;
30045 }
30046
30047
30048 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
30049 PyObject *resultobj = NULL;
30050 wxWindow *arg1 = (wxWindow *) 0 ;
30051 PyObject * obj0 = 0 ;
30052 char *kwnames[] = {
30053 (char *) "self", NULL
30054 };
30055
30056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
30057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(1)) SWIG_fail;
30059 {
30060 PyThreadState* __tstate = wxPyBeginAllowThreads();
30061 (arg1)->CaptureMouse();
30062
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 Py_INCREF(Py_None); resultobj = Py_None;
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj = NULL;
30075 wxWindow *arg1 = (wxWindow *) 0 ;
30076 PyObject * obj0 = 0 ;
30077 char *kwnames[] = {
30078 (char *) "self", NULL
30079 };
30080
30081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
30082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30083 if (SWIG_arg_fail(1)) SWIG_fail;
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 (arg1)->ReleaseMouse();
30087
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 Py_INCREF(Py_None); resultobj = Py_None;
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj = NULL;
30100 wxWindow *result;
30101 char *kwnames[] = {
30102 NULL
30103 };
30104
30105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
30106 {
30107 if (!wxPyCheckForApp()) SWIG_fail;
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 result = (wxWindow *)wxWindow::GetCapture();
30110
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 {
30115 resultobj = wxPyMake_wxObject(result, 0);
30116 }
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30124 PyObject *resultobj = NULL;
30125 wxWindow *arg1 = (wxWindow *) 0 ;
30126 bool result;
30127 PyObject * obj0 = 0 ;
30128 char *kwnames[] = {
30129 (char *) "self", NULL
30130 };
30131
30132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
30133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30134 if (SWIG_arg_fail(1)) SWIG_fail;
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = (bool)((wxWindow const *)arg1)->HasCapture();
30138
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 {
30143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30144 }
30145 return resultobj;
30146 fail:
30147 return NULL;
30148 }
30149
30150
30151 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30152 PyObject *resultobj = NULL;
30153 wxWindow *arg1 = (wxWindow *) 0 ;
30154 bool arg2 = (bool) true ;
30155 wxRect *arg3 = (wxRect *) NULL ;
30156 PyObject * obj0 = 0 ;
30157 PyObject * obj1 = 0 ;
30158 PyObject * obj2 = 0 ;
30159 char *kwnames[] = {
30160 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30161 };
30162
30163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30165 if (SWIG_arg_fail(1)) SWIG_fail;
30166 if (obj1) {
30167 {
30168 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30169 if (SWIG_arg_fail(2)) SWIG_fail;
30170 }
30171 }
30172 if (obj2) {
30173 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30174 if (SWIG_arg_fail(3)) SWIG_fail;
30175 }
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30179
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 Py_INCREF(Py_None); resultobj = Py_None;
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30191 PyObject *resultobj = NULL;
30192 wxWindow *arg1 = (wxWindow *) 0 ;
30193 wxRect *arg2 = 0 ;
30194 bool arg3 = (bool) true ;
30195 wxRect temp2 ;
30196 PyObject * obj0 = 0 ;
30197 PyObject * obj1 = 0 ;
30198 PyObject * obj2 = 0 ;
30199 char *kwnames[] = {
30200 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30201 };
30202
30203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30205 if (SWIG_arg_fail(1)) SWIG_fail;
30206 {
30207 arg2 = &temp2;
30208 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30209 }
30210 if (obj2) {
30211 {
30212 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30213 if (SWIG_arg_fail(3)) SWIG_fail;
30214 }
30215 }
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30219
30220 wxPyEndAllowThreads(__tstate);
30221 if (PyErr_Occurred()) SWIG_fail;
30222 }
30223 Py_INCREF(Py_None); resultobj = Py_None;
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30231 PyObject *resultobj = NULL;
30232 wxWindow *arg1 = (wxWindow *) 0 ;
30233 PyObject * obj0 = 0 ;
30234 char *kwnames[] = {
30235 (char *) "self", NULL
30236 };
30237
30238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30240 if (SWIG_arg_fail(1)) SWIG_fail;
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 (arg1)->Update();
30244
30245 wxPyEndAllowThreads(__tstate);
30246 if (PyErr_Occurred()) SWIG_fail;
30247 }
30248 Py_INCREF(Py_None); resultobj = Py_None;
30249 return resultobj;
30250 fail:
30251 return NULL;
30252 }
30253
30254
30255 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30256 PyObject *resultobj = NULL;
30257 wxWindow *arg1 = (wxWindow *) 0 ;
30258 PyObject * obj0 = 0 ;
30259 char *kwnames[] = {
30260 (char *) "self", NULL
30261 };
30262
30263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30265 if (SWIG_arg_fail(1)) SWIG_fail;
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 (arg1)->ClearBackground();
30269
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 Py_INCREF(Py_None); resultobj = Py_None;
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30281 PyObject *resultobj = NULL;
30282 wxWindow *arg1 = (wxWindow *) 0 ;
30283 PyObject * obj0 = 0 ;
30284 char *kwnames[] = {
30285 (char *) "self", NULL
30286 };
30287
30288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30290 if (SWIG_arg_fail(1)) SWIG_fail;
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 (arg1)->Freeze();
30294
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 Py_INCREF(Py_None); resultobj = Py_None;
30299 return resultobj;
30300 fail:
30301 return NULL;
30302 }
30303
30304
30305 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30306 PyObject *resultobj = NULL;
30307 wxWindow *arg1 = (wxWindow *) 0 ;
30308 PyObject * obj0 = 0 ;
30309 char *kwnames[] = {
30310 (char *) "self", NULL
30311 };
30312
30313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30315 if (SWIG_arg_fail(1)) SWIG_fail;
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 (arg1)->Thaw();
30319
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 Py_INCREF(Py_None); resultobj = Py_None;
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj = NULL;
30332 wxWindow *arg1 = (wxWindow *) 0 ;
30333 wxDC *arg2 = 0 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 char *kwnames[] = {
30337 (char *) "self",(char *) "dc", NULL
30338 };
30339
30340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30342 if (SWIG_arg_fail(1)) SWIG_fail;
30343 {
30344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30345 if (SWIG_arg_fail(2)) SWIG_fail;
30346 if (arg2 == NULL) {
30347 SWIG_null_ref("wxDC");
30348 }
30349 if (SWIG_arg_fail(2)) SWIG_fail;
30350 }
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 (arg1)->PrepareDC(*arg2);
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 Py_INCREF(Py_None); resultobj = Py_None;
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj = NULL;
30367 wxWindow *arg1 = (wxWindow *) 0 ;
30368 wxRegion *result;
30369 PyObject * obj0 = 0 ;
30370 char *kwnames[] = {
30371 (char *) "self", NULL
30372 };
30373
30374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30376 if (SWIG_arg_fail(1)) SWIG_fail;
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 {
30380 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30381 result = (wxRegion *) &_result_ref;
30382 }
30383
30384 wxPyEndAllowThreads(__tstate);
30385 if (PyErr_Occurred()) SWIG_fail;
30386 }
30387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30388 return resultobj;
30389 fail:
30390 return NULL;
30391 }
30392
30393
30394 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30395 PyObject *resultobj = NULL;
30396 wxWindow *arg1 = (wxWindow *) 0 ;
30397 wxRect result;
30398 PyObject * obj0 = 0 ;
30399 char *kwnames[] = {
30400 (char *) "self", NULL
30401 };
30402
30403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30405 if (SWIG_arg_fail(1)) SWIG_fail;
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30409
30410 wxPyEndAllowThreads(__tstate);
30411 if (PyErr_Occurred()) SWIG_fail;
30412 }
30413 {
30414 wxRect * resultptr;
30415 resultptr = new wxRect(static_cast<wxRect & >(result));
30416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30417 }
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj = NULL;
30426 wxWindow *arg1 = (wxWindow *) 0 ;
30427 int arg2 ;
30428 int arg3 ;
30429 int arg4 = (int) 1 ;
30430 int arg5 = (int) 1 ;
30431 bool result;
30432 PyObject * obj0 = 0 ;
30433 PyObject * obj1 = 0 ;
30434 PyObject * obj2 = 0 ;
30435 PyObject * obj3 = 0 ;
30436 PyObject * obj4 = 0 ;
30437 char *kwnames[] = {
30438 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30439 };
30440
30441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30443 if (SWIG_arg_fail(1)) SWIG_fail;
30444 {
30445 arg2 = static_cast<int >(SWIG_As_int(obj1));
30446 if (SWIG_arg_fail(2)) SWIG_fail;
30447 }
30448 {
30449 arg3 = static_cast<int >(SWIG_As_int(obj2));
30450 if (SWIG_arg_fail(3)) SWIG_fail;
30451 }
30452 if (obj3) {
30453 {
30454 arg4 = static_cast<int >(SWIG_As_int(obj3));
30455 if (SWIG_arg_fail(4)) SWIG_fail;
30456 }
30457 }
30458 if (obj4) {
30459 {
30460 arg5 = static_cast<int >(SWIG_As_int(obj4));
30461 if (SWIG_arg_fail(5)) SWIG_fail;
30462 }
30463 }
30464 {
30465 PyThreadState* __tstate = wxPyBeginAllowThreads();
30466 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30467
30468 wxPyEndAllowThreads(__tstate);
30469 if (PyErr_Occurred()) SWIG_fail;
30470 }
30471 {
30472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30473 }
30474 return resultobj;
30475 fail:
30476 return NULL;
30477 }
30478
30479
30480 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30481 PyObject *resultobj = NULL;
30482 wxWindow *arg1 = (wxWindow *) 0 ;
30483 wxPoint *arg2 = 0 ;
30484 bool result;
30485 wxPoint temp2 ;
30486 PyObject * obj0 = 0 ;
30487 PyObject * obj1 = 0 ;
30488 char *kwnames[] = {
30489 (char *) "self",(char *) "pt", NULL
30490 };
30491
30492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30494 if (SWIG_arg_fail(1)) SWIG_fail;
30495 {
30496 arg2 = &temp2;
30497 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30498 }
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30502
30503 wxPyEndAllowThreads(__tstate);
30504 if (PyErr_Occurred()) SWIG_fail;
30505 }
30506 {
30507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30508 }
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj = NULL;
30517 wxWindow *arg1 = (wxWindow *) 0 ;
30518 wxRect *arg2 = 0 ;
30519 bool result;
30520 wxRect temp2 ;
30521 PyObject * obj0 = 0 ;
30522 PyObject * obj1 = 0 ;
30523 char *kwnames[] = {
30524 (char *) "self",(char *) "rect", NULL
30525 };
30526
30527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30529 if (SWIG_arg_fail(1)) SWIG_fail;
30530 {
30531 arg2 = &temp2;
30532 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30533 }
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30537
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 {
30542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30543 }
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj = NULL;
30552 wxWindow *arg1 = (wxWindow *) 0 ;
30553 wxVisualAttributes result;
30554 PyObject * obj0 = 0 ;
30555 char *kwnames[] = {
30556 (char *) "self", NULL
30557 };
30558
30559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30561 if (SWIG_arg_fail(1)) SWIG_fail;
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30565
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 {
30570 wxVisualAttributes * resultptr;
30571 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30573 }
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj = NULL;
30582 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30583 wxVisualAttributes result;
30584 PyObject * obj0 = 0 ;
30585 char *kwnames[] = {
30586 (char *) "variant", NULL
30587 };
30588
30589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30590 if (obj0) {
30591 {
30592 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30593 if (SWIG_arg_fail(1)) SWIG_fail;
30594 }
30595 }
30596 {
30597 if (!wxPyCheckForApp()) SWIG_fail;
30598 PyThreadState* __tstate = wxPyBeginAllowThreads();
30599 result = wxWindow::GetClassDefaultAttributes(arg1);
30600
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 {
30605 wxVisualAttributes * resultptr;
30606 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30608 }
30609 return resultobj;
30610 fail:
30611 return NULL;
30612 }
30613
30614
30615 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30616 PyObject *resultobj = NULL;
30617 wxWindow *arg1 = (wxWindow *) 0 ;
30618 wxColour *arg2 = 0 ;
30619 bool result;
30620 wxColour temp2 ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 char *kwnames[] = {
30624 (char *) "self",(char *) "colour", NULL
30625 };
30626
30627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30629 if (SWIG_arg_fail(1)) SWIG_fail;
30630 {
30631 arg2 = &temp2;
30632 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30633 }
30634 {
30635 PyThreadState* __tstate = wxPyBeginAllowThreads();
30636 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30637
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 {
30642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30643 }
30644 return resultobj;
30645 fail:
30646 return NULL;
30647 }
30648
30649
30650 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30651 PyObject *resultobj = NULL;
30652 wxWindow *arg1 = (wxWindow *) 0 ;
30653 wxColour *arg2 = 0 ;
30654 wxColour temp2 ;
30655 PyObject * obj0 = 0 ;
30656 PyObject * obj1 = 0 ;
30657 char *kwnames[] = {
30658 (char *) "self",(char *) "colour", NULL
30659 };
30660
30661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30663 if (SWIG_arg_fail(1)) SWIG_fail;
30664 {
30665 arg2 = &temp2;
30666 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30667 }
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30671
30672 wxPyEndAllowThreads(__tstate);
30673 if (PyErr_Occurred()) SWIG_fail;
30674 }
30675 Py_INCREF(Py_None); resultobj = Py_None;
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj = NULL;
30684 wxWindow *arg1 = (wxWindow *) 0 ;
30685 wxColour *arg2 = 0 ;
30686 bool result;
30687 wxColour temp2 ;
30688 PyObject * obj0 = 0 ;
30689 PyObject * obj1 = 0 ;
30690 char *kwnames[] = {
30691 (char *) "self",(char *) "colour", NULL
30692 };
30693
30694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30696 if (SWIG_arg_fail(1)) SWIG_fail;
30697 {
30698 arg2 = &temp2;
30699 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30700 }
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30704
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 {
30709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30710 }
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30718 PyObject *resultobj = NULL;
30719 wxWindow *arg1 = (wxWindow *) 0 ;
30720 wxColour *arg2 = 0 ;
30721 wxColour temp2 ;
30722 PyObject * obj0 = 0 ;
30723 PyObject * obj1 = 0 ;
30724 char *kwnames[] = {
30725 (char *) "self",(char *) "colour", NULL
30726 };
30727
30728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30730 if (SWIG_arg_fail(1)) SWIG_fail;
30731 {
30732 arg2 = &temp2;
30733 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30734 }
30735 {
30736 PyThreadState* __tstate = wxPyBeginAllowThreads();
30737 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30738
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 Py_INCREF(Py_None); resultobj = Py_None;
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30750 PyObject *resultobj = NULL;
30751 wxWindow *arg1 = (wxWindow *) 0 ;
30752 wxColour result;
30753 PyObject * obj0 = 0 ;
30754 char *kwnames[] = {
30755 (char *) "self", NULL
30756 };
30757
30758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30760 if (SWIG_arg_fail(1)) SWIG_fail;
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30764
30765 wxPyEndAllowThreads(__tstate);
30766 if (PyErr_Occurred()) SWIG_fail;
30767 }
30768 {
30769 wxColour * resultptr;
30770 resultptr = new wxColour(static_cast<wxColour & >(result));
30771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30772 }
30773 return resultobj;
30774 fail:
30775 return NULL;
30776 }
30777
30778
30779 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30780 PyObject *resultobj = NULL;
30781 wxWindow *arg1 = (wxWindow *) 0 ;
30782 wxColour result;
30783 PyObject * obj0 = 0 ;
30784 char *kwnames[] = {
30785 (char *) "self", NULL
30786 };
30787
30788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30790 if (SWIG_arg_fail(1)) SWIG_fail;
30791 {
30792 PyThreadState* __tstate = wxPyBeginAllowThreads();
30793 result = ((wxWindow const *)arg1)->GetForegroundColour();
30794
30795 wxPyEndAllowThreads(__tstate);
30796 if (PyErr_Occurred()) SWIG_fail;
30797 }
30798 {
30799 wxColour * resultptr;
30800 resultptr = new wxColour(static_cast<wxColour & >(result));
30801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30802 }
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30810 PyObject *resultobj = NULL;
30811 wxWindow *arg1 = (wxWindow *) 0 ;
30812 bool result;
30813 PyObject * obj0 = 0 ;
30814 char *kwnames[] = {
30815 (char *) "self", NULL
30816 };
30817
30818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30820 if (SWIG_arg_fail(1)) SWIG_fail;
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30824
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 {
30829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30830 }
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30838 PyObject *resultobj = NULL;
30839 wxWindow *arg1 = (wxWindow *) 0 ;
30840 bool result;
30841 PyObject * obj0 = 0 ;
30842 char *kwnames[] = {
30843 (char *) "self", NULL
30844 };
30845
30846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30848 if (SWIG_arg_fail(1)) SWIG_fail;
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30852
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 {
30857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30858 }
30859 return resultobj;
30860 fail:
30861 return NULL;
30862 }
30863
30864
30865 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30866 PyObject *resultobj = NULL;
30867 wxWindow *arg1 = (wxWindow *) 0 ;
30868 wxBackgroundStyle arg2 ;
30869 bool result;
30870 PyObject * obj0 = 0 ;
30871 PyObject * obj1 = 0 ;
30872 char *kwnames[] = {
30873 (char *) "self",(char *) "style", NULL
30874 };
30875
30876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30878 if (SWIG_arg_fail(1)) SWIG_fail;
30879 {
30880 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30881 if (SWIG_arg_fail(2)) SWIG_fail;
30882 }
30883 {
30884 PyThreadState* __tstate = wxPyBeginAllowThreads();
30885 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30886
30887 wxPyEndAllowThreads(__tstate);
30888 if (PyErr_Occurred()) SWIG_fail;
30889 }
30890 {
30891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30892 }
30893 return resultobj;
30894 fail:
30895 return NULL;
30896 }
30897
30898
30899 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30900 PyObject *resultobj = NULL;
30901 wxWindow *arg1 = (wxWindow *) 0 ;
30902 wxBackgroundStyle result;
30903 PyObject * obj0 = 0 ;
30904 char *kwnames[] = {
30905 (char *) "self", NULL
30906 };
30907
30908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30910 if (SWIG_arg_fail(1)) SWIG_fail;
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30914
30915 wxPyEndAllowThreads(__tstate);
30916 if (PyErr_Occurred()) SWIG_fail;
30917 }
30918 resultobj = SWIG_From_int((result));
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30926 PyObject *resultobj = NULL;
30927 wxWindow *arg1 = (wxWindow *) 0 ;
30928 bool result;
30929 PyObject * obj0 = 0 ;
30930 char *kwnames[] = {
30931 (char *) "self", NULL
30932 };
30933
30934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30936 if (SWIG_arg_fail(1)) SWIG_fail;
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = (bool)(arg1)->HasTransparentBackground();
30940
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 {
30945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30946 }
30947 return resultobj;
30948 fail:
30949 return NULL;
30950 }
30951
30952
30953 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30954 PyObject *resultobj = NULL;
30955 wxWindow *arg1 = (wxWindow *) 0 ;
30956 wxCursor *arg2 = 0 ;
30957 bool result;
30958 PyObject * obj0 = 0 ;
30959 PyObject * obj1 = 0 ;
30960 char *kwnames[] = {
30961 (char *) "self",(char *) "cursor", NULL
30962 };
30963
30964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30966 if (SWIG_arg_fail(1)) SWIG_fail;
30967 {
30968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30969 if (SWIG_arg_fail(2)) SWIG_fail;
30970 if (arg2 == NULL) {
30971 SWIG_null_ref("wxCursor");
30972 }
30973 if (SWIG_arg_fail(2)) SWIG_fail;
30974 }
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30978
30979 wxPyEndAllowThreads(__tstate);
30980 if (PyErr_Occurred()) SWIG_fail;
30981 }
30982 {
30983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30984 }
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30992 PyObject *resultobj = NULL;
30993 wxWindow *arg1 = (wxWindow *) 0 ;
30994 wxCursor result;
30995 PyObject * obj0 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 result = (arg1)->GetCursor();
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 {
31011 wxCursor * resultptr;
31012 resultptr = new wxCursor(static_cast<wxCursor & >(result));
31013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
31022 PyObject *resultobj = NULL;
31023 wxWindow *arg1 = (wxWindow *) 0 ;
31024 wxFont *arg2 = 0 ;
31025 bool result;
31026 PyObject * obj0 = 0 ;
31027 PyObject * obj1 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self",(char *) "font", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
31033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(1)) SWIG_fail;
31035 {
31036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31037 if (SWIG_arg_fail(2)) SWIG_fail;
31038 if (arg2 == NULL) {
31039 SWIG_null_ref("wxFont");
31040 }
31041 if (SWIG_arg_fail(2)) SWIG_fail;
31042 }
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
31046
31047 wxPyEndAllowThreads(__tstate);
31048 if (PyErr_Occurred()) SWIG_fail;
31049 }
31050 {
31051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31052 }
31053 return resultobj;
31054 fail:
31055 return NULL;
31056 }
31057
31058
31059 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
31060 PyObject *resultobj = NULL;
31061 wxWindow *arg1 = (wxWindow *) 0 ;
31062 wxFont *arg2 = 0 ;
31063 PyObject * obj0 = 0 ;
31064 PyObject * obj1 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self",(char *) "font", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 {
31073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31074 if (SWIG_arg_fail(2)) SWIG_fail;
31075 if (arg2 == NULL) {
31076 SWIG_null_ref("wxFont");
31077 }
31078 if (SWIG_arg_fail(2)) SWIG_fail;
31079 }
31080 {
31081 PyThreadState* __tstate = wxPyBeginAllowThreads();
31082 (arg1)->SetOwnFont((wxFont const &)*arg2);
31083
31084 wxPyEndAllowThreads(__tstate);
31085 if (PyErr_Occurred()) SWIG_fail;
31086 }
31087 Py_INCREF(Py_None); resultobj = Py_None;
31088 return resultobj;
31089 fail:
31090 return NULL;
31091 }
31092
31093
31094 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
31095 PyObject *resultobj = NULL;
31096 wxWindow *arg1 = (wxWindow *) 0 ;
31097 wxFont result;
31098 PyObject * obj0 = 0 ;
31099 char *kwnames[] = {
31100 (char *) "self", NULL
31101 };
31102
31103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
31104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31105 if (SWIG_arg_fail(1)) SWIG_fail;
31106 {
31107 PyThreadState* __tstate = wxPyBeginAllowThreads();
31108 result = (arg1)->GetFont();
31109
31110 wxPyEndAllowThreads(__tstate);
31111 if (PyErr_Occurred()) SWIG_fail;
31112 }
31113 {
31114 wxFont * resultptr;
31115 resultptr = new wxFont(static_cast<wxFont & >(result));
31116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
31117 }
31118 return resultobj;
31119 fail:
31120 return NULL;
31121 }
31122
31123
31124 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31125 PyObject *resultobj = NULL;
31126 wxWindow *arg1 = (wxWindow *) 0 ;
31127 wxCaret *arg2 = (wxCaret *) 0 ;
31128 PyObject * obj0 = 0 ;
31129 PyObject * obj1 = 0 ;
31130 char *kwnames[] = {
31131 (char *) "self",(char *) "caret", NULL
31132 };
31133
31134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
31135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31136 if (SWIG_arg_fail(1)) SWIG_fail;
31137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31138 if (SWIG_arg_fail(2)) SWIG_fail;
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 (arg1)->SetCaret(arg2);
31142
31143 wxPyEndAllowThreads(__tstate);
31144 if (PyErr_Occurred()) SWIG_fail;
31145 }
31146 Py_INCREF(Py_None); resultobj = Py_None;
31147 return resultobj;
31148 fail:
31149 return NULL;
31150 }
31151
31152
31153 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31154 PyObject *resultobj = NULL;
31155 wxWindow *arg1 = (wxWindow *) 0 ;
31156 wxCaret *result;
31157 PyObject * obj0 = 0 ;
31158 char *kwnames[] = {
31159 (char *) "self", NULL
31160 };
31161
31162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31164 if (SWIG_arg_fail(1)) SWIG_fail;
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31168
31169 wxPyEndAllowThreads(__tstate);
31170 if (PyErr_Occurred()) SWIG_fail;
31171 }
31172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31173 return resultobj;
31174 fail:
31175 return NULL;
31176 }
31177
31178
31179 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31180 PyObject *resultobj = NULL;
31181 wxWindow *arg1 = (wxWindow *) 0 ;
31182 int result;
31183 PyObject * obj0 = 0 ;
31184 char *kwnames[] = {
31185 (char *) "self", NULL
31186 };
31187
31188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31190 if (SWIG_arg_fail(1)) SWIG_fail;
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31194
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 {
31199 resultobj = SWIG_From_int(static_cast<int >(result));
31200 }
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31208 PyObject *resultobj = NULL;
31209 wxWindow *arg1 = (wxWindow *) 0 ;
31210 int result;
31211 PyObject * obj0 = 0 ;
31212 char *kwnames[] = {
31213 (char *) "self", NULL
31214 };
31215
31216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31218 if (SWIG_arg_fail(1)) SWIG_fail;
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31222
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 {
31227 resultobj = SWIG_From_int(static_cast<int >(result));
31228 }
31229 return resultobj;
31230 fail:
31231 return NULL;
31232 }
31233
31234
31235 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31236 PyObject *resultobj = NULL;
31237 wxWindow *arg1 = (wxWindow *) 0 ;
31238 wxString *arg2 = 0 ;
31239 int *arg3 = (int *) 0 ;
31240 int *arg4 = (int *) 0 ;
31241 bool temp2 = false ;
31242 int temp3 ;
31243 int res3 = 0 ;
31244 int temp4 ;
31245 int res4 = 0 ;
31246 PyObject * obj0 = 0 ;
31247 PyObject * obj1 = 0 ;
31248 char *kwnames[] = {
31249 (char *) "self",(char *) "string", NULL
31250 };
31251
31252 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31253 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31256 if (SWIG_arg_fail(1)) SWIG_fail;
31257 {
31258 arg2 = wxString_in_helper(obj1);
31259 if (arg2 == NULL) SWIG_fail;
31260 temp2 = true;
31261 }
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31265
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 Py_INCREF(Py_None); resultobj = Py_None;
31270 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31271 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31272 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31273 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31274 {
31275 if (temp2)
31276 delete arg2;
31277 }
31278 return resultobj;
31279 fail:
31280 {
31281 if (temp2)
31282 delete arg2;
31283 }
31284 return NULL;
31285 }
31286
31287
31288 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31289 PyObject *resultobj = NULL;
31290 wxWindow *arg1 = (wxWindow *) 0 ;
31291 wxString *arg2 = 0 ;
31292 int *arg3 = (int *) 0 ;
31293 int *arg4 = (int *) 0 ;
31294 int *arg5 = (int *) 0 ;
31295 int *arg6 = (int *) 0 ;
31296 wxFont *arg7 = (wxFont *) NULL ;
31297 bool temp2 = false ;
31298 int temp3 ;
31299 int res3 = 0 ;
31300 int temp4 ;
31301 int res4 = 0 ;
31302 int temp5 ;
31303 int res5 = 0 ;
31304 int temp6 ;
31305 int res6 = 0 ;
31306 PyObject * obj0 = 0 ;
31307 PyObject * obj1 = 0 ;
31308 PyObject * obj2 = 0 ;
31309 char *kwnames[] = {
31310 (char *) "self",(char *) "string",(char *) "font", NULL
31311 };
31312
31313 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31314 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31315 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31316 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31319 if (SWIG_arg_fail(1)) SWIG_fail;
31320 {
31321 arg2 = wxString_in_helper(obj1);
31322 if (arg2 == NULL) SWIG_fail;
31323 temp2 = true;
31324 }
31325 if (obj2) {
31326 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31327 if (SWIG_arg_fail(7)) SWIG_fail;
31328 }
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31332
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 Py_INCREF(Py_None); resultobj = Py_None;
31337 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31338 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31339 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31340 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31341 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31342 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31343 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31344 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31345 {
31346 if (temp2)
31347 delete arg2;
31348 }
31349 return resultobj;
31350 fail:
31351 {
31352 if (temp2)
31353 delete arg2;
31354 }
31355 return NULL;
31356 }
31357
31358
31359 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31360 PyObject *resultobj = NULL;
31361 wxWindow *arg1 = (wxWindow *) 0 ;
31362 int *arg2 = (int *) 0 ;
31363 int *arg3 = (int *) 0 ;
31364 int temp2 ;
31365 int res2 = 0 ;
31366 int temp3 ;
31367 int res3 = 0 ;
31368 PyObject * obj0 = 0 ;
31369 PyObject * obj1 = 0 ;
31370 PyObject * obj2 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "self",(char *) "x",(char *) "y", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(1)) SWIG_fail;
31378 {
31379 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31380 temp2 = SWIG_As_int(obj1);
31381 if (SWIG_arg_fail(2)) SWIG_fail;
31382 arg2 = &temp2;
31383 res2 = SWIG_NEWOBJ;
31384 }
31385 }
31386 {
31387 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31388 temp3 = SWIG_As_int(obj2);
31389 if (SWIG_arg_fail(3)) SWIG_fail;
31390 arg3 = &temp3;
31391 res3 = SWIG_NEWOBJ;
31392 }
31393 }
31394 {
31395 PyThreadState* __tstate = wxPyBeginAllowThreads();
31396 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31397
31398 wxPyEndAllowThreads(__tstate);
31399 if (PyErr_Occurred()) SWIG_fail;
31400 }
31401 Py_INCREF(Py_None); resultobj = Py_None;
31402 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31403 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31404 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31405 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj = NULL;
31414 wxWindow *arg1 = (wxWindow *) 0 ;
31415 int *arg2 = (int *) 0 ;
31416 int *arg3 = (int *) 0 ;
31417 int temp2 ;
31418 int res2 = 0 ;
31419 int temp3 ;
31420 int res3 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 PyObject * obj1 = 0 ;
31423 PyObject * obj2 = 0 ;
31424 char *kwnames[] = {
31425 (char *) "self",(char *) "x",(char *) "y", NULL
31426 };
31427
31428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31430 if (SWIG_arg_fail(1)) SWIG_fail;
31431 {
31432 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31433 temp2 = SWIG_As_int(obj1);
31434 if (SWIG_arg_fail(2)) SWIG_fail;
31435 arg2 = &temp2;
31436 res2 = SWIG_NEWOBJ;
31437 }
31438 }
31439 {
31440 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31441 temp3 = SWIG_As_int(obj2);
31442 if (SWIG_arg_fail(3)) SWIG_fail;
31443 arg3 = &temp3;
31444 res3 = SWIG_NEWOBJ;
31445 }
31446 }
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31450
31451 wxPyEndAllowThreads(__tstate);
31452 if (PyErr_Occurred()) SWIG_fail;
31453 }
31454 Py_INCREF(Py_None); resultobj = Py_None;
31455 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31456 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31457 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31458 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31466 PyObject *resultobj = NULL;
31467 wxWindow *arg1 = (wxWindow *) 0 ;
31468 wxPoint *arg2 = 0 ;
31469 wxPoint result;
31470 wxPoint temp2 ;
31471 PyObject * obj0 = 0 ;
31472 PyObject * obj1 = 0 ;
31473 char *kwnames[] = {
31474 (char *) "self",(char *) "pt", NULL
31475 };
31476
31477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31479 if (SWIG_arg_fail(1)) SWIG_fail;
31480 {
31481 arg2 = &temp2;
31482 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31483 }
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31487
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 {
31492 wxPoint * resultptr;
31493 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31495 }
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31503 PyObject *resultobj = NULL;
31504 wxWindow *arg1 = (wxWindow *) 0 ;
31505 wxPoint *arg2 = 0 ;
31506 wxPoint result;
31507 wxPoint temp2 ;
31508 PyObject * obj0 = 0 ;
31509 PyObject * obj1 = 0 ;
31510 char *kwnames[] = {
31511 (char *) "self",(char *) "pt", NULL
31512 };
31513
31514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31516 if (SWIG_arg_fail(1)) SWIG_fail;
31517 {
31518 arg2 = &temp2;
31519 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31520 }
31521 {
31522 PyThreadState* __tstate = wxPyBeginAllowThreads();
31523 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31524
31525 wxPyEndAllowThreads(__tstate);
31526 if (PyErr_Occurred()) SWIG_fail;
31527 }
31528 {
31529 wxPoint * resultptr;
31530 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31532 }
31533 return resultobj;
31534 fail:
31535 return NULL;
31536 }
31537
31538
31539 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31540 PyObject *resultobj = NULL;
31541 wxWindow *arg1 = (wxWindow *) 0 ;
31542 int arg2 ;
31543 int arg3 ;
31544 wxHitTest result;
31545 PyObject * obj0 = 0 ;
31546 PyObject * obj1 = 0 ;
31547 PyObject * obj2 = 0 ;
31548 char *kwnames[] = {
31549 (char *) "self",(char *) "x",(char *) "y", NULL
31550 };
31551
31552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31554 if (SWIG_arg_fail(1)) SWIG_fail;
31555 {
31556 arg2 = static_cast<int >(SWIG_As_int(obj1));
31557 if (SWIG_arg_fail(2)) SWIG_fail;
31558 }
31559 {
31560 arg3 = static_cast<int >(SWIG_As_int(obj2));
31561 if (SWIG_arg_fail(3)) SWIG_fail;
31562 }
31563 {
31564 PyThreadState* __tstate = wxPyBeginAllowThreads();
31565 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31566
31567 wxPyEndAllowThreads(__tstate);
31568 if (PyErr_Occurred()) SWIG_fail;
31569 }
31570 resultobj = SWIG_From_int((result));
31571 return resultobj;
31572 fail:
31573 return NULL;
31574 }
31575
31576
31577 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31578 PyObject *resultobj = NULL;
31579 wxWindow *arg1 = (wxWindow *) 0 ;
31580 wxPoint *arg2 = 0 ;
31581 wxHitTest result;
31582 wxPoint temp2 ;
31583 PyObject * obj0 = 0 ;
31584 PyObject * obj1 = 0 ;
31585 char *kwnames[] = {
31586 (char *) "self",(char *) "pt", NULL
31587 };
31588
31589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31591 if (SWIG_arg_fail(1)) SWIG_fail;
31592 {
31593 arg2 = &temp2;
31594 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31595 }
31596 {
31597 PyThreadState* __tstate = wxPyBeginAllowThreads();
31598 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31599
31600 wxPyEndAllowThreads(__tstate);
31601 if (PyErr_Occurred()) SWIG_fail;
31602 }
31603 resultobj = SWIG_From_int((result));
31604 return resultobj;
31605 fail:
31606 return NULL;
31607 }
31608
31609
31610 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31611 PyObject *resultobj = NULL;
31612 wxWindow *arg1 = (wxWindow *) 0 ;
31613 long arg2 ;
31614 wxBorder result;
31615 PyObject * obj0 = 0 ;
31616 PyObject * obj1 = 0 ;
31617
31618 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31620 if (SWIG_arg_fail(1)) SWIG_fail;
31621 {
31622 arg2 = static_cast<long >(SWIG_As_long(obj1));
31623 if (SWIG_arg_fail(2)) SWIG_fail;
31624 }
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31628
31629 wxPyEndAllowThreads(__tstate);
31630 if (PyErr_Occurred()) SWIG_fail;
31631 }
31632 resultobj = SWIG_From_int((result));
31633 return resultobj;
31634 fail:
31635 return NULL;
31636 }
31637
31638
31639 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31640 PyObject *resultobj = NULL;
31641 wxWindow *arg1 = (wxWindow *) 0 ;
31642 wxBorder result;
31643 PyObject * obj0 = 0 ;
31644
31645 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31647 if (SWIG_arg_fail(1)) SWIG_fail;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31651
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 resultobj = SWIG_From_int((result));
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31663 int argc;
31664 PyObject *argv[3];
31665 int ii;
31666
31667 argc = PyObject_Length(args);
31668 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31669 argv[ii] = PyTuple_GetItem(args,ii);
31670 }
31671 if (argc == 1) {
31672 int _v;
31673 {
31674 void *ptr;
31675 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31676 _v = 0;
31677 PyErr_Clear();
31678 } else {
31679 _v = 1;
31680 }
31681 }
31682 if (_v) {
31683 return _wrap_Window_GetBorder__SWIG_1(self,args);
31684 }
31685 }
31686 if (argc == 2) {
31687 int _v;
31688 {
31689 void *ptr;
31690 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31691 _v = 0;
31692 PyErr_Clear();
31693 } else {
31694 _v = 1;
31695 }
31696 }
31697 if (_v) {
31698 _v = SWIG_Check_long(argv[1]);
31699 if (_v) {
31700 return _wrap_Window_GetBorder__SWIG_0(self,args);
31701 }
31702 }
31703 }
31704
31705 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31706 return NULL;
31707 }
31708
31709
31710 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31711 PyObject *resultobj = NULL;
31712 wxWindow *arg1 = (wxWindow *) 0 ;
31713 long arg2 = (long) wxUPDATE_UI_NONE ;
31714 PyObject * obj0 = 0 ;
31715 PyObject * obj1 = 0 ;
31716 char *kwnames[] = {
31717 (char *) "self",(char *) "flags", NULL
31718 };
31719
31720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31722 if (SWIG_arg_fail(1)) SWIG_fail;
31723 if (obj1) {
31724 {
31725 arg2 = static_cast<long >(SWIG_As_long(obj1));
31726 if (SWIG_arg_fail(2)) SWIG_fail;
31727 }
31728 }
31729 {
31730 PyThreadState* __tstate = wxPyBeginAllowThreads();
31731 (arg1)->UpdateWindowUI(arg2);
31732
31733 wxPyEndAllowThreads(__tstate);
31734 if (PyErr_Occurred()) SWIG_fail;
31735 }
31736 Py_INCREF(Py_None); resultobj = Py_None;
31737 return resultobj;
31738 fail:
31739 return NULL;
31740 }
31741
31742
31743 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31744 PyObject *resultobj = NULL;
31745 wxWindow *arg1 = (wxWindow *) 0 ;
31746 wxMenu *arg2 = (wxMenu *) 0 ;
31747 int arg3 = (int) -1 ;
31748 int arg4 = (int) -1 ;
31749 bool result;
31750 PyObject * obj0 = 0 ;
31751 PyObject * obj1 = 0 ;
31752 PyObject * obj2 = 0 ;
31753 PyObject * obj3 = 0 ;
31754 char *kwnames[] = {
31755 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31756 };
31757
31758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31760 if (SWIG_arg_fail(1)) SWIG_fail;
31761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31762 if (SWIG_arg_fail(2)) SWIG_fail;
31763 if (obj2) {
31764 {
31765 arg3 = static_cast<int >(SWIG_As_int(obj2));
31766 if (SWIG_arg_fail(3)) SWIG_fail;
31767 }
31768 }
31769 if (obj3) {
31770 {
31771 arg4 = static_cast<int >(SWIG_As_int(obj3));
31772 if (SWIG_arg_fail(4)) SWIG_fail;
31773 }
31774 }
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31778
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 {
31783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31784 }
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31792 PyObject *resultobj = NULL;
31793 wxWindow *arg1 = (wxWindow *) 0 ;
31794 wxMenu *arg2 = (wxMenu *) 0 ;
31795 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31796 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31797 bool result;
31798 wxPoint temp3 ;
31799 PyObject * obj0 = 0 ;
31800 PyObject * obj1 = 0 ;
31801 PyObject * obj2 = 0 ;
31802 char *kwnames[] = {
31803 (char *) "self",(char *) "menu",(char *) "pos", NULL
31804 };
31805
31806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31808 if (SWIG_arg_fail(1)) SWIG_fail;
31809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31810 if (SWIG_arg_fail(2)) SWIG_fail;
31811 if (obj2) {
31812 {
31813 arg3 = &temp3;
31814 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31815 }
31816 }
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31820
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 {
31825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31826 }
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31834 PyObject *resultobj = NULL;
31835 wxWindow *arg1 = (wxWindow *) 0 ;
31836 long result;
31837 PyObject * obj0 = 0 ;
31838 char *kwnames[] = {
31839 (char *) "self", NULL
31840 };
31841
31842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31844 if (SWIG_arg_fail(1)) SWIG_fail;
31845 {
31846 PyThreadState* __tstate = wxPyBeginAllowThreads();
31847 result = (long)wxWindow_GetHandle(arg1);
31848
31849 wxPyEndAllowThreads(__tstate);
31850 if (PyErr_Occurred()) SWIG_fail;
31851 }
31852 {
31853 resultobj = SWIG_From_long(static_cast<long >(result));
31854 }
31855 return resultobj;
31856 fail:
31857 return NULL;
31858 }
31859
31860
31861 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31862 PyObject *resultobj = NULL;
31863 wxWindow *arg1 = (wxWindow *) 0 ;
31864 long arg2 ;
31865 PyObject * obj0 = 0 ;
31866 PyObject * obj1 = 0 ;
31867 char *kwnames[] = {
31868 (char *) "self",(char *) "handle", NULL
31869 };
31870
31871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31873 if (SWIG_arg_fail(1)) SWIG_fail;
31874 {
31875 arg2 = static_cast<long >(SWIG_As_long(obj1));
31876 if (SWIG_arg_fail(2)) SWIG_fail;
31877 }
31878 {
31879 PyThreadState* __tstate = wxPyBeginAllowThreads();
31880 wxWindow_AssociateHandle(arg1,arg2);
31881
31882 wxPyEndAllowThreads(__tstate);
31883 if (PyErr_Occurred()) SWIG_fail;
31884 }
31885 Py_INCREF(Py_None); resultobj = Py_None;
31886 return resultobj;
31887 fail:
31888 return NULL;
31889 }
31890
31891
31892 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31893 PyObject *resultobj = NULL;
31894 wxWindow *arg1 = (wxWindow *) 0 ;
31895 PyObject * obj0 = 0 ;
31896 char *kwnames[] = {
31897 (char *) "self", NULL
31898 };
31899
31900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31902 if (SWIG_arg_fail(1)) SWIG_fail;
31903 {
31904 PyThreadState* __tstate = wxPyBeginAllowThreads();
31905 (arg1)->DissociateHandle();
31906
31907 wxPyEndAllowThreads(__tstate);
31908 if (PyErr_Occurred()) SWIG_fail;
31909 }
31910 Py_INCREF(Py_None); resultobj = Py_None;
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31918 PyObject *resultobj = NULL;
31919 wxWindow *arg1 = (wxWindow *) 0 ;
31920 int arg2 ;
31921 bool result;
31922 PyObject * obj0 = 0 ;
31923 PyObject * obj1 = 0 ;
31924 char *kwnames[] = {
31925 (char *) "self",(char *) "orient", NULL
31926 };
31927
31928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31930 if (SWIG_arg_fail(1)) SWIG_fail;
31931 {
31932 arg2 = static_cast<int >(SWIG_As_int(obj1));
31933 if (SWIG_arg_fail(2)) SWIG_fail;
31934 }
31935 {
31936 PyThreadState* __tstate = wxPyBeginAllowThreads();
31937 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31938
31939 wxPyEndAllowThreads(__tstate);
31940 if (PyErr_Occurred()) SWIG_fail;
31941 }
31942 {
31943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31944 }
31945 return resultobj;
31946 fail:
31947 return NULL;
31948 }
31949
31950
31951 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31952 PyObject *resultobj = NULL;
31953 wxWindow *arg1 = (wxWindow *) 0 ;
31954 int arg2 ;
31955 int arg3 ;
31956 int arg4 ;
31957 int arg5 ;
31958 bool arg6 = (bool) true ;
31959 PyObject * obj0 = 0 ;
31960 PyObject * obj1 = 0 ;
31961 PyObject * obj2 = 0 ;
31962 PyObject * obj3 = 0 ;
31963 PyObject * obj4 = 0 ;
31964 PyObject * obj5 = 0 ;
31965 char *kwnames[] = {
31966 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31967 };
31968
31969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31971 if (SWIG_arg_fail(1)) SWIG_fail;
31972 {
31973 arg2 = static_cast<int >(SWIG_As_int(obj1));
31974 if (SWIG_arg_fail(2)) SWIG_fail;
31975 }
31976 {
31977 arg3 = static_cast<int >(SWIG_As_int(obj2));
31978 if (SWIG_arg_fail(3)) SWIG_fail;
31979 }
31980 {
31981 arg4 = static_cast<int >(SWIG_As_int(obj3));
31982 if (SWIG_arg_fail(4)) SWIG_fail;
31983 }
31984 {
31985 arg5 = static_cast<int >(SWIG_As_int(obj4));
31986 if (SWIG_arg_fail(5)) SWIG_fail;
31987 }
31988 if (obj5) {
31989 {
31990 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31991 if (SWIG_arg_fail(6)) SWIG_fail;
31992 }
31993 }
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31997
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 Py_INCREF(Py_None); resultobj = Py_None;
32002 return resultobj;
32003 fail:
32004 return NULL;
32005 }
32006
32007
32008 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
32009 PyObject *resultobj = NULL;
32010 wxWindow *arg1 = (wxWindow *) 0 ;
32011 int arg2 ;
32012 int arg3 ;
32013 bool arg4 = (bool) true ;
32014 PyObject * obj0 = 0 ;
32015 PyObject * obj1 = 0 ;
32016 PyObject * obj2 = 0 ;
32017 PyObject * obj3 = 0 ;
32018 char *kwnames[] = {
32019 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
32020 };
32021
32022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32024 if (SWIG_arg_fail(1)) SWIG_fail;
32025 {
32026 arg2 = static_cast<int >(SWIG_As_int(obj1));
32027 if (SWIG_arg_fail(2)) SWIG_fail;
32028 }
32029 {
32030 arg3 = static_cast<int >(SWIG_As_int(obj2));
32031 if (SWIG_arg_fail(3)) SWIG_fail;
32032 }
32033 if (obj3) {
32034 {
32035 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
32036 if (SWIG_arg_fail(4)) SWIG_fail;
32037 }
32038 }
32039 {
32040 PyThreadState* __tstate = wxPyBeginAllowThreads();
32041 (arg1)->SetScrollPos(arg2,arg3,arg4);
32042
32043 wxPyEndAllowThreads(__tstate);
32044 if (PyErr_Occurred()) SWIG_fail;
32045 }
32046 Py_INCREF(Py_None); resultobj = Py_None;
32047 return resultobj;
32048 fail:
32049 return NULL;
32050 }
32051
32052
32053 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
32054 PyObject *resultobj = NULL;
32055 wxWindow *arg1 = (wxWindow *) 0 ;
32056 int arg2 ;
32057 int result;
32058 PyObject * obj0 = 0 ;
32059 PyObject * obj1 = 0 ;
32060 char *kwnames[] = {
32061 (char *) "self",(char *) "orientation", NULL
32062 };
32063
32064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
32065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32066 if (SWIG_arg_fail(1)) SWIG_fail;
32067 {
32068 arg2 = static_cast<int >(SWIG_As_int(obj1));
32069 if (SWIG_arg_fail(2)) SWIG_fail;
32070 }
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
32074
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 {
32079 resultobj = SWIG_From_int(static_cast<int >(result));
32080 }
32081 return resultobj;
32082 fail:
32083 return NULL;
32084 }
32085
32086
32087 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
32088 PyObject *resultobj = NULL;
32089 wxWindow *arg1 = (wxWindow *) 0 ;
32090 int arg2 ;
32091 int result;
32092 PyObject * obj0 = 0 ;
32093 PyObject * obj1 = 0 ;
32094 char *kwnames[] = {
32095 (char *) "self",(char *) "orientation", NULL
32096 };
32097
32098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
32099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32100 if (SWIG_arg_fail(1)) SWIG_fail;
32101 {
32102 arg2 = static_cast<int >(SWIG_As_int(obj1));
32103 if (SWIG_arg_fail(2)) SWIG_fail;
32104 }
32105 {
32106 PyThreadState* __tstate = wxPyBeginAllowThreads();
32107 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
32108
32109 wxPyEndAllowThreads(__tstate);
32110 if (PyErr_Occurred()) SWIG_fail;
32111 }
32112 {
32113 resultobj = SWIG_From_int(static_cast<int >(result));
32114 }
32115 return resultobj;
32116 fail:
32117 return NULL;
32118 }
32119
32120
32121 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
32122 PyObject *resultobj = NULL;
32123 wxWindow *arg1 = (wxWindow *) 0 ;
32124 int arg2 ;
32125 int result;
32126 PyObject * obj0 = 0 ;
32127 PyObject * obj1 = 0 ;
32128 char *kwnames[] = {
32129 (char *) "self",(char *) "orientation", NULL
32130 };
32131
32132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32134 if (SWIG_arg_fail(1)) SWIG_fail;
32135 {
32136 arg2 = static_cast<int >(SWIG_As_int(obj1));
32137 if (SWIG_arg_fail(2)) SWIG_fail;
32138 }
32139 {
32140 PyThreadState* __tstate = wxPyBeginAllowThreads();
32141 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32142
32143 wxPyEndAllowThreads(__tstate);
32144 if (PyErr_Occurred()) SWIG_fail;
32145 }
32146 {
32147 resultobj = SWIG_From_int(static_cast<int >(result));
32148 }
32149 return resultobj;
32150 fail:
32151 return NULL;
32152 }
32153
32154
32155 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32156 PyObject *resultobj = NULL;
32157 wxWindow *arg1 = (wxWindow *) 0 ;
32158 int arg2 ;
32159 int arg3 ;
32160 wxRect *arg4 = (wxRect *) NULL ;
32161 PyObject * obj0 = 0 ;
32162 PyObject * obj1 = 0 ;
32163 PyObject * obj2 = 0 ;
32164 PyObject * obj3 = 0 ;
32165 char *kwnames[] = {
32166 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32167 };
32168
32169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32171 if (SWIG_arg_fail(1)) SWIG_fail;
32172 {
32173 arg2 = static_cast<int >(SWIG_As_int(obj1));
32174 if (SWIG_arg_fail(2)) SWIG_fail;
32175 }
32176 {
32177 arg3 = static_cast<int >(SWIG_As_int(obj2));
32178 if (SWIG_arg_fail(3)) SWIG_fail;
32179 }
32180 if (obj3) {
32181 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32182 if (SWIG_arg_fail(4)) SWIG_fail;
32183 }
32184 {
32185 PyThreadState* __tstate = wxPyBeginAllowThreads();
32186 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32187
32188 wxPyEndAllowThreads(__tstate);
32189 if (PyErr_Occurred()) SWIG_fail;
32190 }
32191 Py_INCREF(Py_None); resultobj = Py_None;
32192 return resultobj;
32193 fail:
32194 return NULL;
32195 }
32196
32197
32198 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32199 PyObject *resultobj = NULL;
32200 wxWindow *arg1 = (wxWindow *) 0 ;
32201 int arg2 ;
32202 bool result;
32203 PyObject * obj0 = 0 ;
32204 PyObject * obj1 = 0 ;
32205 char *kwnames[] = {
32206 (char *) "self",(char *) "lines", NULL
32207 };
32208
32209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32211 if (SWIG_arg_fail(1)) SWIG_fail;
32212 {
32213 arg2 = static_cast<int >(SWIG_As_int(obj1));
32214 if (SWIG_arg_fail(2)) SWIG_fail;
32215 }
32216 {
32217 PyThreadState* __tstate = wxPyBeginAllowThreads();
32218 result = (bool)(arg1)->ScrollLines(arg2);
32219
32220 wxPyEndAllowThreads(__tstate);
32221 if (PyErr_Occurred()) SWIG_fail;
32222 }
32223 {
32224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32225 }
32226 return resultobj;
32227 fail:
32228 return NULL;
32229 }
32230
32231
32232 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32233 PyObject *resultobj = NULL;
32234 wxWindow *arg1 = (wxWindow *) 0 ;
32235 int arg2 ;
32236 bool result;
32237 PyObject * obj0 = 0 ;
32238 PyObject * obj1 = 0 ;
32239 char *kwnames[] = {
32240 (char *) "self",(char *) "pages", NULL
32241 };
32242
32243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32245 if (SWIG_arg_fail(1)) SWIG_fail;
32246 {
32247 arg2 = static_cast<int >(SWIG_As_int(obj1));
32248 if (SWIG_arg_fail(2)) SWIG_fail;
32249 }
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = (bool)(arg1)->ScrollPages(arg2);
32253
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 {
32258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32259 }
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32267 PyObject *resultobj = NULL;
32268 wxWindow *arg1 = (wxWindow *) 0 ;
32269 bool result;
32270 PyObject * obj0 = 0 ;
32271 char *kwnames[] = {
32272 (char *) "self", NULL
32273 };
32274
32275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32277 if (SWIG_arg_fail(1)) SWIG_fail;
32278 {
32279 PyThreadState* __tstate = wxPyBeginAllowThreads();
32280 result = (bool)(arg1)->LineUp();
32281
32282 wxPyEndAllowThreads(__tstate);
32283 if (PyErr_Occurred()) SWIG_fail;
32284 }
32285 {
32286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32287 }
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32295 PyObject *resultobj = NULL;
32296 wxWindow *arg1 = (wxWindow *) 0 ;
32297 bool result;
32298 PyObject * obj0 = 0 ;
32299 char *kwnames[] = {
32300 (char *) "self", NULL
32301 };
32302
32303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32305 if (SWIG_arg_fail(1)) SWIG_fail;
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 result = (bool)(arg1)->LineDown();
32309
32310 wxPyEndAllowThreads(__tstate);
32311 if (PyErr_Occurred()) SWIG_fail;
32312 }
32313 {
32314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32315 }
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32323 PyObject *resultobj = NULL;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 bool result;
32326 PyObject * obj0 = 0 ;
32327 char *kwnames[] = {
32328 (char *) "self", NULL
32329 };
32330
32331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32333 if (SWIG_arg_fail(1)) SWIG_fail;
32334 {
32335 PyThreadState* __tstate = wxPyBeginAllowThreads();
32336 result = (bool)(arg1)->PageUp();
32337
32338 wxPyEndAllowThreads(__tstate);
32339 if (PyErr_Occurred()) SWIG_fail;
32340 }
32341 {
32342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32343 }
32344 return resultobj;
32345 fail:
32346 return NULL;
32347 }
32348
32349
32350 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32351 PyObject *resultobj = NULL;
32352 wxWindow *arg1 = (wxWindow *) 0 ;
32353 bool result;
32354 PyObject * obj0 = 0 ;
32355 char *kwnames[] = {
32356 (char *) "self", NULL
32357 };
32358
32359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32361 if (SWIG_arg_fail(1)) SWIG_fail;
32362 {
32363 PyThreadState* __tstate = wxPyBeginAllowThreads();
32364 result = (bool)(arg1)->PageDown();
32365
32366 wxPyEndAllowThreads(__tstate);
32367 if (PyErr_Occurred()) SWIG_fail;
32368 }
32369 {
32370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32371 }
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32379 PyObject *resultobj = NULL;
32380 wxWindow *arg1 = (wxWindow *) 0 ;
32381 wxString *arg2 = 0 ;
32382 bool temp2 = false ;
32383 PyObject * obj0 = 0 ;
32384 PyObject * obj1 = 0 ;
32385 char *kwnames[] = {
32386 (char *) "self",(char *) "text", NULL
32387 };
32388
32389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32391 if (SWIG_arg_fail(1)) SWIG_fail;
32392 {
32393 arg2 = wxString_in_helper(obj1);
32394 if (arg2 == NULL) SWIG_fail;
32395 temp2 = true;
32396 }
32397 {
32398 PyThreadState* __tstate = wxPyBeginAllowThreads();
32399 (arg1)->SetHelpText((wxString const &)*arg2);
32400
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 Py_INCREF(Py_None); resultobj = Py_None;
32405 {
32406 if (temp2)
32407 delete arg2;
32408 }
32409 return resultobj;
32410 fail:
32411 {
32412 if (temp2)
32413 delete arg2;
32414 }
32415 return NULL;
32416 }
32417
32418
32419 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32420 PyObject *resultobj = NULL;
32421 wxWindow *arg1 = (wxWindow *) 0 ;
32422 wxString *arg2 = 0 ;
32423 bool temp2 = false ;
32424 PyObject * obj0 = 0 ;
32425 PyObject * obj1 = 0 ;
32426 char *kwnames[] = {
32427 (char *) "self",(char *) "text", NULL
32428 };
32429
32430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32432 if (SWIG_arg_fail(1)) SWIG_fail;
32433 {
32434 arg2 = wxString_in_helper(obj1);
32435 if (arg2 == NULL) SWIG_fail;
32436 temp2 = true;
32437 }
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32441
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 Py_INCREF(Py_None); resultobj = Py_None;
32446 {
32447 if (temp2)
32448 delete arg2;
32449 }
32450 return resultobj;
32451 fail:
32452 {
32453 if (temp2)
32454 delete arg2;
32455 }
32456 return NULL;
32457 }
32458
32459
32460 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32461 PyObject *resultobj = NULL;
32462 wxWindow *arg1 = (wxWindow *) 0 ;
32463 wxString result;
32464 PyObject * obj0 = 0 ;
32465 char *kwnames[] = {
32466 (char *) "self", NULL
32467 };
32468
32469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32471 if (SWIG_arg_fail(1)) SWIG_fail;
32472 {
32473 PyThreadState* __tstate = wxPyBeginAllowThreads();
32474 result = ((wxWindow const *)arg1)->GetHelpText();
32475
32476 wxPyEndAllowThreads(__tstate);
32477 if (PyErr_Occurred()) SWIG_fail;
32478 }
32479 {
32480 #if wxUSE_UNICODE
32481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32482 #else
32483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32484 #endif
32485 }
32486 return resultobj;
32487 fail:
32488 return NULL;
32489 }
32490
32491
32492 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32493 PyObject *resultobj = NULL;
32494 wxWindow *arg1 = (wxWindow *) 0 ;
32495 wxString *arg2 = 0 ;
32496 bool temp2 = false ;
32497 PyObject * obj0 = 0 ;
32498 PyObject * obj1 = 0 ;
32499 char *kwnames[] = {
32500 (char *) "self",(char *) "tip", NULL
32501 };
32502
32503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32505 if (SWIG_arg_fail(1)) SWIG_fail;
32506 {
32507 arg2 = wxString_in_helper(obj1);
32508 if (arg2 == NULL) SWIG_fail;
32509 temp2 = true;
32510 }
32511 {
32512 PyThreadState* __tstate = wxPyBeginAllowThreads();
32513 (arg1)->SetToolTip((wxString const &)*arg2);
32514
32515 wxPyEndAllowThreads(__tstate);
32516 if (PyErr_Occurred()) SWIG_fail;
32517 }
32518 Py_INCREF(Py_None); resultobj = Py_None;
32519 {
32520 if (temp2)
32521 delete arg2;
32522 }
32523 return resultobj;
32524 fail:
32525 {
32526 if (temp2)
32527 delete arg2;
32528 }
32529 return NULL;
32530 }
32531
32532
32533 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32534 PyObject *resultobj = NULL;
32535 wxWindow *arg1 = (wxWindow *) 0 ;
32536 wxToolTip *arg2 = (wxToolTip *) 0 ;
32537 PyObject * obj0 = 0 ;
32538 PyObject * obj1 = 0 ;
32539 char *kwnames[] = {
32540 (char *) "self",(char *) "tip", NULL
32541 };
32542
32543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32545 if (SWIG_arg_fail(1)) SWIG_fail;
32546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32547 if (SWIG_arg_fail(2)) SWIG_fail;
32548 {
32549 PyThreadState* __tstate = wxPyBeginAllowThreads();
32550 (arg1)->SetToolTip(arg2);
32551
32552 wxPyEndAllowThreads(__tstate);
32553 if (PyErr_Occurred()) SWIG_fail;
32554 }
32555 Py_INCREF(Py_None); resultobj = Py_None;
32556 return resultobj;
32557 fail:
32558 return NULL;
32559 }
32560
32561
32562 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32563 PyObject *resultobj = NULL;
32564 wxWindow *arg1 = (wxWindow *) 0 ;
32565 wxToolTip *result;
32566 PyObject * obj0 = 0 ;
32567 char *kwnames[] = {
32568 (char *) "self", NULL
32569 };
32570
32571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32573 if (SWIG_arg_fail(1)) SWIG_fail;
32574 {
32575 PyThreadState* __tstate = wxPyBeginAllowThreads();
32576 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32577
32578 wxPyEndAllowThreads(__tstate);
32579 if (PyErr_Occurred()) SWIG_fail;
32580 }
32581 {
32582 resultobj = wxPyMake_wxObject(result, (bool)0);
32583 }
32584 return resultobj;
32585 fail:
32586 return NULL;
32587 }
32588
32589
32590 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32591 PyObject *resultobj = NULL;
32592 wxWindow *arg1 = (wxWindow *) 0 ;
32593 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32594 PyObject * obj0 = 0 ;
32595 PyObject * obj1 = 0 ;
32596 char *kwnames[] = {
32597 (char *) "self",(char *) "dropTarget", NULL
32598 };
32599
32600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32602 if (SWIG_arg_fail(1)) SWIG_fail;
32603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32604 if (SWIG_arg_fail(2)) SWIG_fail;
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 (arg1)->SetDropTarget(arg2);
32608
32609 wxPyEndAllowThreads(__tstate);
32610 if (PyErr_Occurred()) SWIG_fail;
32611 }
32612 Py_INCREF(Py_None); resultobj = Py_None;
32613 return resultobj;
32614 fail:
32615 return NULL;
32616 }
32617
32618
32619 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32620 PyObject *resultobj = NULL;
32621 wxWindow *arg1 = (wxWindow *) 0 ;
32622 wxPyDropTarget *result;
32623 PyObject * obj0 = 0 ;
32624 char *kwnames[] = {
32625 (char *) "self", NULL
32626 };
32627
32628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32630 if (SWIG_arg_fail(1)) SWIG_fail;
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32634
32635 wxPyEndAllowThreads(__tstate);
32636 if (PyErr_Occurred()) SWIG_fail;
32637 }
32638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32639 return resultobj;
32640 fail:
32641 return NULL;
32642 }
32643
32644
32645 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32646 PyObject *resultobj = NULL;
32647 wxWindow *arg1 = (wxWindow *) 0 ;
32648 bool arg2 ;
32649 PyObject * obj0 = 0 ;
32650 PyObject * obj1 = 0 ;
32651 char *kwnames[] = {
32652 (char *) "self",(char *) "accept", NULL
32653 };
32654
32655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32657 if (SWIG_arg_fail(1)) SWIG_fail;
32658 {
32659 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32660 if (SWIG_arg_fail(2)) SWIG_fail;
32661 }
32662 {
32663 PyThreadState* __tstate = wxPyBeginAllowThreads();
32664 wxWindow_DragAcceptFiles(arg1,arg2);
32665
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 Py_INCREF(Py_None); resultobj = Py_None;
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32677 PyObject *resultobj = NULL;
32678 wxWindow *arg1 = (wxWindow *) 0 ;
32679 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32680 PyObject * obj0 = 0 ;
32681 PyObject * obj1 = 0 ;
32682 char *kwnames[] = {
32683 (char *) "self",(char *) "constraints", NULL
32684 };
32685
32686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32688 if (SWIG_arg_fail(1)) SWIG_fail;
32689 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32690 if (SWIG_arg_fail(2)) SWIG_fail;
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 (arg1)->SetConstraints(arg2);
32694
32695 wxPyEndAllowThreads(__tstate);
32696 if (PyErr_Occurred()) SWIG_fail;
32697 }
32698 Py_INCREF(Py_None); resultobj = Py_None;
32699 return resultobj;
32700 fail:
32701 return NULL;
32702 }
32703
32704
32705 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32706 PyObject *resultobj = NULL;
32707 wxWindow *arg1 = (wxWindow *) 0 ;
32708 wxLayoutConstraints *result;
32709 PyObject * obj0 = 0 ;
32710 char *kwnames[] = {
32711 (char *) "self", NULL
32712 };
32713
32714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32716 if (SWIG_arg_fail(1)) SWIG_fail;
32717 {
32718 PyThreadState* __tstate = wxPyBeginAllowThreads();
32719 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32720
32721 wxPyEndAllowThreads(__tstate);
32722 if (PyErr_Occurred()) SWIG_fail;
32723 }
32724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32725 return resultobj;
32726 fail:
32727 return NULL;
32728 }
32729
32730
32731 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32732 PyObject *resultobj = NULL;
32733 wxWindow *arg1 = (wxWindow *) 0 ;
32734 bool arg2 ;
32735 PyObject * obj0 = 0 ;
32736 PyObject * obj1 = 0 ;
32737 char *kwnames[] = {
32738 (char *) "self",(char *) "autoLayout", NULL
32739 };
32740
32741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32743 if (SWIG_arg_fail(1)) SWIG_fail;
32744 {
32745 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32746 if (SWIG_arg_fail(2)) SWIG_fail;
32747 }
32748 {
32749 PyThreadState* __tstate = wxPyBeginAllowThreads();
32750 (arg1)->SetAutoLayout(arg2);
32751
32752 wxPyEndAllowThreads(__tstate);
32753 if (PyErr_Occurred()) SWIG_fail;
32754 }
32755 Py_INCREF(Py_None); resultobj = Py_None;
32756 return resultobj;
32757 fail:
32758 return NULL;
32759 }
32760
32761
32762 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32763 PyObject *resultobj = NULL;
32764 wxWindow *arg1 = (wxWindow *) 0 ;
32765 bool result;
32766 PyObject * obj0 = 0 ;
32767 char *kwnames[] = {
32768 (char *) "self", NULL
32769 };
32770
32771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32773 if (SWIG_arg_fail(1)) SWIG_fail;
32774 {
32775 PyThreadState* __tstate = wxPyBeginAllowThreads();
32776 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32777
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 {
32782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32783 }
32784 return resultobj;
32785 fail:
32786 return NULL;
32787 }
32788
32789
32790 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32791 PyObject *resultobj = NULL;
32792 wxWindow *arg1 = (wxWindow *) 0 ;
32793 bool result;
32794 PyObject * obj0 = 0 ;
32795 char *kwnames[] = {
32796 (char *) "self", NULL
32797 };
32798
32799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32801 if (SWIG_arg_fail(1)) SWIG_fail;
32802 {
32803 PyThreadState* __tstate = wxPyBeginAllowThreads();
32804 result = (bool)(arg1)->Layout();
32805
32806 wxPyEndAllowThreads(__tstate);
32807 if (PyErr_Occurred()) SWIG_fail;
32808 }
32809 {
32810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32811 }
32812 return resultobj;
32813 fail:
32814 return NULL;
32815 }
32816
32817
32818 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32819 PyObject *resultobj = NULL;
32820 wxWindow *arg1 = (wxWindow *) 0 ;
32821 wxSizer *arg2 = (wxSizer *) 0 ;
32822 bool arg3 = (bool) true ;
32823 PyObject * obj0 = 0 ;
32824 PyObject * obj1 = 0 ;
32825 PyObject * obj2 = 0 ;
32826 char *kwnames[] = {
32827 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32828 };
32829
32830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32832 if (SWIG_arg_fail(1)) SWIG_fail;
32833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32834 if (SWIG_arg_fail(2)) SWIG_fail;
32835 if (obj2) {
32836 {
32837 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32838 if (SWIG_arg_fail(3)) SWIG_fail;
32839 }
32840 }
32841 {
32842 PyThreadState* __tstate = wxPyBeginAllowThreads();
32843 (arg1)->SetSizer(arg2,arg3);
32844
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 Py_INCREF(Py_None); resultobj = Py_None;
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32856 PyObject *resultobj = NULL;
32857 wxWindow *arg1 = (wxWindow *) 0 ;
32858 wxSizer *arg2 = (wxSizer *) 0 ;
32859 bool arg3 = (bool) true ;
32860 PyObject * obj0 = 0 ;
32861 PyObject * obj1 = 0 ;
32862 PyObject * obj2 = 0 ;
32863 char *kwnames[] = {
32864 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32865 };
32866
32867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32869 if (SWIG_arg_fail(1)) SWIG_fail;
32870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32871 if (SWIG_arg_fail(2)) SWIG_fail;
32872 if (obj2) {
32873 {
32874 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32875 if (SWIG_arg_fail(3)) SWIG_fail;
32876 }
32877 }
32878 {
32879 PyThreadState* __tstate = wxPyBeginAllowThreads();
32880 (arg1)->SetSizerAndFit(arg2,arg3);
32881
32882 wxPyEndAllowThreads(__tstate);
32883 if (PyErr_Occurred()) SWIG_fail;
32884 }
32885 Py_INCREF(Py_None); resultobj = Py_None;
32886 return resultobj;
32887 fail:
32888 return NULL;
32889 }
32890
32891
32892 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32893 PyObject *resultobj = NULL;
32894 wxWindow *arg1 = (wxWindow *) 0 ;
32895 wxSizer *result;
32896 PyObject * obj0 = 0 ;
32897 char *kwnames[] = {
32898 (char *) "self", NULL
32899 };
32900
32901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32903 if (SWIG_arg_fail(1)) SWIG_fail;
32904 {
32905 PyThreadState* __tstate = wxPyBeginAllowThreads();
32906 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32907
32908 wxPyEndAllowThreads(__tstate);
32909 if (PyErr_Occurred()) SWIG_fail;
32910 }
32911 {
32912 resultobj = wxPyMake_wxObject(result, (bool)0);
32913 }
32914 return resultobj;
32915 fail:
32916 return NULL;
32917 }
32918
32919
32920 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32921 PyObject *resultobj = NULL;
32922 wxWindow *arg1 = (wxWindow *) 0 ;
32923 wxSizer *arg2 = (wxSizer *) 0 ;
32924 PyObject * obj0 = 0 ;
32925 PyObject * obj1 = 0 ;
32926 char *kwnames[] = {
32927 (char *) "self",(char *) "sizer", NULL
32928 };
32929
32930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32932 if (SWIG_arg_fail(1)) SWIG_fail;
32933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32934 if (SWIG_arg_fail(2)) SWIG_fail;
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 (arg1)->SetContainingSizer(arg2);
32938
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 Py_INCREF(Py_None); resultobj = Py_None;
32943 return resultobj;
32944 fail:
32945 return NULL;
32946 }
32947
32948
32949 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32950 PyObject *resultobj = NULL;
32951 wxWindow *arg1 = (wxWindow *) 0 ;
32952 wxSizer *result;
32953 PyObject * obj0 = 0 ;
32954 char *kwnames[] = {
32955 (char *) "self", NULL
32956 };
32957
32958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32960 if (SWIG_arg_fail(1)) SWIG_fail;
32961 {
32962 PyThreadState* __tstate = wxPyBeginAllowThreads();
32963 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32964
32965 wxPyEndAllowThreads(__tstate);
32966 if (PyErr_Occurred()) SWIG_fail;
32967 }
32968 {
32969 resultobj = wxPyMake_wxObject(result, (bool)0);
32970 }
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj = NULL;
32979 wxWindow *arg1 = (wxWindow *) 0 ;
32980 PyObject * obj0 = 0 ;
32981 char *kwnames[] = {
32982 (char *) "self", NULL
32983 };
32984
32985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32987 if (SWIG_arg_fail(1)) SWIG_fail;
32988 {
32989 PyThreadState* __tstate = wxPyBeginAllowThreads();
32990 (arg1)->InheritAttributes();
32991
32992 wxPyEndAllowThreads(__tstate);
32993 if (PyErr_Occurred()) SWIG_fail;
32994 }
32995 Py_INCREF(Py_None); resultobj = Py_None;
32996 return resultobj;
32997 fail:
32998 return NULL;
32999 }
33000
33001
33002 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
33003 PyObject *resultobj = NULL;
33004 wxWindow *arg1 = (wxWindow *) 0 ;
33005 bool result;
33006 PyObject * obj0 = 0 ;
33007 char *kwnames[] = {
33008 (char *) "self", NULL
33009 };
33010
33011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
33012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33013 if (SWIG_arg_fail(1)) SWIG_fail;
33014 {
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
33017
33018 wxPyEndAllowThreads(__tstate);
33019 if (PyErr_Occurred()) SWIG_fail;
33020 }
33021 {
33022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33023 }
33024 return resultobj;
33025 fail:
33026 return NULL;
33027 }
33028
33029
33030 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
33031 PyObject *obj;
33032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33033 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
33034 Py_INCREF(obj);
33035 return Py_BuildValue((char *)"");
33036 }
33037 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
33038 PyObject *resultobj = NULL;
33039 long arg1 ;
33040 wxWindow *arg2 = (wxWindow *) NULL ;
33041 wxWindow *result;
33042 PyObject * obj0 = 0 ;
33043 PyObject * obj1 = 0 ;
33044 char *kwnames[] = {
33045 (char *) "id",(char *) "parent", NULL
33046 };
33047
33048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
33049 {
33050 arg1 = static_cast<long >(SWIG_As_long(obj0));
33051 if (SWIG_arg_fail(1)) SWIG_fail;
33052 }
33053 if (obj1) {
33054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33055 if (SWIG_arg_fail(2)) SWIG_fail;
33056 }
33057 {
33058 if (!wxPyCheckForApp()) SWIG_fail;
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
33061
33062 wxPyEndAllowThreads(__tstate);
33063 if (PyErr_Occurred()) SWIG_fail;
33064 }
33065 {
33066 resultobj = wxPyMake_wxObject(result, 0);
33067 }
33068 return resultobj;
33069 fail:
33070 return NULL;
33071 }
33072
33073
33074 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
33075 PyObject *resultobj = NULL;
33076 wxString *arg1 = 0 ;
33077 wxWindow *arg2 = (wxWindow *) NULL ;
33078 wxWindow *result;
33079 bool temp1 = false ;
33080 PyObject * obj0 = 0 ;
33081 PyObject * obj1 = 0 ;
33082 char *kwnames[] = {
33083 (char *) "name",(char *) "parent", NULL
33084 };
33085
33086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
33087 {
33088 arg1 = wxString_in_helper(obj0);
33089 if (arg1 == NULL) SWIG_fail;
33090 temp1 = true;
33091 }
33092 if (obj1) {
33093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33094 if (SWIG_arg_fail(2)) SWIG_fail;
33095 }
33096 {
33097 if (!wxPyCheckForApp()) SWIG_fail;
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
33100
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 {
33105 resultobj = wxPyMake_wxObject(result, 0);
33106 }
33107 {
33108 if (temp1)
33109 delete arg1;
33110 }
33111 return resultobj;
33112 fail:
33113 {
33114 if (temp1)
33115 delete arg1;
33116 }
33117 return NULL;
33118 }
33119
33120
33121 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33122 PyObject *resultobj = NULL;
33123 wxString *arg1 = 0 ;
33124 wxWindow *arg2 = (wxWindow *) NULL ;
33125 wxWindow *result;
33126 bool temp1 = false ;
33127 PyObject * obj0 = 0 ;
33128 PyObject * obj1 = 0 ;
33129 char *kwnames[] = {
33130 (char *) "label",(char *) "parent", NULL
33131 };
33132
33133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33134 {
33135 arg1 = wxString_in_helper(obj0);
33136 if (arg1 == NULL) SWIG_fail;
33137 temp1 = true;
33138 }
33139 if (obj1) {
33140 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33141 if (SWIG_arg_fail(2)) SWIG_fail;
33142 }
33143 {
33144 if (!wxPyCheckForApp()) SWIG_fail;
33145 PyThreadState* __tstate = wxPyBeginAllowThreads();
33146 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33147
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 {
33152 resultobj = wxPyMake_wxObject(result, 0);
33153 }
33154 {
33155 if (temp1)
33156 delete arg1;
33157 }
33158 return resultobj;
33159 fail:
33160 {
33161 if (temp1)
33162 delete arg1;
33163 }
33164 return NULL;
33165 }
33166
33167
33168 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33169 PyObject *resultobj = NULL;
33170 wxWindow *arg1 = (wxWindow *) 0 ;
33171 unsigned long arg2 ;
33172 wxWindow *result;
33173 PyObject * obj0 = 0 ;
33174 PyObject * obj1 = 0 ;
33175 char *kwnames[] = {
33176 (char *) "parent",(char *) "_hWnd", NULL
33177 };
33178
33179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33181 if (SWIG_arg_fail(1)) SWIG_fail;
33182 {
33183 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33184 if (SWIG_arg_fail(2)) SWIG_fail;
33185 }
33186 {
33187 PyThreadState* __tstate = wxPyBeginAllowThreads();
33188 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33189
33190 wxPyEndAllowThreads(__tstate);
33191 if (PyErr_Occurred()) SWIG_fail;
33192 }
33193 {
33194 resultobj = wxPyMake_wxObject(result, 0);
33195 }
33196 return resultobj;
33197 fail:
33198 return NULL;
33199 }
33200
33201
33202 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33203 PyObject *resultobj = NULL;
33204 PyObject *result;
33205 char *kwnames[] = {
33206 NULL
33207 };
33208
33209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33210 {
33211 PyThreadState* __tstate = wxPyBeginAllowThreads();
33212 result = (PyObject *)GetTopLevelWindows();
33213
33214 wxPyEndAllowThreads(__tstate);
33215 if (PyErr_Occurred()) SWIG_fail;
33216 }
33217 resultobj = result;
33218 return resultobj;
33219 fail:
33220 return NULL;
33221 }
33222
33223
33224 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33225 PyObject *resultobj = NULL;
33226 wxValidator *result;
33227 char *kwnames[] = {
33228 NULL
33229 };
33230
33231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = (wxValidator *)new wxValidator();
33235
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj = NULL;
33248 wxValidator *arg1 = (wxValidator *) 0 ;
33249 wxValidator *result;
33250 PyObject * obj0 = 0 ;
33251 char *kwnames[] = {
33252 (char *) "self", NULL
33253 };
33254
33255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33257 if (SWIG_arg_fail(1)) SWIG_fail;
33258 {
33259 PyThreadState* __tstate = wxPyBeginAllowThreads();
33260 result = (wxValidator *)(arg1)->Clone();
33261
33262 wxPyEndAllowThreads(__tstate);
33263 if (PyErr_Occurred()) SWIG_fail;
33264 }
33265 {
33266 resultobj = wxPyMake_wxObject(result, 0);
33267 }
33268 return resultobj;
33269 fail:
33270 return NULL;
33271 }
33272
33273
33274 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33275 PyObject *resultobj = NULL;
33276 wxValidator *arg1 = (wxValidator *) 0 ;
33277 wxWindow *arg2 = (wxWindow *) 0 ;
33278 bool result;
33279 PyObject * obj0 = 0 ;
33280 PyObject * obj1 = 0 ;
33281 char *kwnames[] = {
33282 (char *) "self",(char *) "parent", NULL
33283 };
33284
33285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33287 if (SWIG_arg_fail(1)) SWIG_fail;
33288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33289 if (SWIG_arg_fail(2)) SWIG_fail;
33290 {
33291 PyThreadState* __tstate = wxPyBeginAllowThreads();
33292 result = (bool)(arg1)->Validate(arg2);
33293
33294 wxPyEndAllowThreads(__tstate);
33295 if (PyErr_Occurred()) SWIG_fail;
33296 }
33297 {
33298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33299 }
33300 return resultobj;
33301 fail:
33302 return NULL;
33303 }
33304
33305
33306 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33307 PyObject *resultobj = NULL;
33308 wxValidator *arg1 = (wxValidator *) 0 ;
33309 bool result;
33310 PyObject * obj0 = 0 ;
33311 char *kwnames[] = {
33312 (char *) "self", NULL
33313 };
33314
33315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33317 if (SWIG_arg_fail(1)) SWIG_fail;
33318 {
33319 PyThreadState* __tstate = wxPyBeginAllowThreads();
33320 result = (bool)(arg1)->TransferToWindow();
33321
33322 wxPyEndAllowThreads(__tstate);
33323 if (PyErr_Occurred()) SWIG_fail;
33324 }
33325 {
33326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33327 }
33328 return resultobj;
33329 fail:
33330 return NULL;
33331 }
33332
33333
33334 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33335 PyObject *resultobj = NULL;
33336 wxValidator *arg1 = (wxValidator *) 0 ;
33337 bool result;
33338 PyObject * obj0 = 0 ;
33339 char *kwnames[] = {
33340 (char *) "self", NULL
33341 };
33342
33343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33345 if (SWIG_arg_fail(1)) SWIG_fail;
33346 {
33347 PyThreadState* __tstate = wxPyBeginAllowThreads();
33348 result = (bool)(arg1)->TransferFromWindow();
33349
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 {
33354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33355 }
33356 return resultobj;
33357 fail:
33358 return NULL;
33359 }
33360
33361
33362 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33363 PyObject *resultobj = NULL;
33364 wxValidator *arg1 = (wxValidator *) 0 ;
33365 wxWindow *result;
33366 PyObject * obj0 = 0 ;
33367 char *kwnames[] = {
33368 (char *) "self", NULL
33369 };
33370
33371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33373 if (SWIG_arg_fail(1)) SWIG_fail;
33374 {
33375 PyThreadState* __tstate = wxPyBeginAllowThreads();
33376 result = (wxWindow *)(arg1)->GetWindow();
33377
33378 wxPyEndAllowThreads(__tstate);
33379 if (PyErr_Occurred()) SWIG_fail;
33380 }
33381 {
33382 resultobj = wxPyMake_wxObject(result, 0);
33383 }
33384 return resultobj;
33385 fail:
33386 return NULL;
33387 }
33388
33389
33390 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33391 PyObject *resultobj = NULL;
33392 wxValidator *arg1 = (wxValidator *) 0 ;
33393 wxWindow *arg2 = (wxWindow *) 0 ;
33394 PyObject * obj0 = 0 ;
33395 PyObject * obj1 = 0 ;
33396 char *kwnames[] = {
33397 (char *) "self",(char *) "window", NULL
33398 };
33399
33400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33402 if (SWIG_arg_fail(1)) SWIG_fail;
33403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33404 if (SWIG_arg_fail(2)) SWIG_fail;
33405 {
33406 PyThreadState* __tstate = wxPyBeginAllowThreads();
33407 (arg1)->SetWindow(arg2);
33408
33409 wxPyEndAllowThreads(__tstate);
33410 if (PyErr_Occurred()) SWIG_fail;
33411 }
33412 Py_INCREF(Py_None); resultobj = Py_None;
33413 return resultobj;
33414 fail:
33415 return NULL;
33416 }
33417
33418
33419 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33420 PyObject *resultobj = NULL;
33421 bool result;
33422 char *kwnames[] = {
33423 NULL
33424 };
33425
33426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 result = (bool)wxValidator::IsSilent();
33430
33431 wxPyEndAllowThreads(__tstate);
33432 if (PyErr_Occurred()) SWIG_fail;
33433 }
33434 {
33435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33436 }
33437 return resultobj;
33438 fail:
33439 return NULL;
33440 }
33441
33442
33443 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33444 PyObject *resultobj = NULL;
33445 int arg1 = (int) true ;
33446 PyObject * obj0 = 0 ;
33447 char *kwnames[] = {
33448 (char *) "doIt", NULL
33449 };
33450
33451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33452 if (obj0) {
33453 {
33454 arg1 = static_cast<int >(SWIG_As_int(obj0));
33455 if (SWIG_arg_fail(1)) SWIG_fail;
33456 }
33457 }
33458 {
33459 PyThreadState* __tstate = wxPyBeginAllowThreads();
33460 wxValidator::SetBellOnError(arg1);
33461
33462 wxPyEndAllowThreads(__tstate);
33463 if (PyErr_Occurred()) SWIG_fail;
33464 }
33465 Py_INCREF(Py_None); resultobj = Py_None;
33466 return resultobj;
33467 fail:
33468 return NULL;
33469 }
33470
33471
33472 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33473 PyObject *obj;
33474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33475 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33476 Py_INCREF(obj);
33477 return Py_BuildValue((char *)"");
33478 }
33479 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj = NULL;
33481 wxPyValidator *result;
33482 char *kwnames[] = {
33483 NULL
33484 };
33485
33486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33487 {
33488 PyThreadState* __tstate = wxPyBeginAllowThreads();
33489 result = (wxPyValidator *)new wxPyValidator();
33490
33491 wxPyEndAllowThreads(__tstate);
33492 if (PyErr_Occurred()) SWIG_fail;
33493 }
33494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33495 return resultobj;
33496 fail:
33497 return NULL;
33498 }
33499
33500
33501 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33502 PyObject *resultobj = NULL;
33503 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33504 PyObject *arg2 = (PyObject *) 0 ;
33505 PyObject *arg3 = (PyObject *) 0 ;
33506 int arg4 = (int) true ;
33507 PyObject * obj0 = 0 ;
33508 PyObject * obj1 = 0 ;
33509 PyObject * obj2 = 0 ;
33510 PyObject * obj3 = 0 ;
33511 char *kwnames[] = {
33512 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33513 };
33514
33515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33517 if (SWIG_arg_fail(1)) SWIG_fail;
33518 arg2 = obj1;
33519 arg3 = obj2;
33520 if (obj3) {
33521 {
33522 arg4 = static_cast<int >(SWIG_As_int(obj3));
33523 if (SWIG_arg_fail(4)) SWIG_fail;
33524 }
33525 }
33526 {
33527 PyThreadState* __tstate = wxPyBeginAllowThreads();
33528 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33529
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 Py_INCREF(Py_None); resultobj = Py_None;
33534 return resultobj;
33535 fail:
33536 return NULL;
33537 }
33538
33539
33540 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33541 PyObject *obj;
33542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33543 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33544 Py_INCREF(obj);
33545 return Py_BuildValue((char *)"");
33546 }
33547 static int _wrap_DefaultValidator_set(PyObject *) {
33548 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33549 return 1;
33550 }
33551
33552
33553 static PyObject *_wrap_DefaultValidator_get(void) {
33554 PyObject *pyobj = NULL;
33555
33556 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33557 return pyobj;
33558 }
33559
33560
33561 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33562 PyObject *resultobj = NULL;
33563 wxString const &arg1_defvalue = wxPyEmptyString ;
33564 wxString *arg1 = (wxString *) &arg1_defvalue ;
33565 long arg2 = (long) 0 ;
33566 wxMenu *result;
33567 bool temp1 = false ;
33568 PyObject * obj0 = 0 ;
33569 PyObject * obj1 = 0 ;
33570 char *kwnames[] = {
33571 (char *) "title",(char *) "style", NULL
33572 };
33573
33574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33575 if (obj0) {
33576 {
33577 arg1 = wxString_in_helper(obj0);
33578 if (arg1 == NULL) SWIG_fail;
33579 temp1 = true;
33580 }
33581 }
33582 if (obj1) {
33583 {
33584 arg2 = static_cast<long >(SWIG_As_long(obj1));
33585 if (SWIG_arg_fail(2)) SWIG_fail;
33586 }
33587 }
33588 {
33589 if (!wxPyCheckForApp()) SWIG_fail;
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33592
33593 wxPyEndAllowThreads(__tstate);
33594 if (PyErr_Occurred()) SWIG_fail;
33595 }
33596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33597 {
33598 if (temp1)
33599 delete arg1;
33600 }
33601 return resultobj;
33602 fail:
33603 {
33604 if (temp1)
33605 delete arg1;
33606 }
33607 return NULL;
33608 }
33609
33610
33611 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33612 PyObject *resultobj = NULL;
33613 wxMenu *arg1 = (wxMenu *) 0 ;
33614 int arg2 ;
33615 wxString *arg3 = 0 ;
33616 wxString const &arg4_defvalue = wxPyEmptyString ;
33617 wxString *arg4 = (wxString *) &arg4_defvalue ;
33618 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33619 wxMenuItem *result;
33620 bool temp3 = false ;
33621 bool temp4 = false ;
33622 PyObject * obj0 = 0 ;
33623 PyObject * obj1 = 0 ;
33624 PyObject * obj2 = 0 ;
33625 PyObject * obj3 = 0 ;
33626 PyObject * obj4 = 0 ;
33627 char *kwnames[] = {
33628 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33629 };
33630
33631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33633 if (SWIG_arg_fail(1)) SWIG_fail;
33634 {
33635 arg2 = static_cast<int >(SWIG_As_int(obj1));
33636 if (SWIG_arg_fail(2)) SWIG_fail;
33637 }
33638 {
33639 arg3 = wxString_in_helper(obj2);
33640 if (arg3 == NULL) SWIG_fail;
33641 temp3 = true;
33642 }
33643 if (obj3) {
33644 {
33645 arg4 = wxString_in_helper(obj3);
33646 if (arg4 == NULL) SWIG_fail;
33647 temp4 = true;
33648 }
33649 }
33650 if (obj4) {
33651 {
33652 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33653 if (SWIG_arg_fail(5)) SWIG_fail;
33654 }
33655 }
33656 {
33657 PyThreadState* __tstate = wxPyBeginAllowThreads();
33658 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33659
33660 wxPyEndAllowThreads(__tstate);
33661 if (PyErr_Occurred()) SWIG_fail;
33662 }
33663 {
33664 resultobj = wxPyMake_wxObject(result, (bool)0);
33665 }
33666 {
33667 if (temp3)
33668 delete arg3;
33669 }
33670 {
33671 if (temp4)
33672 delete arg4;
33673 }
33674 return resultobj;
33675 fail:
33676 {
33677 if (temp3)
33678 delete arg3;
33679 }
33680 {
33681 if (temp4)
33682 delete arg4;
33683 }
33684 return NULL;
33685 }
33686
33687
33688 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33689 PyObject *resultobj = NULL;
33690 wxMenu *arg1 = (wxMenu *) 0 ;
33691 wxMenuItem *result;
33692 PyObject * obj0 = 0 ;
33693 char *kwnames[] = {
33694 (char *) "self", NULL
33695 };
33696
33697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33699 if (SWIG_arg_fail(1)) SWIG_fail;
33700 {
33701 PyThreadState* __tstate = wxPyBeginAllowThreads();
33702 result = (wxMenuItem *)(arg1)->AppendSeparator();
33703
33704 wxPyEndAllowThreads(__tstate);
33705 if (PyErr_Occurred()) SWIG_fail;
33706 }
33707 {
33708 resultobj = wxPyMake_wxObject(result, (bool)0);
33709 }
33710 return resultobj;
33711 fail:
33712 return NULL;
33713 }
33714
33715
33716 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33717 PyObject *resultobj = NULL;
33718 wxMenu *arg1 = (wxMenu *) 0 ;
33719 int arg2 ;
33720 wxString *arg3 = 0 ;
33721 wxString const &arg4_defvalue = wxPyEmptyString ;
33722 wxString *arg4 = (wxString *) &arg4_defvalue ;
33723 wxMenuItem *result;
33724 bool temp3 = false ;
33725 bool temp4 = false ;
33726 PyObject * obj0 = 0 ;
33727 PyObject * obj1 = 0 ;
33728 PyObject * obj2 = 0 ;
33729 PyObject * obj3 = 0 ;
33730 char *kwnames[] = {
33731 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33732 };
33733
33734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33736 if (SWIG_arg_fail(1)) SWIG_fail;
33737 {
33738 arg2 = static_cast<int >(SWIG_As_int(obj1));
33739 if (SWIG_arg_fail(2)) SWIG_fail;
33740 }
33741 {
33742 arg3 = wxString_in_helper(obj2);
33743 if (arg3 == NULL) SWIG_fail;
33744 temp3 = true;
33745 }
33746 if (obj3) {
33747 {
33748 arg4 = wxString_in_helper(obj3);
33749 if (arg4 == NULL) SWIG_fail;
33750 temp4 = true;
33751 }
33752 }
33753 {
33754 PyThreadState* __tstate = wxPyBeginAllowThreads();
33755 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33756
33757 wxPyEndAllowThreads(__tstate);
33758 if (PyErr_Occurred()) SWIG_fail;
33759 }
33760 {
33761 resultobj = wxPyMake_wxObject(result, (bool)0);
33762 }
33763 {
33764 if (temp3)
33765 delete arg3;
33766 }
33767 {
33768 if (temp4)
33769 delete arg4;
33770 }
33771 return resultobj;
33772 fail:
33773 {
33774 if (temp3)
33775 delete arg3;
33776 }
33777 {
33778 if (temp4)
33779 delete arg4;
33780 }
33781 return NULL;
33782 }
33783
33784
33785 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33786 PyObject *resultobj = NULL;
33787 wxMenu *arg1 = (wxMenu *) 0 ;
33788 int arg2 ;
33789 wxString *arg3 = 0 ;
33790 wxString const &arg4_defvalue = wxPyEmptyString ;
33791 wxString *arg4 = (wxString *) &arg4_defvalue ;
33792 wxMenuItem *result;
33793 bool temp3 = false ;
33794 bool temp4 = false ;
33795 PyObject * obj0 = 0 ;
33796 PyObject * obj1 = 0 ;
33797 PyObject * obj2 = 0 ;
33798 PyObject * obj3 = 0 ;
33799 char *kwnames[] = {
33800 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33801 };
33802
33803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33805 if (SWIG_arg_fail(1)) SWIG_fail;
33806 {
33807 arg2 = static_cast<int >(SWIG_As_int(obj1));
33808 if (SWIG_arg_fail(2)) SWIG_fail;
33809 }
33810 {
33811 arg3 = wxString_in_helper(obj2);
33812 if (arg3 == NULL) SWIG_fail;
33813 temp3 = true;
33814 }
33815 if (obj3) {
33816 {
33817 arg4 = wxString_in_helper(obj3);
33818 if (arg4 == NULL) SWIG_fail;
33819 temp4 = true;
33820 }
33821 }
33822 {
33823 PyThreadState* __tstate = wxPyBeginAllowThreads();
33824 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33825
33826 wxPyEndAllowThreads(__tstate);
33827 if (PyErr_Occurred()) SWIG_fail;
33828 }
33829 {
33830 resultobj = wxPyMake_wxObject(result, (bool)0);
33831 }
33832 {
33833 if (temp3)
33834 delete arg3;
33835 }
33836 {
33837 if (temp4)
33838 delete arg4;
33839 }
33840 return resultobj;
33841 fail:
33842 {
33843 if (temp3)
33844 delete arg3;
33845 }
33846 {
33847 if (temp4)
33848 delete arg4;
33849 }
33850 return NULL;
33851 }
33852
33853
33854 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33855 PyObject *resultobj = NULL;
33856 wxMenu *arg1 = (wxMenu *) 0 ;
33857 int arg2 ;
33858 wxString *arg3 = 0 ;
33859 wxMenu *arg4 = (wxMenu *) 0 ;
33860 wxString const &arg5_defvalue = wxPyEmptyString ;
33861 wxString *arg5 = (wxString *) &arg5_defvalue ;
33862 wxMenuItem *result;
33863 bool temp3 = false ;
33864 bool temp5 = false ;
33865 PyObject * obj0 = 0 ;
33866 PyObject * obj1 = 0 ;
33867 PyObject * obj2 = 0 ;
33868 PyObject * obj3 = 0 ;
33869 PyObject * obj4 = 0 ;
33870 char *kwnames[] = {
33871 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33872 };
33873
33874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33876 if (SWIG_arg_fail(1)) SWIG_fail;
33877 {
33878 arg2 = static_cast<int >(SWIG_As_int(obj1));
33879 if (SWIG_arg_fail(2)) SWIG_fail;
33880 }
33881 {
33882 arg3 = wxString_in_helper(obj2);
33883 if (arg3 == NULL) SWIG_fail;
33884 temp3 = true;
33885 }
33886 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33887 if (SWIG_arg_fail(4)) SWIG_fail;
33888 if (obj4) {
33889 {
33890 arg5 = wxString_in_helper(obj4);
33891 if (arg5 == NULL) SWIG_fail;
33892 temp5 = true;
33893 }
33894 }
33895 {
33896 PyThreadState* __tstate = wxPyBeginAllowThreads();
33897 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33898
33899 wxPyEndAllowThreads(__tstate);
33900 if (PyErr_Occurred()) SWIG_fail;
33901 }
33902 {
33903 resultobj = wxPyMake_wxObject(result, (bool)0);
33904 }
33905 {
33906 if (temp3)
33907 delete arg3;
33908 }
33909 {
33910 if (temp5)
33911 delete arg5;
33912 }
33913 return resultobj;
33914 fail:
33915 {
33916 if (temp3)
33917 delete arg3;
33918 }
33919 {
33920 if (temp5)
33921 delete arg5;
33922 }
33923 return NULL;
33924 }
33925
33926
33927 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33928 PyObject *resultobj = NULL;
33929 wxMenu *arg1 = (wxMenu *) 0 ;
33930 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33931 wxMenuItem *result;
33932 PyObject * obj0 = 0 ;
33933 PyObject * obj1 = 0 ;
33934 char *kwnames[] = {
33935 (char *) "self",(char *) "item", NULL
33936 };
33937
33938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33940 if (SWIG_arg_fail(1)) SWIG_fail;
33941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33942 if (SWIG_arg_fail(2)) SWIG_fail;
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 result = (wxMenuItem *)(arg1)->Append(arg2);
33946
33947 wxPyEndAllowThreads(__tstate);
33948 if (PyErr_Occurred()) SWIG_fail;
33949 }
33950 {
33951 resultobj = wxPyMake_wxObject(result, (bool)0);
33952 }
33953 return resultobj;
33954 fail:
33955 return NULL;
33956 }
33957
33958
33959 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33960 PyObject *resultobj = NULL;
33961 wxMenu *arg1 = (wxMenu *) 0 ;
33962 PyObject * obj0 = 0 ;
33963 char *kwnames[] = {
33964 (char *) "self", NULL
33965 };
33966
33967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33969 if (SWIG_arg_fail(1)) SWIG_fail;
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 (arg1)->Break();
33973
33974 wxPyEndAllowThreads(__tstate);
33975 if (PyErr_Occurred()) SWIG_fail;
33976 }
33977 Py_INCREF(Py_None); resultobj = Py_None;
33978 return resultobj;
33979 fail:
33980 return NULL;
33981 }
33982
33983
33984 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33985 PyObject *resultobj = NULL;
33986 wxMenu *arg1 = (wxMenu *) 0 ;
33987 size_t arg2 ;
33988 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33989 wxMenuItem *result;
33990 PyObject * obj0 = 0 ;
33991 PyObject * obj1 = 0 ;
33992 PyObject * obj2 = 0 ;
33993 char *kwnames[] = {
33994 (char *) "self",(char *) "pos",(char *) "item", NULL
33995 };
33996
33997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33999 if (SWIG_arg_fail(1)) SWIG_fail;
34000 {
34001 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34002 if (SWIG_arg_fail(2)) SWIG_fail;
34003 }
34004 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34005 if (SWIG_arg_fail(3)) SWIG_fail;
34006 {
34007 PyThreadState* __tstate = wxPyBeginAllowThreads();
34008 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
34009
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 {
34014 resultobj = wxPyMake_wxObject(result, (bool)0);
34015 }
34016 return resultobj;
34017 fail:
34018 return NULL;
34019 }
34020
34021
34022 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34023 PyObject *resultobj = NULL;
34024 wxMenu *arg1 = (wxMenu *) 0 ;
34025 size_t arg2 ;
34026 int arg3 ;
34027 wxString *arg4 = 0 ;
34028 wxString const &arg5_defvalue = wxPyEmptyString ;
34029 wxString *arg5 = (wxString *) &arg5_defvalue ;
34030 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
34031 wxMenuItem *result;
34032 bool temp4 = false ;
34033 bool temp5 = false ;
34034 PyObject * obj0 = 0 ;
34035 PyObject * obj1 = 0 ;
34036 PyObject * obj2 = 0 ;
34037 PyObject * obj3 = 0 ;
34038 PyObject * obj4 = 0 ;
34039 PyObject * obj5 = 0 ;
34040 char *kwnames[] = {
34041 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34042 };
34043
34044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34046 if (SWIG_arg_fail(1)) SWIG_fail;
34047 {
34048 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34049 if (SWIG_arg_fail(2)) SWIG_fail;
34050 }
34051 {
34052 arg3 = static_cast<int >(SWIG_As_int(obj2));
34053 if (SWIG_arg_fail(3)) SWIG_fail;
34054 }
34055 {
34056 arg4 = wxString_in_helper(obj3);
34057 if (arg4 == NULL) SWIG_fail;
34058 temp4 = true;
34059 }
34060 if (obj4) {
34061 {
34062 arg5 = wxString_in_helper(obj4);
34063 if (arg5 == NULL) SWIG_fail;
34064 temp5 = true;
34065 }
34066 }
34067 if (obj5) {
34068 {
34069 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
34070 if (SWIG_arg_fail(6)) SWIG_fail;
34071 }
34072 }
34073 {
34074 PyThreadState* __tstate = wxPyBeginAllowThreads();
34075 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
34076
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 {
34081 resultobj = wxPyMake_wxObject(result, (bool)0);
34082 }
34083 {
34084 if (temp4)
34085 delete arg4;
34086 }
34087 {
34088 if (temp5)
34089 delete arg5;
34090 }
34091 return resultobj;
34092 fail:
34093 {
34094 if (temp4)
34095 delete arg4;
34096 }
34097 {
34098 if (temp5)
34099 delete arg5;
34100 }
34101 return NULL;
34102 }
34103
34104
34105 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34106 PyObject *resultobj = NULL;
34107 wxMenu *arg1 = (wxMenu *) 0 ;
34108 size_t arg2 ;
34109 wxMenuItem *result;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 char *kwnames[] = {
34113 (char *) "self",(char *) "pos", NULL
34114 };
34115
34116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
34117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34118 if (SWIG_arg_fail(1)) SWIG_fail;
34119 {
34120 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34121 if (SWIG_arg_fail(2)) SWIG_fail;
34122 }
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
34126
34127 wxPyEndAllowThreads(__tstate);
34128 if (PyErr_Occurred()) SWIG_fail;
34129 }
34130 {
34131 resultobj = wxPyMake_wxObject(result, (bool)0);
34132 }
34133 return resultobj;
34134 fail:
34135 return NULL;
34136 }
34137
34138
34139 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34140 PyObject *resultobj = NULL;
34141 wxMenu *arg1 = (wxMenu *) 0 ;
34142 size_t arg2 ;
34143 int arg3 ;
34144 wxString *arg4 = 0 ;
34145 wxString const &arg5_defvalue = wxPyEmptyString ;
34146 wxString *arg5 = (wxString *) &arg5_defvalue ;
34147 wxMenuItem *result;
34148 bool temp4 = false ;
34149 bool temp5 = false ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 PyObject * obj2 = 0 ;
34153 PyObject * obj3 = 0 ;
34154 PyObject * obj4 = 0 ;
34155 char *kwnames[] = {
34156 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34157 };
34158
34159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34161 if (SWIG_arg_fail(1)) SWIG_fail;
34162 {
34163 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34164 if (SWIG_arg_fail(2)) SWIG_fail;
34165 }
34166 {
34167 arg3 = static_cast<int >(SWIG_As_int(obj2));
34168 if (SWIG_arg_fail(3)) SWIG_fail;
34169 }
34170 {
34171 arg4 = wxString_in_helper(obj3);
34172 if (arg4 == NULL) SWIG_fail;
34173 temp4 = true;
34174 }
34175 if (obj4) {
34176 {
34177 arg5 = wxString_in_helper(obj4);
34178 if (arg5 == NULL) SWIG_fail;
34179 temp5 = true;
34180 }
34181 }
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34185
34186 wxPyEndAllowThreads(__tstate);
34187 if (PyErr_Occurred()) SWIG_fail;
34188 }
34189 {
34190 resultobj = wxPyMake_wxObject(result, (bool)0);
34191 }
34192 {
34193 if (temp4)
34194 delete arg4;
34195 }
34196 {
34197 if (temp5)
34198 delete arg5;
34199 }
34200 return resultobj;
34201 fail:
34202 {
34203 if (temp4)
34204 delete arg4;
34205 }
34206 {
34207 if (temp5)
34208 delete arg5;
34209 }
34210 return NULL;
34211 }
34212
34213
34214 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34215 PyObject *resultobj = NULL;
34216 wxMenu *arg1 = (wxMenu *) 0 ;
34217 size_t arg2 ;
34218 int arg3 ;
34219 wxString *arg4 = 0 ;
34220 wxString const &arg5_defvalue = wxPyEmptyString ;
34221 wxString *arg5 = (wxString *) &arg5_defvalue ;
34222 wxMenuItem *result;
34223 bool temp4 = false ;
34224 bool temp5 = false ;
34225 PyObject * obj0 = 0 ;
34226 PyObject * obj1 = 0 ;
34227 PyObject * obj2 = 0 ;
34228 PyObject * obj3 = 0 ;
34229 PyObject * obj4 = 0 ;
34230 char *kwnames[] = {
34231 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34232 };
34233
34234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34236 if (SWIG_arg_fail(1)) SWIG_fail;
34237 {
34238 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34239 if (SWIG_arg_fail(2)) SWIG_fail;
34240 }
34241 {
34242 arg3 = static_cast<int >(SWIG_As_int(obj2));
34243 if (SWIG_arg_fail(3)) SWIG_fail;
34244 }
34245 {
34246 arg4 = wxString_in_helper(obj3);
34247 if (arg4 == NULL) SWIG_fail;
34248 temp4 = true;
34249 }
34250 if (obj4) {
34251 {
34252 arg5 = wxString_in_helper(obj4);
34253 if (arg5 == NULL) SWIG_fail;
34254 temp5 = true;
34255 }
34256 }
34257 {
34258 PyThreadState* __tstate = wxPyBeginAllowThreads();
34259 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34260
34261 wxPyEndAllowThreads(__tstate);
34262 if (PyErr_Occurred()) SWIG_fail;
34263 }
34264 {
34265 resultobj = wxPyMake_wxObject(result, (bool)0);
34266 }
34267 {
34268 if (temp4)
34269 delete arg4;
34270 }
34271 {
34272 if (temp5)
34273 delete arg5;
34274 }
34275 return resultobj;
34276 fail:
34277 {
34278 if (temp4)
34279 delete arg4;
34280 }
34281 {
34282 if (temp5)
34283 delete arg5;
34284 }
34285 return NULL;
34286 }
34287
34288
34289 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34290 PyObject *resultobj = NULL;
34291 wxMenu *arg1 = (wxMenu *) 0 ;
34292 size_t arg2 ;
34293 int arg3 ;
34294 wxString *arg4 = 0 ;
34295 wxMenu *arg5 = (wxMenu *) 0 ;
34296 wxString const &arg6_defvalue = wxPyEmptyString ;
34297 wxString *arg6 = (wxString *) &arg6_defvalue ;
34298 wxMenuItem *result;
34299 bool temp4 = false ;
34300 bool temp6 = false ;
34301 PyObject * obj0 = 0 ;
34302 PyObject * obj1 = 0 ;
34303 PyObject * obj2 = 0 ;
34304 PyObject * obj3 = 0 ;
34305 PyObject * obj4 = 0 ;
34306 PyObject * obj5 = 0 ;
34307 char *kwnames[] = {
34308 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34309 };
34310
34311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34313 if (SWIG_arg_fail(1)) SWIG_fail;
34314 {
34315 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34316 if (SWIG_arg_fail(2)) SWIG_fail;
34317 }
34318 {
34319 arg3 = static_cast<int >(SWIG_As_int(obj2));
34320 if (SWIG_arg_fail(3)) SWIG_fail;
34321 }
34322 {
34323 arg4 = wxString_in_helper(obj3);
34324 if (arg4 == NULL) SWIG_fail;
34325 temp4 = true;
34326 }
34327 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34328 if (SWIG_arg_fail(5)) SWIG_fail;
34329 if (obj5) {
34330 {
34331 arg6 = wxString_in_helper(obj5);
34332 if (arg6 == NULL) SWIG_fail;
34333 temp6 = true;
34334 }
34335 }
34336 {
34337 PyThreadState* __tstate = wxPyBeginAllowThreads();
34338 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34339
34340 wxPyEndAllowThreads(__tstate);
34341 if (PyErr_Occurred()) SWIG_fail;
34342 }
34343 {
34344 resultobj = wxPyMake_wxObject(result, (bool)0);
34345 }
34346 {
34347 if (temp4)
34348 delete arg4;
34349 }
34350 {
34351 if (temp6)
34352 delete arg6;
34353 }
34354 return resultobj;
34355 fail:
34356 {
34357 if (temp4)
34358 delete arg4;
34359 }
34360 {
34361 if (temp6)
34362 delete arg6;
34363 }
34364 return NULL;
34365 }
34366
34367
34368 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34369 PyObject *resultobj = NULL;
34370 wxMenu *arg1 = (wxMenu *) 0 ;
34371 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34372 wxMenuItem *result;
34373 PyObject * obj0 = 0 ;
34374 PyObject * obj1 = 0 ;
34375 char *kwnames[] = {
34376 (char *) "self",(char *) "item", NULL
34377 };
34378
34379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34381 if (SWIG_arg_fail(1)) SWIG_fail;
34382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34383 if (SWIG_arg_fail(2)) SWIG_fail;
34384 {
34385 PyThreadState* __tstate = wxPyBeginAllowThreads();
34386 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34387
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 {
34392 resultobj = wxPyMake_wxObject(result, (bool)0);
34393 }
34394 return resultobj;
34395 fail:
34396 return NULL;
34397 }
34398
34399
34400 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34401 PyObject *resultobj = NULL;
34402 wxMenu *arg1 = (wxMenu *) 0 ;
34403 int arg2 ;
34404 wxString *arg3 = 0 ;
34405 wxString const &arg4_defvalue = wxPyEmptyString ;
34406 wxString *arg4 = (wxString *) &arg4_defvalue ;
34407 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34408 wxMenuItem *result;
34409 bool temp3 = false ;
34410 bool temp4 = false ;
34411 PyObject * obj0 = 0 ;
34412 PyObject * obj1 = 0 ;
34413 PyObject * obj2 = 0 ;
34414 PyObject * obj3 = 0 ;
34415 PyObject * obj4 = 0 ;
34416 char *kwnames[] = {
34417 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34418 };
34419
34420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34422 if (SWIG_arg_fail(1)) SWIG_fail;
34423 {
34424 arg2 = static_cast<int >(SWIG_As_int(obj1));
34425 if (SWIG_arg_fail(2)) SWIG_fail;
34426 }
34427 {
34428 arg3 = wxString_in_helper(obj2);
34429 if (arg3 == NULL) SWIG_fail;
34430 temp3 = true;
34431 }
34432 if (obj3) {
34433 {
34434 arg4 = wxString_in_helper(obj3);
34435 if (arg4 == NULL) SWIG_fail;
34436 temp4 = true;
34437 }
34438 }
34439 if (obj4) {
34440 {
34441 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34442 if (SWIG_arg_fail(5)) SWIG_fail;
34443 }
34444 }
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34448
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 {
34453 resultobj = wxPyMake_wxObject(result, (bool)0);
34454 }
34455 {
34456 if (temp3)
34457 delete arg3;
34458 }
34459 {
34460 if (temp4)
34461 delete arg4;
34462 }
34463 return resultobj;
34464 fail:
34465 {
34466 if (temp3)
34467 delete arg3;
34468 }
34469 {
34470 if (temp4)
34471 delete arg4;
34472 }
34473 return NULL;
34474 }
34475
34476
34477 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34478 PyObject *resultobj = NULL;
34479 wxMenu *arg1 = (wxMenu *) 0 ;
34480 wxMenuItem *result;
34481 PyObject * obj0 = 0 ;
34482 char *kwnames[] = {
34483 (char *) "self", NULL
34484 };
34485
34486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34488 if (SWIG_arg_fail(1)) SWIG_fail;
34489 {
34490 PyThreadState* __tstate = wxPyBeginAllowThreads();
34491 result = (wxMenuItem *)(arg1)->PrependSeparator();
34492
34493 wxPyEndAllowThreads(__tstate);
34494 if (PyErr_Occurred()) SWIG_fail;
34495 }
34496 {
34497 resultobj = wxPyMake_wxObject(result, (bool)0);
34498 }
34499 return resultobj;
34500 fail:
34501 return NULL;
34502 }
34503
34504
34505 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34506 PyObject *resultobj = NULL;
34507 wxMenu *arg1 = (wxMenu *) 0 ;
34508 int arg2 ;
34509 wxString *arg3 = 0 ;
34510 wxString const &arg4_defvalue = wxPyEmptyString ;
34511 wxString *arg4 = (wxString *) &arg4_defvalue ;
34512 wxMenuItem *result;
34513 bool temp3 = false ;
34514 bool temp4 = false ;
34515 PyObject * obj0 = 0 ;
34516 PyObject * obj1 = 0 ;
34517 PyObject * obj2 = 0 ;
34518 PyObject * obj3 = 0 ;
34519 char *kwnames[] = {
34520 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34521 };
34522
34523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34525 if (SWIG_arg_fail(1)) SWIG_fail;
34526 {
34527 arg2 = static_cast<int >(SWIG_As_int(obj1));
34528 if (SWIG_arg_fail(2)) SWIG_fail;
34529 }
34530 {
34531 arg3 = wxString_in_helper(obj2);
34532 if (arg3 == NULL) SWIG_fail;
34533 temp3 = true;
34534 }
34535 if (obj3) {
34536 {
34537 arg4 = wxString_in_helper(obj3);
34538 if (arg4 == NULL) SWIG_fail;
34539 temp4 = true;
34540 }
34541 }
34542 {
34543 PyThreadState* __tstate = wxPyBeginAllowThreads();
34544 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34545
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 {
34550 resultobj = wxPyMake_wxObject(result, (bool)0);
34551 }
34552 {
34553 if (temp3)
34554 delete arg3;
34555 }
34556 {
34557 if (temp4)
34558 delete arg4;
34559 }
34560 return resultobj;
34561 fail:
34562 {
34563 if (temp3)
34564 delete arg3;
34565 }
34566 {
34567 if (temp4)
34568 delete arg4;
34569 }
34570 return NULL;
34571 }
34572
34573
34574 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34575 PyObject *resultobj = NULL;
34576 wxMenu *arg1 = (wxMenu *) 0 ;
34577 int arg2 ;
34578 wxString *arg3 = 0 ;
34579 wxString const &arg4_defvalue = wxPyEmptyString ;
34580 wxString *arg4 = (wxString *) &arg4_defvalue ;
34581 wxMenuItem *result;
34582 bool temp3 = false ;
34583 bool temp4 = false ;
34584 PyObject * obj0 = 0 ;
34585 PyObject * obj1 = 0 ;
34586 PyObject * obj2 = 0 ;
34587 PyObject * obj3 = 0 ;
34588 char *kwnames[] = {
34589 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34590 };
34591
34592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34594 if (SWIG_arg_fail(1)) SWIG_fail;
34595 {
34596 arg2 = static_cast<int >(SWIG_As_int(obj1));
34597 if (SWIG_arg_fail(2)) SWIG_fail;
34598 }
34599 {
34600 arg3 = wxString_in_helper(obj2);
34601 if (arg3 == NULL) SWIG_fail;
34602 temp3 = true;
34603 }
34604 if (obj3) {
34605 {
34606 arg4 = wxString_in_helper(obj3);
34607 if (arg4 == NULL) SWIG_fail;
34608 temp4 = true;
34609 }
34610 }
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34614
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 {
34619 resultobj = wxPyMake_wxObject(result, (bool)0);
34620 }
34621 {
34622 if (temp3)
34623 delete arg3;
34624 }
34625 {
34626 if (temp4)
34627 delete arg4;
34628 }
34629 return resultobj;
34630 fail:
34631 {
34632 if (temp3)
34633 delete arg3;
34634 }
34635 {
34636 if (temp4)
34637 delete arg4;
34638 }
34639 return NULL;
34640 }
34641
34642
34643 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34644 PyObject *resultobj = NULL;
34645 wxMenu *arg1 = (wxMenu *) 0 ;
34646 int arg2 ;
34647 wxString *arg3 = 0 ;
34648 wxMenu *arg4 = (wxMenu *) 0 ;
34649 wxString const &arg5_defvalue = wxPyEmptyString ;
34650 wxString *arg5 = (wxString *) &arg5_defvalue ;
34651 wxMenuItem *result;
34652 bool temp3 = false ;
34653 bool temp5 = false ;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 PyObject * obj2 = 0 ;
34657 PyObject * obj3 = 0 ;
34658 PyObject * obj4 = 0 ;
34659 char *kwnames[] = {
34660 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34661 };
34662
34663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34665 if (SWIG_arg_fail(1)) SWIG_fail;
34666 {
34667 arg2 = static_cast<int >(SWIG_As_int(obj1));
34668 if (SWIG_arg_fail(2)) SWIG_fail;
34669 }
34670 {
34671 arg3 = wxString_in_helper(obj2);
34672 if (arg3 == NULL) SWIG_fail;
34673 temp3 = true;
34674 }
34675 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34676 if (SWIG_arg_fail(4)) SWIG_fail;
34677 if (obj4) {
34678 {
34679 arg5 = wxString_in_helper(obj4);
34680 if (arg5 == NULL) SWIG_fail;
34681 temp5 = true;
34682 }
34683 }
34684 {
34685 PyThreadState* __tstate = wxPyBeginAllowThreads();
34686 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34687
34688 wxPyEndAllowThreads(__tstate);
34689 if (PyErr_Occurred()) SWIG_fail;
34690 }
34691 {
34692 resultobj = wxPyMake_wxObject(result, (bool)0);
34693 }
34694 {
34695 if (temp3)
34696 delete arg3;
34697 }
34698 {
34699 if (temp5)
34700 delete arg5;
34701 }
34702 return resultobj;
34703 fail:
34704 {
34705 if (temp3)
34706 delete arg3;
34707 }
34708 {
34709 if (temp5)
34710 delete arg5;
34711 }
34712 return NULL;
34713 }
34714
34715
34716 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34717 PyObject *resultobj = NULL;
34718 wxMenu *arg1 = (wxMenu *) 0 ;
34719 int arg2 ;
34720 wxMenuItem *result;
34721 PyObject * obj0 = 0 ;
34722 PyObject * obj1 = 0 ;
34723 char *kwnames[] = {
34724 (char *) "self",(char *) "id", NULL
34725 };
34726
34727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34729 if (SWIG_arg_fail(1)) SWIG_fail;
34730 {
34731 arg2 = static_cast<int >(SWIG_As_int(obj1));
34732 if (SWIG_arg_fail(2)) SWIG_fail;
34733 }
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 result = (wxMenuItem *)(arg1)->Remove(arg2);
34737
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 {
34742 resultobj = wxPyMake_wxObject(result, (bool)0);
34743 }
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj = NULL;
34752 wxMenu *arg1 = (wxMenu *) 0 ;
34753 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34754 wxMenuItem *result;
34755 PyObject * obj0 = 0 ;
34756 PyObject * obj1 = 0 ;
34757 char *kwnames[] = {
34758 (char *) "self",(char *) "item", NULL
34759 };
34760
34761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34763 if (SWIG_arg_fail(1)) SWIG_fail;
34764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34765 if (SWIG_arg_fail(2)) SWIG_fail;
34766 {
34767 PyThreadState* __tstate = wxPyBeginAllowThreads();
34768 result = (wxMenuItem *)(arg1)->Remove(arg2);
34769
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 {
34774 resultobj = wxPyMake_wxObject(result, (bool)0);
34775 }
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34783 PyObject *resultobj = NULL;
34784 wxMenu *arg1 = (wxMenu *) 0 ;
34785 int arg2 ;
34786 bool result;
34787 PyObject * obj0 = 0 ;
34788 PyObject * obj1 = 0 ;
34789 char *kwnames[] = {
34790 (char *) "self",(char *) "id", NULL
34791 };
34792
34793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34795 if (SWIG_arg_fail(1)) SWIG_fail;
34796 {
34797 arg2 = static_cast<int >(SWIG_As_int(obj1));
34798 if (SWIG_arg_fail(2)) SWIG_fail;
34799 }
34800 {
34801 PyThreadState* __tstate = wxPyBeginAllowThreads();
34802 result = (bool)(arg1)->Delete(arg2);
34803
34804 wxPyEndAllowThreads(__tstate);
34805 if (PyErr_Occurred()) SWIG_fail;
34806 }
34807 {
34808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34809 }
34810 return resultobj;
34811 fail:
34812 return NULL;
34813 }
34814
34815
34816 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34817 PyObject *resultobj = NULL;
34818 wxMenu *arg1 = (wxMenu *) 0 ;
34819 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34820 bool result;
34821 PyObject * obj0 = 0 ;
34822 PyObject * obj1 = 0 ;
34823 char *kwnames[] = {
34824 (char *) "self",(char *) "item", NULL
34825 };
34826
34827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34829 if (SWIG_arg_fail(1)) SWIG_fail;
34830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34831 if (SWIG_arg_fail(2)) SWIG_fail;
34832 {
34833 PyThreadState* __tstate = wxPyBeginAllowThreads();
34834 result = (bool)(arg1)->Delete(arg2);
34835
34836 wxPyEndAllowThreads(__tstate);
34837 if (PyErr_Occurred()) SWIG_fail;
34838 }
34839 {
34840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34841 }
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj = NULL;
34850 wxMenu *arg1 = (wxMenu *) 0 ;
34851 PyObject * obj0 = 0 ;
34852 char *kwnames[] = {
34853 (char *) "self", NULL
34854 };
34855
34856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34858 if (SWIG_arg_fail(1)) SWIG_fail;
34859 {
34860 PyThreadState* __tstate = wxPyBeginAllowThreads();
34861 wxMenu_Destroy(arg1);
34862
34863 wxPyEndAllowThreads(__tstate);
34864 if (PyErr_Occurred()) SWIG_fail;
34865 }
34866 Py_INCREF(Py_None); resultobj = Py_None;
34867 return resultobj;
34868 fail:
34869 return NULL;
34870 }
34871
34872
34873 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34874 PyObject *resultobj = NULL;
34875 wxMenu *arg1 = (wxMenu *) 0 ;
34876 int arg2 ;
34877 bool result;
34878 PyObject * obj0 = 0 ;
34879 PyObject * obj1 = 0 ;
34880 char *kwnames[] = {
34881 (char *) "self",(char *) "id", NULL
34882 };
34883
34884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34886 if (SWIG_arg_fail(1)) SWIG_fail;
34887 {
34888 arg2 = static_cast<int >(SWIG_As_int(obj1));
34889 if (SWIG_arg_fail(2)) SWIG_fail;
34890 }
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 result = (bool)(arg1)->Destroy(arg2);
34894
34895 wxPyEndAllowThreads(__tstate);
34896 if (PyErr_Occurred()) SWIG_fail;
34897 }
34898 {
34899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34900 }
34901 return resultobj;
34902 fail:
34903 return NULL;
34904 }
34905
34906
34907 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34908 PyObject *resultobj = NULL;
34909 wxMenu *arg1 = (wxMenu *) 0 ;
34910 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34911 bool result;
34912 PyObject * obj0 = 0 ;
34913 PyObject * obj1 = 0 ;
34914 char *kwnames[] = {
34915 (char *) "self",(char *) "item", NULL
34916 };
34917
34918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34920 if (SWIG_arg_fail(1)) SWIG_fail;
34921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34922 if (SWIG_arg_fail(2)) SWIG_fail;
34923 {
34924 PyThreadState* __tstate = wxPyBeginAllowThreads();
34925 result = (bool)(arg1)->Destroy(arg2);
34926
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 {
34931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34932 }
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34940 PyObject *resultobj = NULL;
34941 wxMenu *arg1 = (wxMenu *) 0 ;
34942 size_t result;
34943 PyObject * obj0 = 0 ;
34944 char *kwnames[] = {
34945 (char *) "self", NULL
34946 };
34947
34948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34950 if (SWIG_arg_fail(1)) SWIG_fail;
34951 {
34952 PyThreadState* __tstate = wxPyBeginAllowThreads();
34953 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34954
34955 wxPyEndAllowThreads(__tstate);
34956 if (PyErr_Occurred()) SWIG_fail;
34957 }
34958 {
34959 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34960 }
34961 return resultobj;
34962 fail:
34963 return NULL;
34964 }
34965
34966
34967 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34968 PyObject *resultobj = NULL;
34969 wxMenu *arg1 = (wxMenu *) 0 ;
34970 PyObject *result;
34971 PyObject * obj0 = 0 ;
34972 char *kwnames[] = {
34973 (char *) "self", NULL
34974 };
34975
34976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34978 if (SWIG_arg_fail(1)) SWIG_fail;
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34982
34983 wxPyEndAllowThreads(__tstate);
34984 if (PyErr_Occurred()) SWIG_fail;
34985 }
34986 resultobj = result;
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34994 PyObject *resultobj = NULL;
34995 wxMenu *arg1 = (wxMenu *) 0 ;
34996 wxString *arg2 = 0 ;
34997 int result;
34998 bool temp2 = false ;
34999 PyObject * obj0 = 0 ;
35000 PyObject * obj1 = 0 ;
35001 char *kwnames[] = {
35002 (char *) "self",(char *) "item", NULL
35003 };
35004
35005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
35006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35007 if (SWIG_arg_fail(1)) SWIG_fail;
35008 {
35009 arg2 = wxString_in_helper(obj1);
35010 if (arg2 == NULL) SWIG_fail;
35011 temp2 = true;
35012 }
35013 {
35014 PyThreadState* __tstate = wxPyBeginAllowThreads();
35015 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
35016
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 {
35021 resultobj = SWIG_From_int(static_cast<int >(result));
35022 }
35023 {
35024 if (temp2)
35025 delete arg2;
35026 }
35027 return resultobj;
35028 fail:
35029 {
35030 if (temp2)
35031 delete arg2;
35032 }
35033 return NULL;
35034 }
35035
35036
35037 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35038 PyObject *resultobj = NULL;
35039 wxMenu *arg1 = (wxMenu *) 0 ;
35040 int arg2 ;
35041 wxMenuItem *result;
35042 PyObject * obj0 = 0 ;
35043 PyObject * obj1 = 0 ;
35044 char *kwnames[] = {
35045 (char *) "self",(char *) "id", NULL
35046 };
35047
35048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35050 if (SWIG_arg_fail(1)) SWIG_fail;
35051 {
35052 arg2 = static_cast<int >(SWIG_As_int(obj1));
35053 if (SWIG_arg_fail(2)) SWIG_fail;
35054 }
35055 {
35056 PyThreadState* __tstate = wxPyBeginAllowThreads();
35057 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
35058
35059 wxPyEndAllowThreads(__tstate);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 }
35062 {
35063 resultobj = wxPyMake_wxObject(result, (bool)0);
35064 }
35065 return resultobj;
35066 fail:
35067 return NULL;
35068 }
35069
35070
35071 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
35072 PyObject *resultobj = NULL;
35073 wxMenu *arg1 = (wxMenu *) 0 ;
35074 size_t arg2 ;
35075 wxMenuItem *result;
35076 PyObject * obj0 = 0 ;
35077 PyObject * obj1 = 0 ;
35078 char *kwnames[] = {
35079 (char *) "self",(char *) "position", NULL
35080 };
35081
35082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
35083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35084 if (SWIG_arg_fail(1)) SWIG_fail;
35085 {
35086 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35087 if (SWIG_arg_fail(2)) SWIG_fail;
35088 }
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
35092
35093 wxPyEndAllowThreads(__tstate);
35094 if (PyErr_Occurred()) SWIG_fail;
35095 }
35096 {
35097 resultobj = wxPyMake_wxObject(result, (bool)0);
35098 }
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35106 PyObject *resultobj = NULL;
35107 wxMenu *arg1 = (wxMenu *) 0 ;
35108 int arg2 ;
35109 bool arg3 ;
35110 PyObject * obj0 = 0 ;
35111 PyObject * obj1 = 0 ;
35112 PyObject * obj2 = 0 ;
35113 char *kwnames[] = {
35114 (char *) "self",(char *) "id",(char *) "enable", NULL
35115 };
35116
35117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35119 if (SWIG_arg_fail(1)) SWIG_fail;
35120 {
35121 arg2 = static_cast<int >(SWIG_As_int(obj1));
35122 if (SWIG_arg_fail(2)) SWIG_fail;
35123 }
35124 {
35125 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35126 if (SWIG_arg_fail(3)) SWIG_fail;
35127 }
35128 {
35129 PyThreadState* __tstate = wxPyBeginAllowThreads();
35130 (arg1)->Enable(arg2,arg3);
35131
35132 wxPyEndAllowThreads(__tstate);
35133 if (PyErr_Occurred()) SWIG_fail;
35134 }
35135 Py_INCREF(Py_None); resultobj = Py_None;
35136 return resultobj;
35137 fail:
35138 return NULL;
35139 }
35140
35141
35142 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35143 PyObject *resultobj = NULL;
35144 wxMenu *arg1 = (wxMenu *) 0 ;
35145 int arg2 ;
35146 bool result;
35147 PyObject * obj0 = 0 ;
35148 PyObject * obj1 = 0 ;
35149 char *kwnames[] = {
35150 (char *) "self",(char *) "id", NULL
35151 };
35152
35153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35155 if (SWIG_arg_fail(1)) SWIG_fail;
35156 {
35157 arg2 = static_cast<int >(SWIG_As_int(obj1));
35158 if (SWIG_arg_fail(2)) SWIG_fail;
35159 }
35160 {
35161 PyThreadState* __tstate = wxPyBeginAllowThreads();
35162 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35163
35164 wxPyEndAllowThreads(__tstate);
35165 if (PyErr_Occurred()) SWIG_fail;
35166 }
35167 {
35168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35169 }
35170 return resultobj;
35171 fail:
35172 return NULL;
35173 }
35174
35175
35176 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35177 PyObject *resultobj = NULL;
35178 wxMenu *arg1 = (wxMenu *) 0 ;
35179 int arg2 ;
35180 bool arg3 ;
35181 PyObject * obj0 = 0 ;
35182 PyObject * obj1 = 0 ;
35183 PyObject * obj2 = 0 ;
35184 char *kwnames[] = {
35185 (char *) "self",(char *) "id",(char *) "check", NULL
35186 };
35187
35188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35190 if (SWIG_arg_fail(1)) SWIG_fail;
35191 {
35192 arg2 = static_cast<int >(SWIG_As_int(obj1));
35193 if (SWIG_arg_fail(2)) SWIG_fail;
35194 }
35195 {
35196 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35197 if (SWIG_arg_fail(3)) SWIG_fail;
35198 }
35199 {
35200 PyThreadState* __tstate = wxPyBeginAllowThreads();
35201 (arg1)->Check(arg2,arg3);
35202
35203 wxPyEndAllowThreads(__tstate);
35204 if (PyErr_Occurred()) SWIG_fail;
35205 }
35206 Py_INCREF(Py_None); resultobj = Py_None;
35207 return resultobj;
35208 fail:
35209 return NULL;
35210 }
35211
35212
35213 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35214 PyObject *resultobj = NULL;
35215 wxMenu *arg1 = (wxMenu *) 0 ;
35216 int arg2 ;
35217 bool result;
35218 PyObject * obj0 = 0 ;
35219 PyObject * obj1 = 0 ;
35220 char *kwnames[] = {
35221 (char *) "self",(char *) "id", NULL
35222 };
35223
35224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35226 if (SWIG_arg_fail(1)) SWIG_fail;
35227 {
35228 arg2 = static_cast<int >(SWIG_As_int(obj1));
35229 if (SWIG_arg_fail(2)) SWIG_fail;
35230 }
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35234
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 {
35239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35240 }
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj = NULL;
35249 wxMenu *arg1 = (wxMenu *) 0 ;
35250 int arg2 ;
35251 wxString *arg3 = 0 ;
35252 bool temp3 = false ;
35253 PyObject * obj0 = 0 ;
35254 PyObject * obj1 = 0 ;
35255 PyObject * obj2 = 0 ;
35256 char *kwnames[] = {
35257 (char *) "self",(char *) "id",(char *) "label", NULL
35258 };
35259
35260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35262 if (SWIG_arg_fail(1)) SWIG_fail;
35263 {
35264 arg2 = static_cast<int >(SWIG_As_int(obj1));
35265 if (SWIG_arg_fail(2)) SWIG_fail;
35266 }
35267 {
35268 arg3 = wxString_in_helper(obj2);
35269 if (arg3 == NULL) SWIG_fail;
35270 temp3 = true;
35271 }
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35275
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 Py_INCREF(Py_None); resultobj = Py_None;
35280 {
35281 if (temp3)
35282 delete arg3;
35283 }
35284 return resultobj;
35285 fail:
35286 {
35287 if (temp3)
35288 delete arg3;
35289 }
35290 return NULL;
35291 }
35292
35293
35294 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35295 PyObject *resultobj = NULL;
35296 wxMenu *arg1 = (wxMenu *) 0 ;
35297 int arg2 ;
35298 wxString result;
35299 PyObject * obj0 = 0 ;
35300 PyObject * obj1 = 0 ;
35301 char *kwnames[] = {
35302 (char *) "self",(char *) "id", NULL
35303 };
35304
35305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35307 if (SWIG_arg_fail(1)) SWIG_fail;
35308 {
35309 arg2 = static_cast<int >(SWIG_As_int(obj1));
35310 if (SWIG_arg_fail(2)) SWIG_fail;
35311 }
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35315
35316 wxPyEndAllowThreads(__tstate);
35317 if (PyErr_Occurred()) SWIG_fail;
35318 }
35319 {
35320 #if wxUSE_UNICODE
35321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35322 #else
35323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35324 #endif
35325 }
35326 return resultobj;
35327 fail:
35328 return NULL;
35329 }
35330
35331
35332 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35333 PyObject *resultobj = NULL;
35334 wxMenu *arg1 = (wxMenu *) 0 ;
35335 int arg2 ;
35336 wxString *arg3 = 0 ;
35337 bool temp3 = false ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 PyObject * obj2 = 0 ;
35341 char *kwnames[] = {
35342 (char *) "self",(char *) "id",(char *) "helpString", NULL
35343 };
35344
35345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35347 if (SWIG_arg_fail(1)) SWIG_fail;
35348 {
35349 arg2 = static_cast<int >(SWIG_As_int(obj1));
35350 if (SWIG_arg_fail(2)) SWIG_fail;
35351 }
35352 {
35353 arg3 = wxString_in_helper(obj2);
35354 if (arg3 == NULL) SWIG_fail;
35355 temp3 = true;
35356 }
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35360
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 Py_INCREF(Py_None); resultobj = Py_None;
35365 {
35366 if (temp3)
35367 delete arg3;
35368 }
35369 return resultobj;
35370 fail:
35371 {
35372 if (temp3)
35373 delete arg3;
35374 }
35375 return NULL;
35376 }
35377
35378
35379 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35380 PyObject *resultobj = NULL;
35381 wxMenu *arg1 = (wxMenu *) 0 ;
35382 int arg2 ;
35383 wxString result;
35384 PyObject * obj0 = 0 ;
35385 PyObject * obj1 = 0 ;
35386 char *kwnames[] = {
35387 (char *) "self",(char *) "id", NULL
35388 };
35389
35390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35392 if (SWIG_arg_fail(1)) SWIG_fail;
35393 {
35394 arg2 = static_cast<int >(SWIG_As_int(obj1));
35395 if (SWIG_arg_fail(2)) SWIG_fail;
35396 }
35397 {
35398 PyThreadState* __tstate = wxPyBeginAllowThreads();
35399 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35400
35401 wxPyEndAllowThreads(__tstate);
35402 if (PyErr_Occurred()) SWIG_fail;
35403 }
35404 {
35405 #if wxUSE_UNICODE
35406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35407 #else
35408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35409 #endif
35410 }
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35418 PyObject *resultobj = NULL;
35419 wxMenu *arg1 = (wxMenu *) 0 ;
35420 wxString *arg2 = 0 ;
35421 bool temp2 = false ;
35422 PyObject * obj0 = 0 ;
35423 PyObject * obj1 = 0 ;
35424 char *kwnames[] = {
35425 (char *) "self",(char *) "title", NULL
35426 };
35427
35428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35430 if (SWIG_arg_fail(1)) SWIG_fail;
35431 {
35432 arg2 = wxString_in_helper(obj1);
35433 if (arg2 == NULL) SWIG_fail;
35434 temp2 = true;
35435 }
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 (arg1)->SetTitle((wxString const &)*arg2);
35439
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 Py_INCREF(Py_None); resultobj = Py_None;
35444 {
35445 if (temp2)
35446 delete arg2;
35447 }
35448 return resultobj;
35449 fail:
35450 {
35451 if (temp2)
35452 delete arg2;
35453 }
35454 return NULL;
35455 }
35456
35457
35458 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35459 PyObject *resultobj = NULL;
35460 wxMenu *arg1 = (wxMenu *) 0 ;
35461 wxString result;
35462 PyObject * obj0 = 0 ;
35463 char *kwnames[] = {
35464 (char *) "self", NULL
35465 };
35466
35467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35469 if (SWIG_arg_fail(1)) SWIG_fail;
35470 {
35471 PyThreadState* __tstate = wxPyBeginAllowThreads();
35472 result = ((wxMenu const *)arg1)->GetTitle();
35473
35474 wxPyEndAllowThreads(__tstate);
35475 if (PyErr_Occurred()) SWIG_fail;
35476 }
35477 {
35478 #if wxUSE_UNICODE
35479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35480 #else
35481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35482 #endif
35483 }
35484 return resultobj;
35485 fail:
35486 return NULL;
35487 }
35488
35489
35490 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35491 PyObject *resultobj = NULL;
35492 wxMenu *arg1 = (wxMenu *) 0 ;
35493 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35494 PyObject * obj0 = 0 ;
35495 PyObject * obj1 = 0 ;
35496 char *kwnames[] = {
35497 (char *) "self",(char *) "handler", NULL
35498 };
35499
35500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35502 if (SWIG_arg_fail(1)) SWIG_fail;
35503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35504 if (SWIG_arg_fail(2)) SWIG_fail;
35505 {
35506 PyThreadState* __tstate = wxPyBeginAllowThreads();
35507 (arg1)->SetEventHandler(arg2);
35508
35509 wxPyEndAllowThreads(__tstate);
35510 if (PyErr_Occurred()) SWIG_fail;
35511 }
35512 Py_INCREF(Py_None); resultobj = Py_None;
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj = NULL;
35521 wxMenu *arg1 = (wxMenu *) 0 ;
35522 wxEvtHandler *result;
35523 PyObject * obj0 = 0 ;
35524 char *kwnames[] = {
35525 (char *) "self", NULL
35526 };
35527
35528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35530 if (SWIG_arg_fail(1)) SWIG_fail;
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35534
35535 wxPyEndAllowThreads(__tstate);
35536 if (PyErr_Occurred()) SWIG_fail;
35537 }
35538 {
35539 resultobj = wxPyMake_wxObject(result, 0);
35540 }
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35548 PyObject *resultobj = NULL;
35549 wxMenu *arg1 = (wxMenu *) 0 ;
35550 wxWindow *arg2 = (wxWindow *) 0 ;
35551 PyObject * obj0 = 0 ;
35552 PyObject * obj1 = 0 ;
35553 char *kwnames[] = {
35554 (char *) "self",(char *) "win", NULL
35555 };
35556
35557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35559 if (SWIG_arg_fail(1)) SWIG_fail;
35560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35561 if (SWIG_arg_fail(2)) SWIG_fail;
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 (arg1)->SetInvokingWindow(arg2);
35565
35566 wxPyEndAllowThreads(__tstate);
35567 if (PyErr_Occurred()) SWIG_fail;
35568 }
35569 Py_INCREF(Py_None); resultobj = Py_None;
35570 return resultobj;
35571 fail:
35572 return NULL;
35573 }
35574
35575
35576 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35577 PyObject *resultobj = NULL;
35578 wxMenu *arg1 = (wxMenu *) 0 ;
35579 wxWindow *result;
35580 PyObject * obj0 = 0 ;
35581 char *kwnames[] = {
35582 (char *) "self", NULL
35583 };
35584
35585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35587 if (SWIG_arg_fail(1)) SWIG_fail;
35588 {
35589 PyThreadState* __tstate = wxPyBeginAllowThreads();
35590 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35591
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 {
35596 resultobj = wxPyMake_wxObject(result, 0);
35597 }
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35605 PyObject *resultobj = NULL;
35606 wxMenu *arg1 = (wxMenu *) 0 ;
35607 long result;
35608 PyObject * obj0 = 0 ;
35609 char *kwnames[] = {
35610 (char *) "self", NULL
35611 };
35612
35613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35615 if (SWIG_arg_fail(1)) SWIG_fail;
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 result = (long)((wxMenu const *)arg1)->GetStyle();
35619
35620 wxPyEndAllowThreads(__tstate);
35621 if (PyErr_Occurred()) SWIG_fail;
35622 }
35623 {
35624 resultobj = SWIG_From_long(static_cast<long >(result));
35625 }
35626 return resultobj;
35627 fail:
35628 return NULL;
35629 }
35630
35631
35632 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35633 PyObject *resultobj = NULL;
35634 wxMenu *arg1 = (wxMenu *) 0 ;
35635 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35636 PyObject * obj0 = 0 ;
35637 PyObject * obj1 = 0 ;
35638 char *kwnames[] = {
35639 (char *) "self",(char *) "source", NULL
35640 };
35641
35642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35644 if (SWIG_arg_fail(1)) SWIG_fail;
35645 if (obj1) {
35646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35647 if (SWIG_arg_fail(2)) SWIG_fail;
35648 }
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 (arg1)->UpdateUI(arg2);
35652
35653 wxPyEndAllowThreads(__tstate);
35654 if (PyErr_Occurred()) SWIG_fail;
35655 }
35656 Py_INCREF(Py_None); resultobj = Py_None;
35657 return resultobj;
35658 fail:
35659 return NULL;
35660 }
35661
35662
35663 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35664 PyObject *resultobj = NULL;
35665 wxMenu *arg1 = (wxMenu *) 0 ;
35666 wxMenuBar *result;
35667 PyObject * obj0 = 0 ;
35668 char *kwnames[] = {
35669 (char *) "self", NULL
35670 };
35671
35672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35674 if (SWIG_arg_fail(1)) SWIG_fail;
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35678
35679 wxPyEndAllowThreads(__tstate);
35680 if (PyErr_Occurred()) SWIG_fail;
35681 }
35682 {
35683 resultobj = wxPyMake_wxObject(result, (bool)0);
35684 }
35685 return resultobj;
35686 fail:
35687 return NULL;
35688 }
35689
35690
35691 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35692 PyObject *resultobj = NULL;
35693 wxMenu *arg1 = (wxMenu *) 0 ;
35694 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35695 PyObject * obj0 = 0 ;
35696 PyObject * obj1 = 0 ;
35697 char *kwnames[] = {
35698 (char *) "self",(char *) "menubar", NULL
35699 };
35700
35701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35703 if (SWIG_arg_fail(1)) SWIG_fail;
35704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35705 if (SWIG_arg_fail(2)) SWIG_fail;
35706 {
35707 PyThreadState* __tstate = wxPyBeginAllowThreads();
35708 (arg1)->Attach(arg2);
35709
35710 wxPyEndAllowThreads(__tstate);
35711 if (PyErr_Occurred()) SWIG_fail;
35712 }
35713 Py_INCREF(Py_None); resultobj = Py_None;
35714 return resultobj;
35715 fail:
35716 return NULL;
35717 }
35718
35719
35720 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35721 PyObject *resultobj = NULL;
35722 wxMenu *arg1 = (wxMenu *) 0 ;
35723 PyObject * obj0 = 0 ;
35724 char *kwnames[] = {
35725 (char *) "self", NULL
35726 };
35727
35728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35730 if (SWIG_arg_fail(1)) SWIG_fail;
35731 {
35732 PyThreadState* __tstate = wxPyBeginAllowThreads();
35733 (arg1)->Detach();
35734
35735 wxPyEndAllowThreads(__tstate);
35736 if (PyErr_Occurred()) SWIG_fail;
35737 }
35738 Py_INCREF(Py_None); resultobj = Py_None;
35739 return resultobj;
35740 fail:
35741 return NULL;
35742 }
35743
35744
35745 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35746 PyObject *resultobj = NULL;
35747 wxMenu *arg1 = (wxMenu *) 0 ;
35748 bool result;
35749 PyObject * obj0 = 0 ;
35750 char *kwnames[] = {
35751 (char *) "self", NULL
35752 };
35753
35754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35756 if (SWIG_arg_fail(1)) SWIG_fail;
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 result = (bool)((wxMenu const *)arg1)->IsAttached();
35760
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 {
35765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35774 PyObject *resultobj = NULL;
35775 wxMenu *arg1 = (wxMenu *) 0 ;
35776 wxMenu *arg2 = (wxMenu *) 0 ;
35777 PyObject * obj0 = 0 ;
35778 PyObject * obj1 = 0 ;
35779 char *kwnames[] = {
35780 (char *) "self",(char *) "parent", NULL
35781 };
35782
35783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35785 if (SWIG_arg_fail(1)) SWIG_fail;
35786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35787 if (SWIG_arg_fail(2)) SWIG_fail;
35788 {
35789 PyThreadState* __tstate = wxPyBeginAllowThreads();
35790 (arg1)->SetParent(arg2);
35791
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 Py_INCREF(Py_None); resultobj = Py_None;
35796 return resultobj;
35797 fail:
35798 return NULL;
35799 }
35800
35801
35802 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35803 PyObject *resultobj = NULL;
35804 wxMenu *arg1 = (wxMenu *) 0 ;
35805 wxMenu *result;
35806 PyObject * obj0 = 0 ;
35807 char *kwnames[] = {
35808 (char *) "self", NULL
35809 };
35810
35811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35813 if (SWIG_arg_fail(1)) SWIG_fail;
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35817
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 {
35822 resultobj = wxPyMake_wxObject(result, 0);
35823 }
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35831 PyObject *obj;
35832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35833 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35834 Py_INCREF(obj);
35835 return Py_BuildValue((char *)"");
35836 }
35837 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35838 PyObject *resultobj = NULL;
35839 long arg1 = (long) 0 ;
35840 wxMenuBar *result;
35841 PyObject * obj0 = 0 ;
35842 char *kwnames[] = {
35843 (char *) "style", NULL
35844 };
35845
35846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35847 if (obj0) {
35848 {
35849 arg1 = static_cast<long >(SWIG_As_long(obj0));
35850 if (SWIG_arg_fail(1)) SWIG_fail;
35851 }
35852 }
35853 {
35854 if (!wxPyCheckForApp()) SWIG_fail;
35855 PyThreadState* __tstate = wxPyBeginAllowThreads();
35856 result = (wxMenuBar *)new wxMenuBar(arg1);
35857
35858 wxPyEndAllowThreads(__tstate);
35859 if (PyErr_Occurred()) SWIG_fail;
35860 }
35861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35862 return resultobj;
35863 fail:
35864 return NULL;
35865 }
35866
35867
35868 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35869 PyObject *resultobj = NULL;
35870 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35871 wxMenu *arg2 = (wxMenu *) 0 ;
35872 wxString *arg3 = 0 ;
35873 bool result;
35874 bool temp3 = false ;
35875 PyObject * obj0 = 0 ;
35876 PyObject * obj1 = 0 ;
35877 PyObject * obj2 = 0 ;
35878 char *kwnames[] = {
35879 (char *) "self",(char *) "menu",(char *) "title", NULL
35880 };
35881
35882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35884 if (SWIG_arg_fail(1)) SWIG_fail;
35885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35886 if (SWIG_arg_fail(2)) SWIG_fail;
35887 {
35888 arg3 = wxString_in_helper(obj2);
35889 if (arg3 == NULL) SWIG_fail;
35890 temp3 = true;
35891 }
35892 {
35893 PyThreadState* __tstate = wxPyBeginAllowThreads();
35894 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35895
35896 wxPyEndAllowThreads(__tstate);
35897 if (PyErr_Occurred()) SWIG_fail;
35898 }
35899 {
35900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35901 }
35902 {
35903 if (temp3)
35904 delete arg3;
35905 }
35906 return resultobj;
35907 fail:
35908 {
35909 if (temp3)
35910 delete arg3;
35911 }
35912 return NULL;
35913 }
35914
35915
35916 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35917 PyObject *resultobj = NULL;
35918 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35919 size_t arg2 ;
35920 wxMenu *arg3 = (wxMenu *) 0 ;
35921 wxString *arg4 = 0 ;
35922 bool result;
35923 bool temp4 = false ;
35924 PyObject * obj0 = 0 ;
35925 PyObject * obj1 = 0 ;
35926 PyObject * obj2 = 0 ;
35927 PyObject * obj3 = 0 ;
35928 char *kwnames[] = {
35929 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35930 };
35931
35932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35934 if (SWIG_arg_fail(1)) SWIG_fail;
35935 {
35936 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35937 if (SWIG_arg_fail(2)) SWIG_fail;
35938 }
35939 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35940 if (SWIG_arg_fail(3)) SWIG_fail;
35941 {
35942 arg4 = wxString_in_helper(obj3);
35943 if (arg4 == NULL) SWIG_fail;
35944 temp4 = true;
35945 }
35946 {
35947 PyThreadState* __tstate = wxPyBeginAllowThreads();
35948 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35949
35950 wxPyEndAllowThreads(__tstate);
35951 if (PyErr_Occurred()) SWIG_fail;
35952 }
35953 {
35954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35955 }
35956 {
35957 if (temp4)
35958 delete arg4;
35959 }
35960 return resultobj;
35961 fail:
35962 {
35963 if (temp4)
35964 delete arg4;
35965 }
35966 return NULL;
35967 }
35968
35969
35970 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35971 PyObject *resultobj = NULL;
35972 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35973 size_t result;
35974 PyObject * obj0 = 0 ;
35975 char *kwnames[] = {
35976 (char *) "self", NULL
35977 };
35978
35979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35981 if (SWIG_arg_fail(1)) SWIG_fail;
35982 {
35983 PyThreadState* __tstate = wxPyBeginAllowThreads();
35984 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35985
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 {
35990 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35991 }
35992 return resultobj;
35993 fail:
35994 return NULL;
35995 }
35996
35997
35998 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35999 PyObject *resultobj = NULL;
36000 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36001 size_t arg2 ;
36002 wxMenu *result;
36003 PyObject * obj0 = 0 ;
36004 PyObject * obj1 = 0 ;
36005 char *kwnames[] = {
36006 (char *) "self",(char *) "pos", NULL
36007 };
36008
36009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
36010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36011 if (SWIG_arg_fail(1)) SWIG_fail;
36012 {
36013 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36014 if (SWIG_arg_fail(2)) SWIG_fail;
36015 }
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
36019
36020 wxPyEndAllowThreads(__tstate);
36021 if (PyErr_Occurred()) SWIG_fail;
36022 }
36023 {
36024 resultobj = wxPyMake_wxObject(result, 0);
36025 }
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
36033 PyObject *resultobj = NULL;
36034 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36035 size_t arg2 ;
36036 wxMenu *arg3 = (wxMenu *) 0 ;
36037 wxString *arg4 = 0 ;
36038 wxMenu *result;
36039 bool temp4 = false ;
36040 PyObject * obj0 = 0 ;
36041 PyObject * obj1 = 0 ;
36042 PyObject * obj2 = 0 ;
36043 PyObject * obj3 = 0 ;
36044 char *kwnames[] = {
36045 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
36046 };
36047
36048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36050 if (SWIG_arg_fail(1)) SWIG_fail;
36051 {
36052 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36053 if (SWIG_arg_fail(2)) SWIG_fail;
36054 }
36055 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36056 if (SWIG_arg_fail(3)) SWIG_fail;
36057 {
36058 arg4 = wxString_in_helper(obj3);
36059 if (arg4 == NULL) SWIG_fail;
36060 temp4 = true;
36061 }
36062 {
36063 PyThreadState* __tstate = wxPyBeginAllowThreads();
36064 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
36065
36066 wxPyEndAllowThreads(__tstate);
36067 if (PyErr_Occurred()) SWIG_fail;
36068 }
36069 {
36070 resultobj = wxPyMake_wxObject(result, 0);
36071 }
36072 {
36073 if (temp4)
36074 delete arg4;
36075 }
36076 return resultobj;
36077 fail:
36078 {
36079 if (temp4)
36080 delete arg4;
36081 }
36082 return NULL;
36083 }
36084
36085
36086 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
36087 PyObject *resultobj = NULL;
36088 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36089 size_t arg2 ;
36090 wxMenu *result;
36091 PyObject * obj0 = 0 ;
36092 PyObject * obj1 = 0 ;
36093 char *kwnames[] = {
36094 (char *) "self",(char *) "pos", NULL
36095 };
36096
36097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
36098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36099 if (SWIG_arg_fail(1)) SWIG_fail;
36100 {
36101 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36102 if (SWIG_arg_fail(2)) SWIG_fail;
36103 }
36104 {
36105 PyThreadState* __tstate = wxPyBeginAllowThreads();
36106 result = (wxMenu *)(arg1)->Remove(arg2);
36107
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 {
36112 resultobj = wxPyMake_wxObject(result, 0);
36113 }
36114 return resultobj;
36115 fail:
36116 return NULL;
36117 }
36118
36119
36120 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
36121 PyObject *resultobj = NULL;
36122 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36123 size_t arg2 ;
36124 bool arg3 ;
36125 PyObject * obj0 = 0 ;
36126 PyObject * obj1 = 0 ;
36127 PyObject * obj2 = 0 ;
36128 char *kwnames[] = {
36129 (char *) "self",(char *) "pos",(char *) "enable", NULL
36130 };
36131
36132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36134 if (SWIG_arg_fail(1)) SWIG_fail;
36135 {
36136 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36137 if (SWIG_arg_fail(2)) SWIG_fail;
36138 }
36139 {
36140 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36141 if (SWIG_arg_fail(3)) SWIG_fail;
36142 }
36143 {
36144 PyThreadState* __tstate = wxPyBeginAllowThreads();
36145 (arg1)->EnableTop(arg2,arg3);
36146
36147 wxPyEndAllowThreads(__tstate);
36148 if (PyErr_Occurred()) SWIG_fail;
36149 }
36150 Py_INCREF(Py_None); resultobj = Py_None;
36151 return resultobj;
36152 fail:
36153 return NULL;
36154 }
36155
36156
36157 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36158 PyObject *resultobj = NULL;
36159 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36160 size_t arg2 ;
36161 bool result;
36162 PyObject * obj0 = 0 ;
36163 PyObject * obj1 = 0 ;
36164 char *kwnames[] = {
36165 (char *) "self",(char *) "pos", NULL
36166 };
36167
36168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36170 if (SWIG_arg_fail(1)) SWIG_fail;
36171 {
36172 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36173 if (SWIG_arg_fail(2)) SWIG_fail;
36174 }
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36178
36179 wxPyEndAllowThreads(__tstate);
36180 if (PyErr_Occurred()) SWIG_fail;
36181 }
36182 {
36183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36184 }
36185 return resultobj;
36186 fail:
36187 return NULL;
36188 }
36189
36190
36191 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36192 PyObject *resultobj = NULL;
36193 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36194 size_t arg2 ;
36195 wxString *arg3 = 0 ;
36196 bool temp3 = false ;
36197 PyObject * obj0 = 0 ;
36198 PyObject * obj1 = 0 ;
36199 PyObject * obj2 = 0 ;
36200 char *kwnames[] = {
36201 (char *) "self",(char *) "pos",(char *) "label", NULL
36202 };
36203
36204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36206 if (SWIG_arg_fail(1)) SWIG_fail;
36207 {
36208 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36209 if (SWIG_arg_fail(2)) SWIG_fail;
36210 }
36211 {
36212 arg3 = wxString_in_helper(obj2);
36213 if (arg3 == NULL) SWIG_fail;
36214 temp3 = true;
36215 }
36216 {
36217 PyThreadState* __tstate = wxPyBeginAllowThreads();
36218 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36219
36220 wxPyEndAllowThreads(__tstate);
36221 if (PyErr_Occurred()) SWIG_fail;
36222 }
36223 Py_INCREF(Py_None); resultobj = Py_None;
36224 {
36225 if (temp3)
36226 delete arg3;
36227 }
36228 return resultobj;
36229 fail:
36230 {
36231 if (temp3)
36232 delete arg3;
36233 }
36234 return NULL;
36235 }
36236
36237
36238 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36239 PyObject *resultobj = NULL;
36240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36241 size_t arg2 ;
36242 wxString result;
36243 PyObject * obj0 = 0 ;
36244 PyObject * obj1 = 0 ;
36245 char *kwnames[] = {
36246 (char *) "self",(char *) "pos", NULL
36247 };
36248
36249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36251 if (SWIG_arg_fail(1)) SWIG_fail;
36252 {
36253 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36254 if (SWIG_arg_fail(2)) SWIG_fail;
36255 }
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36259
36260 wxPyEndAllowThreads(__tstate);
36261 if (PyErr_Occurred()) SWIG_fail;
36262 }
36263 {
36264 #if wxUSE_UNICODE
36265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36266 #else
36267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36268 #endif
36269 }
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36277 PyObject *resultobj = NULL;
36278 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36279 wxString *arg2 = 0 ;
36280 wxString *arg3 = 0 ;
36281 int result;
36282 bool temp2 = false ;
36283 bool temp3 = false ;
36284 PyObject * obj0 = 0 ;
36285 PyObject * obj1 = 0 ;
36286 PyObject * obj2 = 0 ;
36287 char *kwnames[] = {
36288 (char *) "self",(char *) "menu",(char *) "item", NULL
36289 };
36290
36291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36293 if (SWIG_arg_fail(1)) SWIG_fail;
36294 {
36295 arg2 = wxString_in_helper(obj1);
36296 if (arg2 == NULL) SWIG_fail;
36297 temp2 = true;
36298 }
36299 {
36300 arg3 = wxString_in_helper(obj2);
36301 if (arg3 == NULL) SWIG_fail;
36302 temp3 = true;
36303 }
36304 {
36305 PyThreadState* __tstate = wxPyBeginAllowThreads();
36306 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36307
36308 wxPyEndAllowThreads(__tstate);
36309 if (PyErr_Occurred()) SWIG_fail;
36310 }
36311 {
36312 resultobj = SWIG_From_int(static_cast<int >(result));
36313 }
36314 {
36315 if (temp2)
36316 delete arg2;
36317 }
36318 {
36319 if (temp3)
36320 delete arg3;
36321 }
36322 return resultobj;
36323 fail:
36324 {
36325 if (temp2)
36326 delete arg2;
36327 }
36328 {
36329 if (temp3)
36330 delete arg3;
36331 }
36332 return NULL;
36333 }
36334
36335
36336 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36337 PyObject *resultobj = NULL;
36338 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36339 int arg2 ;
36340 wxMenuItem *result;
36341 PyObject * obj0 = 0 ;
36342 PyObject * obj1 = 0 ;
36343 char *kwnames[] = {
36344 (char *) "self",(char *) "id", NULL
36345 };
36346
36347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36349 if (SWIG_arg_fail(1)) SWIG_fail;
36350 {
36351 arg2 = static_cast<int >(SWIG_As_int(obj1));
36352 if (SWIG_arg_fail(2)) SWIG_fail;
36353 }
36354 {
36355 PyThreadState* __tstate = wxPyBeginAllowThreads();
36356 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36357
36358 wxPyEndAllowThreads(__tstate);
36359 if (PyErr_Occurred()) SWIG_fail;
36360 }
36361 {
36362 resultobj = wxPyMake_wxObject(result, (bool)0);
36363 }
36364 return resultobj;
36365 fail:
36366 return NULL;
36367 }
36368
36369
36370 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36371 PyObject *resultobj = NULL;
36372 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36373 wxString *arg2 = 0 ;
36374 int result;
36375 bool temp2 = false ;
36376 PyObject * obj0 = 0 ;
36377 PyObject * obj1 = 0 ;
36378 char *kwnames[] = {
36379 (char *) "self",(char *) "title", NULL
36380 };
36381
36382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36384 if (SWIG_arg_fail(1)) SWIG_fail;
36385 {
36386 arg2 = wxString_in_helper(obj1);
36387 if (arg2 == NULL) SWIG_fail;
36388 temp2 = true;
36389 }
36390 {
36391 PyThreadState* __tstate = wxPyBeginAllowThreads();
36392 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36393
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 {
36398 resultobj = SWIG_From_int(static_cast<int >(result));
36399 }
36400 {
36401 if (temp2)
36402 delete arg2;
36403 }
36404 return resultobj;
36405 fail:
36406 {
36407 if (temp2)
36408 delete arg2;
36409 }
36410 return NULL;
36411 }
36412
36413
36414 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36415 PyObject *resultobj = NULL;
36416 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36417 int arg2 ;
36418 bool arg3 ;
36419 PyObject * obj0 = 0 ;
36420 PyObject * obj1 = 0 ;
36421 PyObject * obj2 = 0 ;
36422 char *kwnames[] = {
36423 (char *) "self",(char *) "id",(char *) "enable", NULL
36424 };
36425
36426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36428 if (SWIG_arg_fail(1)) SWIG_fail;
36429 {
36430 arg2 = static_cast<int >(SWIG_As_int(obj1));
36431 if (SWIG_arg_fail(2)) SWIG_fail;
36432 }
36433 {
36434 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36435 if (SWIG_arg_fail(3)) SWIG_fail;
36436 }
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 (arg1)->Enable(arg2,arg3);
36440
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 Py_INCREF(Py_None); resultobj = Py_None;
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = NULL;
36453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36454 int arg2 ;
36455 bool arg3 ;
36456 PyObject * obj0 = 0 ;
36457 PyObject * obj1 = 0 ;
36458 PyObject * obj2 = 0 ;
36459 char *kwnames[] = {
36460 (char *) "self",(char *) "id",(char *) "check", NULL
36461 };
36462
36463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36465 if (SWIG_arg_fail(1)) SWIG_fail;
36466 {
36467 arg2 = static_cast<int >(SWIG_As_int(obj1));
36468 if (SWIG_arg_fail(2)) SWIG_fail;
36469 }
36470 {
36471 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36472 if (SWIG_arg_fail(3)) SWIG_fail;
36473 }
36474 {
36475 PyThreadState* __tstate = wxPyBeginAllowThreads();
36476 (arg1)->Check(arg2,arg3);
36477
36478 wxPyEndAllowThreads(__tstate);
36479 if (PyErr_Occurred()) SWIG_fail;
36480 }
36481 Py_INCREF(Py_None); resultobj = Py_None;
36482 return resultobj;
36483 fail:
36484 return NULL;
36485 }
36486
36487
36488 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36489 PyObject *resultobj = NULL;
36490 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36491 int arg2 ;
36492 bool result;
36493 PyObject * obj0 = 0 ;
36494 PyObject * obj1 = 0 ;
36495 char *kwnames[] = {
36496 (char *) "self",(char *) "id", NULL
36497 };
36498
36499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36501 if (SWIG_arg_fail(1)) SWIG_fail;
36502 {
36503 arg2 = static_cast<int >(SWIG_As_int(obj1));
36504 if (SWIG_arg_fail(2)) SWIG_fail;
36505 }
36506 {
36507 PyThreadState* __tstate = wxPyBeginAllowThreads();
36508 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36509
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 {
36514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36515 }
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36523 PyObject *resultobj = NULL;
36524 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36525 int arg2 ;
36526 bool result;
36527 PyObject * obj0 = 0 ;
36528 PyObject * obj1 = 0 ;
36529 char *kwnames[] = {
36530 (char *) "self",(char *) "id", NULL
36531 };
36532
36533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36535 if (SWIG_arg_fail(1)) SWIG_fail;
36536 {
36537 arg2 = static_cast<int >(SWIG_As_int(obj1));
36538 if (SWIG_arg_fail(2)) SWIG_fail;
36539 }
36540 {
36541 PyThreadState* __tstate = wxPyBeginAllowThreads();
36542 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36543
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 {
36548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36549 }
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36557 PyObject *resultobj = NULL;
36558 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36559 int arg2 ;
36560 wxString *arg3 = 0 ;
36561 bool temp3 = false ;
36562 PyObject * obj0 = 0 ;
36563 PyObject * obj1 = 0 ;
36564 PyObject * obj2 = 0 ;
36565 char *kwnames[] = {
36566 (char *) "self",(char *) "id",(char *) "label", NULL
36567 };
36568
36569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36571 if (SWIG_arg_fail(1)) SWIG_fail;
36572 {
36573 arg2 = static_cast<int >(SWIG_As_int(obj1));
36574 if (SWIG_arg_fail(2)) SWIG_fail;
36575 }
36576 {
36577 arg3 = wxString_in_helper(obj2);
36578 if (arg3 == NULL) SWIG_fail;
36579 temp3 = true;
36580 }
36581 {
36582 PyThreadState* __tstate = wxPyBeginAllowThreads();
36583 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36584
36585 wxPyEndAllowThreads(__tstate);
36586 if (PyErr_Occurred()) SWIG_fail;
36587 }
36588 Py_INCREF(Py_None); resultobj = Py_None;
36589 {
36590 if (temp3)
36591 delete arg3;
36592 }
36593 return resultobj;
36594 fail:
36595 {
36596 if (temp3)
36597 delete arg3;
36598 }
36599 return NULL;
36600 }
36601
36602
36603 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36604 PyObject *resultobj = NULL;
36605 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36606 int arg2 ;
36607 wxString result;
36608 PyObject * obj0 = 0 ;
36609 PyObject * obj1 = 0 ;
36610 char *kwnames[] = {
36611 (char *) "self",(char *) "id", NULL
36612 };
36613
36614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36616 if (SWIG_arg_fail(1)) SWIG_fail;
36617 {
36618 arg2 = static_cast<int >(SWIG_As_int(obj1));
36619 if (SWIG_arg_fail(2)) SWIG_fail;
36620 }
36621 {
36622 PyThreadState* __tstate = wxPyBeginAllowThreads();
36623 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36624
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 {
36629 #if wxUSE_UNICODE
36630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36631 #else
36632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36633 #endif
36634 }
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36642 PyObject *resultobj = NULL;
36643 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36644 int arg2 ;
36645 wxString *arg3 = 0 ;
36646 bool temp3 = false ;
36647 PyObject * obj0 = 0 ;
36648 PyObject * obj1 = 0 ;
36649 PyObject * obj2 = 0 ;
36650 char *kwnames[] = {
36651 (char *) "self",(char *) "id",(char *) "helpString", NULL
36652 };
36653
36654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36656 if (SWIG_arg_fail(1)) SWIG_fail;
36657 {
36658 arg2 = static_cast<int >(SWIG_As_int(obj1));
36659 if (SWIG_arg_fail(2)) SWIG_fail;
36660 }
36661 {
36662 arg3 = wxString_in_helper(obj2);
36663 if (arg3 == NULL) SWIG_fail;
36664 temp3 = true;
36665 }
36666 {
36667 PyThreadState* __tstate = wxPyBeginAllowThreads();
36668 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36669
36670 wxPyEndAllowThreads(__tstate);
36671 if (PyErr_Occurred()) SWIG_fail;
36672 }
36673 Py_INCREF(Py_None); resultobj = Py_None;
36674 {
36675 if (temp3)
36676 delete arg3;
36677 }
36678 return resultobj;
36679 fail:
36680 {
36681 if (temp3)
36682 delete arg3;
36683 }
36684 return NULL;
36685 }
36686
36687
36688 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36689 PyObject *resultobj = NULL;
36690 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36691 int arg2 ;
36692 wxString result;
36693 PyObject * obj0 = 0 ;
36694 PyObject * obj1 = 0 ;
36695 char *kwnames[] = {
36696 (char *) "self",(char *) "id", NULL
36697 };
36698
36699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36701 if (SWIG_arg_fail(1)) SWIG_fail;
36702 {
36703 arg2 = static_cast<int >(SWIG_As_int(obj1));
36704 if (SWIG_arg_fail(2)) SWIG_fail;
36705 }
36706 {
36707 PyThreadState* __tstate = wxPyBeginAllowThreads();
36708 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36709
36710 wxPyEndAllowThreads(__tstate);
36711 if (PyErr_Occurred()) SWIG_fail;
36712 }
36713 {
36714 #if wxUSE_UNICODE
36715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36716 #else
36717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36718 #endif
36719 }
36720 return resultobj;
36721 fail:
36722 return NULL;
36723 }
36724
36725
36726 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36727 PyObject *resultobj = NULL;
36728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36729 wxFrame *result;
36730 PyObject * obj0 = 0 ;
36731 char *kwnames[] = {
36732 (char *) "self", NULL
36733 };
36734
36735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36737 if (SWIG_arg_fail(1)) SWIG_fail;
36738 {
36739 PyThreadState* __tstate = wxPyBeginAllowThreads();
36740 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36741
36742 wxPyEndAllowThreads(__tstate);
36743 if (PyErr_Occurred()) SWIG_fail;
36744 }
36745 {
36746 resultobj = wxPyMake_wxObject(result, (bool)0);
36747 }
36748 return resultobj;
36749 fail:
36750 return NULL;
36751 }
36752
36753
36754 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36755 PyObject *resultobj = NULL;
36756 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36757 bool result;
36758 PyObject * obj0 = 0 ;
36759 char *kwnames[] = {
36760 (char *) "self", NULL
36761 };
36762
36763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36765 if (SWIG_arg_fail(1)) SWIG_fail;
36766 {
36767 PyThreadState* __tstate = wxPyBeginAllowThreads();
36768 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36769
36770 wxPyEndAllowThreads(__tstate);
36771 if (PyErr_Occurred()) SWIG_fail;
36772 }
36773 {
36774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36775 }
36776 return resultobj;
36777 fail:
36778 return NULL;
36779 }
36780
36781
36782 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36783 PyObject *resultobj = NULL;
36784 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36785 wxFrame *arg2 = (wxFrame *) 0 ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char *kwnames[] = {
36789 (char *) "self",(char *) "frame", NULL
36790 };
36791
36792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36794 if (SWIG_arg_fail(1)) SWIG_fail;
36795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36796 if (SWIG_arg_fail(2)) SWIG_fail;
36797 {
36798 PyThreadState* __tstate = wxPyBeginAllowThreads();
36799 (arg1)->Attach(arg2);
36800
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 Py_INCREF(Py_None); resultobj = Py_None;
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36812 PyObject *resultobj = NULL;
36813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36814 PyObject * obj0 = 0 ;
36815 char *kwnames[] = {
36816 (char *) "self", NULL
36817 };
36818
36819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36821 if (SWIG_arg_fail(1)) SWIG_fail;
36822 {
36823 PyThreadState* __tstate = wxPyBeginAllowThreads();
36824 (arg1)->Detach();
36825
36826 wxPyEndAllowThreads(__tstate);
36827 if (PyErr_Occurred()) SWIG_fail;
36828 }
36829 Py_INCREF(Py_None); resultobj = Py_None;
36830 return resultobj;
36831 fail:
36832 return NULL;
36833 }
36834
36835
36836 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36837 PyObject *resultobj = NULL;
36838 bool arg1 ;
36839 PyObject * obj0 = 0 ;
36840 char *kwnames[] = {
36841 (char *) "enable", NULL
36842 };
36843
36844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36845 {
36846 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36847 if (SWIG_arg_fail(1)) SWIG_fail;
36848 }
36849 {
36850 PyThreadState* __tstate = wxPyBeginAllowThreads();
36851 wxMenuBar::SetAutoWindowMenu(arg1);
36852
36853 wxPyEndAllowThreads(__tstate);
36854 if (PyErr_Occurred()) SWIG_fail;
36855 }
36856 Py_INCREF(Py_None); resultobj = Py_None;
36857 return resultobj;
36858 fail:
36859 return NULL;
36860 }
36861
36862
36863 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36864 PyObject *resultobj = NULL;
36865 bool result;
36866 char *kwnames[] = {
36867 NULL
36868 };
36869
36870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (bool)wxMenuBar::GetAutoWindowMenu();
36874
36875 wxPyEndAllowThreads(__tstate);
36876 if (PyErr_Occurred()) SWIG_fail;
36877 }
36878 {
36879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36880 }
36881 return resultobj;
36882 fail:
36883 return NULL;
36884 }
36885
36886
36887 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36888 PyObject *obj;
36889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36890 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36891 Py_INCREF(obj);
36892 return Py_BuildValue((char *)"");
36893 }
36894 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36895 PyObject *resultobj = NULL;
36896 wxMenu *arg1 = (wxMenu *) NULL ;
36897 int arg2 = (int) wxID_ANY ;
36898 wxString const &arg3_defvalue = wxPyEmptyString ;
36899 wxString *arg3 = (wxString *) &arg3_defvalue ;
36900 wxString const &arg4_defvalue = wxPyEmptyString ;
36901 wxString *arg4 = (wxString *) &arg4_defvalue ;
36902 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36903 wxMenu *arg6 = (wxMenu *) NULL ;
36904 wxMenuItem *result;
36905 bool temp3 = false ;
36906 bool temp4 = false ;
36907 PyObject * obj0 = 0 ;
36908 PyObject * obj1 = 0 ;
36909 PyObject * obj2 = 0 ;
36910 PyObject * obj3 = 0 ;
36911 PyObject * obj4 = 0 ;
36912 PyObject * obj5 = 0 ;
36913 char *kwnames[] = {
36914 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36915 };
36916
36917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36918 if (obj0) {
36919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36920 if (SWIG_arg_fail(1)) SWIG_fail;
36921 }
36922 if (obj1) {
36923 {
36924 arg2 = static_cast<int >(SWIG_As_int(obj1));
36925 if (SWIG_arg_fail(2)) SWIG_fail;
36926 }
36927 }
36928 if (obj2) {
36929 {
36930 arg3 = wxString_in_helper(obj2);
36931 if (arg3 == NULL) SWIG_fail;
36932 temp3 = true;
36933 }
36934 }
36935 if (obj3) {
36936 {
36937 arg4 = wxString_in_helper(obj3);
36938 if (arg4 == NULL) SWIG_fail;
36939 temp4 = true;
36940 }
36941 }
36942 if (obj4) {
36943 {
36944 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36945 if (SWIG_arg_fail(5)) SWIG_fail;
36946 }
36947 }
36948 if (obj5) {
36949 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36950 if (SWIG_arg_fail(6)) SWIG_fail;
36951 }
36952 {
36953 PyThreadState* __tstate = wxPyBeginAllowThreads();
36954 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36955
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 resultobj = wxPyMake_wxObject(result, (bool)1);
36961 }
36962 {
36963 if (temp3)
36964 delete arg3;
36965 }
36966 {
36967 if (temp4)
36968 delete arg4;
36969 }
36970 return resultobj;
36971 fail:
36972 {
36973 if (temp3)
36974 delete arg3;
36975 }
36976 {
36977 if (temp4)
36978 delete arg4;
36979 }
36980 return NULL;
36981 }
36982
36983
36984 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36985 PyObject *resultobj = NULL;
36986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36987 wxMenu *result;
36988 PyObject * obj0 = 0 ;
36989 char *kwnames[] = {
36990 (char *) "self", NULL
36991 };
36992
36993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36995 if (SWIG_arg_fail(1)) SWIG_fail;
36996 {
36997 PyThreadState* __tstate = wxPyBeginAllowThreads();
36998 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36999
37000 wxPyEndAllowThreads(__tstate);
37001 if (PyErr_Occurred()) SWIG_fail;
37002 }
37003 {
37004 resultobj = wxPyMake_wxObject(result, 0);
37005 }
37006 return resultobj;
37007 fail:
37008 return NULL;
37009 }
37010
37011
37012 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37013 PyObject *resultobj = NULL;
37014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37015 wxMenu *arg2 = (wxMenu *) 0 ;
37016 PyObject * obj0 = 0 ;
37017 PyObject * obj1 = 0 ;
37018 char *kwnames[] = {
37019 (char *) "self",(char *) "menu", NULL
37020 };
37021
37022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
37023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37024 if (SWIG_arg_fail(1)) SWIG_fail;
37025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37026 if (SWIG_arg_fail(2)) SWIG_fail;
37027 {
37028 PyThreadState* __tstate = wxPyBeginAllowThreads();
37029 (arg1)->SetMenu(arg2);
37030
37031 wxPyEndAllowThreads(__tstate);
37032 if (PyErr_Occurred()) SWIG_fail;
37033 }
37034 Py_INCREF(Py_None); resultobj = Py_None;
37035 return resultobj;
37036 fail:
37037 return NULL;
37038 }
37039
37040
37041 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
37042 PyObject *resultobj = NULL;
37043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37044 int arg2 ;
37045 PyObject * obj0 = 0 ;
37046 PyObject * obj1 = 0 ;
37047 char *kwnames[] = {
37048 (char *) "self",(char *) "id", NULL
37049 };
37050
37051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
37052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37053 if (SWIG_arg_fail(1)) SWIG_fail;
37054 {
37055 arg2 = static_cast<int >(SWIG_As_int(obj1));
37056 if (SWIG_arg_fail(2)) SWIG_fail;
37057 }
37058 {
37059 PyThreadState* __tstate = wxPyBeginAllowThreads();
37060 (arg1)->SetId(arg2);
37061
37062 wxPyEndAllowThreads(__tstate);
37063 if (PyErr_Occurred()) SWIG_fail;
37064 }
37065 Py_INCREF(Py_None); resultobj = Py_None;
37066 return resultobj;
37067 fail:
37068 return NULL;
37069 }
37070
37071
37072 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
37073 PyObject *resultobj = NULL;
37074 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37075 int result;
37076 PyObject * obj0 = 0 ;
37077 char *kwnames[] = {
37078 (char *) "self", NULL
37079 };
37080
37081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
37082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37083 if (SWIG_arg_fail(1)) SWIG_fail;
37084 {
37085 PyThreadState* __tstate = wxPyBeginAllowThreads();
37086 result = (int)((wxMenuItem const *)arg1)->GetId();
37087
37088 wxPyEndAllowThreads(__tstate);
37089 if (PyErr_Occurred()) SWIG_fail;
37090 }
37091 {
37092 resultobj = SWIG_From_int(static_cast<int >(result));
37093 }
37094 return resultobj;
37095 fail:
37096 return NULL;
37097 }
37098
37099
37100 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
37101 PyObject *resultobj = NULL;
37102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37103 bool result;
37104 PyObject * obj0 = 0 ;
37105 char *kwnames[] = {
37106 (char *) "self", NULL
37107 };
37108
37109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
37110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37111 if (SWIG_arg_fail(1)) SWIG_fail;
37112 {
37113 PyThreadState* __tstate = wxPyBeginAllowThreads();
37114 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
37115
37116 wxPyEndAllowThreads(__tstate);
37117 if (PyErr_Occurred()) SWIG_fail;
37118 }
37119 {
37120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37121 }
37122 return resultobj;
37123 fail:
37124 return NULL;
37125 }
37126
37127
37128 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
37129 PyObject *resultobj = NULL;
37130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37131 wxString *arg2 = 0 ;
37132 bool temp2 = false ;
37133 PyObject * obj0 = 0 ;
37134 PyObject * obj1 = 0 ;
37135 char *kwnames[] = {
37136 (char *) "self",(char *) "str", NULL
37137 };
37138
37139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37141 if (SWIG_arg_fail(1)) SWIG_fail;
37142 {
37143 arg2 = wxString_in_helper(obj1);
37144 if (arg2 == NULL) SWIG_fail;
37145 temp2 = true;
37146 }
37147 {
37148 PyThreadState* __tstate = wxPyBeginAllowThreads();
37149 (arg1)->SetText((wxString const &)*arg2);
37150
37151 wxPyEndAllowThreads(__tstate);
37152 if (PyErr_Occurred()) SWIG_fail;
37153 }
37154 Py_INCREF(Py_None); resultobj = Py_None;
37155 {
37156 if (temp2)
37157 delete arg2;
37158 }
37159 return resultobj;
37160 fail:
37161 {
37162 if (temp2)
37163 delete arg2;
37164 }
37165 return NULL;
37166 }
37167
37168
37169 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37170 PyObject *resultobj = NULL;
37171 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37172 wxString result;
37173 PyObject * obj0 = 0 ;
37174 char *kwnames[] = {
37175 (char *) "self", NULL
37176 };
37177
37178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37180 if (SWIG_arg_fail(1)) SWIG_fail;
37181 {
37182 PyThreadState* __tstate = wxPyBeginAllowThreads();
37183 result = ((wxMenuItem const *)arg1)->GetLabel();
37184
37185 wxPyEndAllowThreads(__tstate);
37186 if (PyErr_Occurred()) SWIG_fail;
37187 }
37188 {
37189 #if wxUSE_UNICODE
37190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37191 #else
37192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37193 #endif
37194 }
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37202 PyObject *resultobj = NULL;
37203 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37204 wxString *result;
37205 PyObject * obj0 = 0 ;
37206 char *kwnames[] = {
37207 (char *) "self", NULL
37208 };
37209
37210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37212 if (SWIG_arg_fail(1)) SWIG_fail;
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 {
37216 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37217 result = (wxString *) &_result_ref;
37218 }
37219
37220 wxPyEndAllowThreads(__tstate);
37221 if (PyErr_Occurred()) SWIG_fail;
37222 }
37223 {
37224 #if wxUSE_UNICODE
37225 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37226 #else
37227 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37228 #endif
37229 }
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37237 PyObject *resultobj = NULL;
37238 wxString *arg1 = 0 ;
37239 wxString result;
37240 bool temp1 = false ;
37241 PyObject * obj0 = 0 ;
37242 char *kwnames[] = {
37243 (char *) "text", NULL
37244 };
37245
37246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37247 {
37248 arg1 = wxString_in_helper(obj0);
37249 if (arg1 == NULL) SWIG_fail;
37250 temp1 = true;
37251 }
37252 {
37253 PyThreadState* __tstate = wxPyBeginAllowThreads();
37254 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37255
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 {
37260 #if wxUSE_UNICODE
37261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37262 #else
37263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37264 #endif
37265 }
37266 {
37267 if (temp1)
37268 delete arg1;
37269 }
37270 return resultobj;
37271 fail:
37272 {
37273 if (temp1)
37274 delete arg1;
37275 }
37276 return NULL;
37277 }
37278
37279
37280 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37281 PyObject *resultobj = NULL;
37282 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37283 wxItemKind result;
37284 PyObject * obj0 = 0 ;
37285 char *kwnames[] = {
37286 (char *) "self", NULL
37287 };
37288
37289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37291 if (SWIG_arg_fail(1)) SWIG_fail;
37292 {
37293 PyThreadState* __tstate = wxPyBeginAllowThreads();
37294 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37295
37296 wxPyEndAllowThreads(__tstate);
37297 if (PyErr_Occurred()) SWIG_fail;
37298 }
37299 resultobj = SWIG_From_int((result));
37300 return resultobj;
37301 fail:
37302 return NULL;
37303 }
37304
37305
37306 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37307 PyObject *resultobj = NULL;
37308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37309 wxItemKind arg2 ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char *kwnames[] = {
37313 (char *) "self",(char *) "kind", NULL
37314 };
37315
37316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37318 if (SWIG_arg_fail(1)) SWIG_fail;
37319 {
37320 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37321 if (SWIG_arg_fail(2)) SWIG_fail;
37322 }
37323 {
37324 PyThreadState* __tstate = wxPyBeginAllowThreads();
37325 (arg1)->SetKind(arg2);
37326
37327 wxPyEndAllowThreads(__tstate);
37328 if (PyErr_Occurred()) SWIG_fail;
37329 }
37330 Py_INCREF(Py_None); resultobj = Py_None;
37331 return resultobj;
37332 fail:
37333 return NULL;
37334 }
37335
37336
37337 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37338 PyObject *resultobj = NULL;
37339 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37340 bool arg2 ;
37341 PyObject * obj0 = 0 ;
37342 PyObject * obj1 = 0 ;
37343 char *kwnames[] = {
37344 (char *) "self",(char *) "checkable", NULL
37345 };
37346
37347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37349 if (SWIG_arg_fail(1)) SWIG_fail;
37350 {
37351 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37352 if (SWIG_arg_fail(2)) SWIG_fail;
37353 }
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 (arg1)->SetCheckable(arg2);
37357
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 Py_INCREF(Py_None); resultobj = Py_None;
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37369 PyObject *resultobj = NULL;
37370 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37371 bool result;
37372 PyObject * obj0 = 0 ;
37373 char *kwnames[] = {
37374 (char *) "self", NULL
37375 };
37376
37377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37379 if (SWIG_arg_fail(1)) SWIG_fail;
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37383
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 {
37388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37389 }
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37397 PyObject *resultobj = NULL;
37398 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37399 bool result;
37400 PyObject * obj0 = 0 ;
37401 char *kwnames[] = {
37402 (char *) "self", NULL
37403 };
37404
37405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37407 if (SWIG_arg_fail(1)) SWIG_fail;
37408 {
37409 PyThreadState* __tstate = wxPyBeginAllowThreads();
37410 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37411
37412 wxPyEndAllowThreads(__tstate);
37413 if (PyErr_Occurred()) SWIG_fail;
37414 }
37415 {
37416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37417 }
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37425 PyObject *resultobj = NULL;
37426 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37427 wxMenu *arg2 = (wxMenu *) 0 ;
37428 PyObject * obj0 = 0 ;
37429 PyObject * obj1 = 0 ;
37430 char *kwnames[] = {
37431 (char *) "self",(char *) "menu", NULL
37432 };
37433
37434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37436 if (SWIG_arg_fail(1)) SWIG_fail;
37437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37438 if (SWIG_arg_fail(2)) SWIG_fail;
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 (arg1)->SetSubMenu(arg2);
37442
37443 wxPyEndAllowThreads(__tstate);
37444 if (PyErr_Occurred()) SWIG_fail;
37445 }
37446 Py_INCREF(Py_None); resultobj = Py_None;
37447 return resultobj;
37448 fail:
37449 return NULL;
37450 }
37451
37452
37453 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37454 PyObject *resultobj = NULL;
37455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37456 wxMenu *result;
37457 PyObject * obj0 = 0 ;
37458 char *kwnames[] = {
37459 (char *) "self", NULL
37460 };
37461
37462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37464 if (SWIG_arg_fail(1)) SWIG_fail;
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37468
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 {
37473 resultobj = wxPyMake_wxObject(result, 0);
37474 }
37475 return resultobj;
37476 fail:
37477 return NULL;
37478 }
37479
37480
37481 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37482 PyObject *resultobj = NULL;
37483 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37484 bool arg2 = (bool) true ;
37485 PyObject * obj0 = 0 ;
37486 PyObject * obj1 = 0 ;
37487 char *kwnames[] = {
37488 (char *) "self",(char *) "enable", NULL
37489 };
37490
37491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37493 if (SWIG_arg_fail(1)) SWIG_fail;
37494 if (obj1) {
37495 {
37496 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37497 if (SWIG_arg_fail(2)) SWIG_fail;
37498 }
37499 }
37500 {
37501 PyThreadState* __tstate = wxPyBeginAllowThreads();
37502 (arg1)->Enable(arg2);
37503
37504 wxPyEndAllowThreads(__tstate);
37505 if (PyErr_Occurred()) SWIG_fail;
37506 }
37507 Py_INCREF(Py_None); resultobj = Py_None;
37508 return resultobj;
37509 fail:
37510 return NULL;
37511 }
37512
37513
37514 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37515 PyObject *resultobj = NULL;
37516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37517 bool result;
37518 PyObject * obj0 = 0 ;
37519 char *kwnames[] = {
37520 (char *) "self", NULL
37521 };
37522
37523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37525 if (SWIG_arg_fail(1)) SWIG_fail;
37526 {
37527 PyThreadState* __tstate = wxPyBeginAllowThreads();
37528 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37529
37530 wxPyEndAllowThreads(__tstate);
37531 if (PyErr_Occurred()) SWIG_fail;
37532 }
37533 {
37534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37535 }
37536 return resultobj;
37537 fail:
37538 return NULL;
37539 }
37540
37541
37542 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37543 PyObject *resultobj = NULL;
37544 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37545 bool arg2 = (bool) true ;
37546 PyObject * obj0 = 0 ;
37547 PyObject * obj1 = 0 ;
37548 char *kwnames[] = {
37549 (char *) "self",(char *) "check", NULL
37550 };
37551
37552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37554 if (SWIG_arg_fail(1)) SWIG_fail;
37555 if (obj1) {
37556 {
37557 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37558 if (SWIG_arg_fail(2)) SWIG_fail;
37559 }
37560 }
37561 {
37562 PyThreadState* __tstate = wxPyBeginAllowThreads();
37563 (arg1)->Check(arg2);
37564
37565 wxPyEndAllowThreads(__tstate);
37566 if (PyErr_Occurred()) SWIG_fail;
37567 }
37568 Py_INCREF(Py_None); resultobj = Py_None;
37569 return resultobj;
37570 fail:
37571 return NULL;
37572 }
37573
37574
37575 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37576 PyObject *resultobj = NULL;
37577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37578 bool result;
37579 PyObject * obj0 = 0 ;
37580 char *kwnames[] = {
37581 (char *) "self", NULL
37582 };
37583
37584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37586 if (SWIG_arg_fail(1)) SWIG_fail;
37587 {
37588 PyThreadState* __tstate = wxPyBeginAllowThreads();
37589 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37590
37591 wxPyEndAllowThreads(__tstate);
37592 if (PyErr_Occurred()) SWIG_fail;
37593 }
37594 {
37595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37596 }
37597 return resultobj;
37598 fail:
37599 return NULL;
37600 }
37601
37602
37603 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37604 PyObject *resultobj = NULL;
37605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37606 PyObject * obj0 = 0 ;
37607 char *kwnames[] = {
37608 (char *) "self", NULL
37609 };
37610
37611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37613 if (SWIG_arg_fail(1)) SWIG_fail;
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->Toggle();
37617
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 Py_INCREF(Py_None); resultobj = Py_None;
37622 return resultobj;
37623 fail:
37624 return NULL;
37625 }
37626
37627
37628 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37629 PyObject *resultobj = NULL;
37630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37631 wxString *arg2 = 0 ;
37632 bool temp2 = false ;
37633 PyObject * obj0 = 0 ;
37634 PyObject * obj1 = 0 ;
37635 char *kwnames[] = {
37636 (char *) "self",(char *) "str", NULL
37637 };
37638
37639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37641 if (SWIG_arg_fail(1)) SWIG_fail;
37642 {
37643 arg2 = wxString_in_helper(obj1);
37644 if (arg2 == NULL) SWIG_fail;
37645 temp2 = true;
37646 }
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 (arg1)->SetHelp((wxString const &)*arg2);
37650
37651 wxPyEndAllowThreads(__tstate);
37652 if (PyErr_Occurred()) SWIG_fail;
37653 }
37654 Py_INCREF(Py_None); resultobj = Py_None;
37655 {
37656 if (temp2)
37657 delete arg2;
37658 }
37659 return resultobj;
37660 fail:
37661 {
37662 if (temp2)
37663 delete arg2;
37664 }
37665 return NULL;
37666 }
37667
37668
37669 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37670 PyObject *resultobj = NULL;
37671 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37672 wxString *result;
37673 PyObject * obj0 = 0 ;
37674 char *kwnames[] = {
37675 (char *) "self", NULL
37676 };
37677
37678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37680 if (SWIG_arg_fail(1)) SWIG_fail;
37681 {
37682 PyThreadState* __tstate = wxPyBeginAllowThreads();
37683 {
37684 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37685 result = (wxString *) &_result_ref;
37686 }
37687
37688 wxPyEndAllowThreads(__tstate);
37689 if (PyErr_Occurred()) SWIG_fail;
37690 }
37691 {
37692 #if wxUSE_UNICODE
37693 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37694 #else
37695 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37696 #endif
37697 }
37698 return resultobj;
37699 fail:
37700 return NULL;
37701 }
37702
37703
37704 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj = NULL;
37706 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37707 wxAcceleratorEntry *result;
37708 PyObject * obj0 = 0 ;
37709 char *kwnames[] = {
37710 (char *) "self", NULL
37711 };
37712
37713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37715 if (SWIG_arg_fail(1)) SWIG_fail;
37716 {
37717 PyThreadState* __tstate = wxPyBeginAllowThreads();
37718 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37719
37720 wxPyEndAllowThreads(__tstate);
37721 if (PyErr_Occurred()) SWIG_fail;
37722 }
37723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37724 return resultobj;
37725 fail:
37726 return NULL;
37727 }
37728
37729
37730 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37731 PyObject *resultobj = NULL;
37732 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37733 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37734 PyObject * obj0 = 0 ;
37735 PyObject * obj1 = 0 ;
37736 char *kwnames[] = {
37737 (char *) "self",(char *) "accel", NULL
37738 };
37739
37740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37742 if (SWIG_arg_fail(1)) SWIG_fail;
37743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37744 if (SWIG_arg_fail(2)) SWIG_fail;
37745 {
37746 PyThreadState* __tstate = wxPyBeginAllowThreads();
37747 (arg1)->SetAccel(arg2);
37748
37749 wxPyEndAllowThreads(__tstate);
37750 if (PyErr_Occurred()) SWIG_fail;
37751 }
37752 Py_INCREF(Py_None); resultobj = Py_None;
37753 return resultobj;
37754 fail:
37755 return NULL;
37756 }
37757
37758
37759 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37760 PyObject *resultobj = NULL;
37761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37762 wxBitmap *arg2 = 0 ;
37763 PyObject * obj0 = 0 ;
37764 PyObject * obj1 = 0 ;
37765 char *kwnames[] = {
37766 (char *) "self",(char *) "bitmap", NULL
37767 };
37768
37769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37771 if (SWIG_arg_fail(1)) SWIG_fail;
37772 {
37773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37774 if (SWIG_arg_fail(2)) SWIG_fail;
37775 if (arg2 == NULL) {
37776 SWIG_null_ref("wxBitmap");
37777 }
37778 if (SWIG_arg_fail(2)) SWIG_fail;
37779 }
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37783
37784 wxPyEndAllowThreads(__tstate);
37785 if (PyErr_Occurred()) SWIG_fail;
37786 }
37787 Py_INCREF(Py_None); resultobj = Py_None;
37788 return resultobj;
37789 fail:
37790 return NULL;
37791 }
37792
37793
37794 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37795 PyObject *resultobj = NULL;
37796 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37797 wxBitmap *result;
37798 PyObject * obj0 = 0 ;
37799 char *kwnames[] = {
37800 (char *) "self", NULL
37801 };
37802
37803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37805 if (SWIG_arg_fail(1)) SWIG_fail;
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 {
37809 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37810 result = (wxBitmap *) &_result_ref;
37811 }
37812
37813 wxPyEndAllowThreads(__tstate);
37814 if (PyErr_Occurred()) SWIG_fail;
37815 }
37816 {
37817 wxBitmap* resultptr = new wxBitmap(*result);
37818 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37819 }
37820 return resultobj;
37821 fail:
37822 return NULL;
37823 }
37824
37825
37826 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37827 PyObject *resultobj = NULL;
37828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37829 wxFont *arg2 = 0 ;
37830 PyObject * obj0 = 0 ;
37831 PyObject * obj1 = 0 ;
37832 char *kwnames[] = {
37833 (char *) "self",(char *) "font", NULL
37834 };
37835
37836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37838 if (SWIG_arg_fail(1)) SWIG_fail;
37839 {
37840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37841 if (SWIG_arg_fail(2)) SWIG_fail;
37842 if (arg2 == NULL) {
37843 SWIG_null_ref("wxFont");
37844 }
37845 if (SWIG_arg_fail(2)) SWIG_fail;
37846 }
37847 {
37848 PyThreadState* __tstate = wxPyBeginAllowThreads();
37849 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37850
37851 wxPyEndAllowThreads(__tstate);
37852 if (PyErr_Occurred()) SWIG_fail;
37853 }
37854 Py_INCREF(Py_None); resultobj = Py_None;
37855 return resultobj;
37856 fail:
37857 return NULL;
37858 }
37859
37860
37861 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37862 PyObject *resultobj = NULL;
37863 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37864 wxFont result;
37865 PyObject * obj0 = 0 ;
37866 char *kwnames[] = {
37867 (char *) "self", NULL
37868 };
37869
37870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37872 if (SWIG_arg_fail(1)) SWIG_fail;
37873 {
37874 PyThreadState* __tstate = wxPyBeginAllowThreads();
37875 result = wxMenuItem_GetFont(arg1);
37876
37877 wxPyEndAllowThreads(__tstate);
37878 if (PyErr_Occurred()) SWIG_fail;
37879 }
37880 {
37881 wxFont * resultptr;
37882 resultptr = new wxFont(static_cast<wxFont & >(result));
37883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37884 }
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37892 PyObject *resultobj = NULL;
37893 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37894 wxColour *arg2 = 0 ;
37895 wxColour temp2 ;
37896 PyObject * obj0 = 0 ;
37897 PyObject * obj1 = 0 ;
37898 char *kwnames[] = {
37899 (char *) "self",(char *) "colText", NULL
37900 };
37901
37902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37904 if (SWIG_arg_fail(1)) SWIG_fail;
37905 {
37906 arg2 = &temp2;
37907 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37908 }
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37912
37913 wxPyEndAllowThreads(__tstate);
37914 if (PyErr_Occurred()) SWIG_fail;
37915 }
37916 Py_INCREF(Py_None); resultobj = Py_None;
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37924 PyObject *resultobj = NULL;
37925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37926 wxColour result;
37927 PyObject * obj0 = 0 ;
37928 char *kwnames[] = {
37929 (char *) "self", NULL
37930 };
37931
37932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37934 if (SWIG_arg_fail(1)) SWIG_fail;
37935 {
37936 PyThreadState* __tstate = wxPyBeginAllowThreads();
37937 result = wxMenuItem_GetTextColour(arg1);
37938
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 {
37943 wxColour * resultptr;
37944 resultptr = new wxColour(static_cast<wxColour & >(result));
37945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37946 }
37947 return resultobj;
37948 fail:
37949 return NULL;
37950 }
37951
37952
37953 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37954 PyObject *resultobj = NULL;
37955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37956 wxColour *arg2 = 0 ;
37957 wxColour temp2 ;
37958 PyObject * obj0 = 0 ;
37959 PyObject * obj1 = 0 ;
37960 char *kwnames[] = {
37961 (char *) "self",(char *) "colBack", NULL
37962 };
37963
37964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37966 if (SWIG_arg_fail(1)) SWIG_fail;
37967 {
37968 arg2 = &temp2;
37969 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37970 }
37971 {
37972 PyThreadState* __tstate = wxPyBeginAllowThreads();
37973 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37974
37975 wxPyEndAllowThreads(__tstate);
37976 if (PyErr_Occurred()) SWIG_fail;
37977 }
37978 Py_INCREF(Py_None); resultobj = Py_None;
37979 return resultobj;
37980 fail:
37981 return NULL;
37982 }
37983
37984
37985 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37986 PyObject *resultobj = NULL;
37987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37988 wxColour result;
37989 PyObject * obj0 = 0 ;
37990 char *kwnames[] = {
37991 (char *) "self", NULL
37992 };
37993
37994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37996 if (SWIG_arg_fail(1)) SWIG_fail;
37997 {
37998 PyThreadState* __tstate = wxPyBeginAllowThreads();
37999 result = wxMenuItem_GetBackgroundColour(arg1);
38000
38001 wxPyEndAllowThreads(__tstate);
38002 if (PyErr_Occurred()) SWIG_fail;
38003 }
38004 {
38005 wxColour * resultptr;
38006 resultptr = new wxColour(static_cast<wxColour & >(result));
38007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
38008 }
38009 return resultobj;
38010 fail:
38011 return NULL;
38012 }
38013
38014
38015 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
38016 PyObject *resultobj = NULL;
38017 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38018 wxBitmap *arg2 = 0 ;
38019 wxBitmap const &arg3_defvalue = wxNullBitmap ;
38020 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
38021 PyObject * obj0 = 0 ;
38022 PyObject * obj1 = 0 ;
38023 PyObject * obj2 = 0 ;
38024 char *kwnames[] = {
38025 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
38026 };
38027
38028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
38029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38030 if (SWIG_arg_fail(1)) SWIG_fail;
38031 {
38032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
38033 if (SWIG_arg_fail(2)) SWIG_fail;
38034 if (arg2 == NULL) {
38035 SWIG_null_ref("wxBitmap");
38036 }
38037 if (SWIG_arg_fail(2)) SWIG_fail;
38038 }
38039 if (obj2) {
38040 {
38041 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
38042 if (SWIG_arg_fail(3)) SWIG_fail;
38043 if (arg3 == NULL) {
38044 SWIG_null_ref("wxBitmap");
38045 }
38046 if (SWIG_arg_fail(3)) SWIG_fail;
38047 }
38048 }
38049 {
38050 PyThreadState* __tstate = wxPyBeginAllowThreads();
38051 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
38052
38053 wxPyEndAllowThreads(__tstate);
38054 if (PyErr_Occurred()) SWIG_fail;
38055 }
38056 Py_INCREF(Py_None); resultobj = Py_None;
38057 return resultobj;
38058 fail:
38059 return NULL;
38060 }
38061
38062
38063 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
38064 PyObject *resultobj = NULL;
38065 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38066 wxBitmap *arg2 = 0 ;
38067 PyObject * obj0 = 0 ;
38068 PyObject * obj1 = 0 ;
38069 char *kwnames[] = {
38070 (char *) "self",(char *) "bmpDisabled", NULL
38071 };
38072
38073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
38074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38075 if (SWIG_arg_fail(1)) SWIG_fail;
38076 {
38077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
38078 if (SWIG_arg_fail(2)) SWIG_fail;
38079 if (arg2 == NULL) {
38080 SWIG_null_ref("wxBitmap");
38081 }
38082 if (SWIG_arg_fail(2)) SWIG_fail;
38083 }
38084 {
38085 PyThreadState* __tstate = wxPyBeginAllowThreads();
38086 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
38087
38088 wxPyEndAllowThreads(__tstate);
38089 if (PyErr_Occurred()) SWIG_fail;
38090 }
38091 Py_INCREF(Py_None); resultobj = Py_None;
38092 return resultobj;
38093 fail:
38094 return NULL;
38095 }
38096
38097
38098 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
38099 PyObject *resultobj = NULL;
38100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38101 wxBitmap *result;
38102 PyObject * obj0 = 0 ;
38103 char *kwnames[] = {
38104 (char *) "self", NULL
38105 };
38106
38107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
38108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38109 if (SWIG_arg_fail(1)) SWIG_fail;
38110 {
38111 PyThreadState* __tstate = wxPyBeginAllowThreads();
38112 {
38113 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
38114 result = (wxBitmap *) &_result_ref;
38115 }
38116
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 {
38121 wxBitmap* resultptr = new wxBitmap(*result);
38122 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
38123 }
38124 return resultobj;
38125 fail:
38126 return NULL;
38127 }
38128
38129
38130 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38131 PyObject *resultobj = NULL;
38132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38133 int arg2 ;
38134 PyObject * obj0 = 0 ;
38135 PyObject * obj1 = 0 ;
38136 char *kwnames[] = {
38137 (char *) "self",(char *) "nWidth", NULL
38138 };
38139
38140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38142 if (SWIG_arg_fail(1)) SWIG_fail;
38143 {
38144 arg2 = static_cast<int >(SWIG_As_int(obj1));
38145 if (SWIG_arg_fail(2)) SWIG_fail;
38146 }
38147 {
38148 PyThreadState* __tstate = wxPyBeginAllowThreads();
38149 wxMenuItem_SetMarginWidth(arg1,arg2);
38150
38151 wxPyEndAllowThreads(__tstate);
38152 if (PyErr_Occurred()) SWIG_fail;
38153 }
38154 Py_INCREF(Py_None); resultobj = Py_None;
38155 return resultobj;
38156 fail:
38157 return NULL;
38158 }
38159
38160
38161 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38162 PyObject *resultobj = NULL;
38163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38164 int result;
38165 PyObject * obj0 = 0 ;
38166 char *kwnames[] = {
38167 (char *) "self", NULL
38168 };
38169
38170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38172 if (SWIG_arg_fail(1)) SWIG_fail;
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 result = (int)wxMenuItem_GetMarginWidth(arg1);
38176
38177 wxPyEndAllowThreads(__tstate);
38178 if (PyErr_Occurred()) SWIG_fail;
38179 }
38180 {
38181 resultobj = SWIG_From_int(static_cast<int >(result));
38182 }
38183 return resultobj;
38184 fail:
38185 return NULL;
38186 }
38187
38188
38189 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38190 PyObject *resultobj = NULL;
38191 int result;
38192 char *kwnames[] = {
38193 NULL
38194 };
38195
38196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38197 {
38198 PyThreadState* __tstate = wxPyBeginAllowThreads();
38199 result = (int)wxMenuItem_GetDefaultMarginWidth();
38200
38201 wxPyEndAllowThreads(__tstate);
38202 if (PyErr_Occurred()) SWIG_fail;
38203 }
38204 {
38205 resultobj = SWIG_From_int(static_cast<int >(result));
38206 }
38207 return resultobj;
38208 fail:
38209 return NULL;
38210 }
38211
38212
38213 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38214 PyObject *resultobj = NULL;
38215 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38216 bool result;
38217 PyObject * obj0 = 0 ;
38218 char *kwnames[] = {
38219 (char *) "self", NULL
38220 };
38221
38222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38224 if (SWIG_arg_fail(1)) SWIG_fail;
38225 {
38226 PyThreadState* __tstate = wxPyBeginAllowThreads();
38227 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
38228
38229 wxPyEndAllowThreads(__tstate);
38230 if (PyErr_Occurred()) SWIG_fail;
38231 }
38232 {
38233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38234 }
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38242 PyObject *resultobj = NULL;
38243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38244 bool arg2 = (bool) true ;
38245 PyObject * obj0 = 0 ;
38246 PyObject * obj1 = 0 ;
38247 char *kwnames[] = {
38248 (char *) "self",(char *) "ownerDrawn", NULL
38249 };
38250
38251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38253 if (SWIG_arg_fail(1)) SWIG_fail;
38254 if (obj1) {
38255 {
38256 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38257 if (SWIG_arg_fail(2)) SWIG_fail;
38258 }
38259 }
38260 {
38261 PyThreadState* __tstate = wxPyBeginAllowThreads();
38262 wxMenuItem_SetOwnerDrawn(arg1,arg2);
38263
38264 wxPyEndAllowThreads(__tstate);
38265 if (PyErr_Occurred()) SWIG_fail;
38266 }
38267 Py_INCREF(Py_None); resultobj = Py_None;
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj = NULL;
38276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38277 PyObject * obj0 = 0 ;
38278 char *kwnames[] = {
38279 (char *) "self", NULL
38280 };
38281
38282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38284 if (SWIG_arg_fail(1)) SWIG_fail;
38285 {
38286 PyThreadState* __tstate = wxPyBeginAllowThreads();
38287 wxMenuItem_ResetOwnerDrawn(arg1);
38288
38289 wxPyEndAllowThreads(__tstate);
38290 if (PyErr_Occurred()) SWIG_fail;
38291 }
38292 Py_INCREF(Py_None); resultobj = Py_None;
38293 return resultobj;
38294 fail:
38295 return NULL;
38296 }
38297
38298
38299 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38300 PyObject *obj;
38301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38302 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38303 Py_INCREF(obj);
38304 return Py_BuildValue((char *)"");
38305 }
38306 static int _wrap_ControlNameStr_set(PyObject *) {
38307 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38308 return 1;
38309 }
38310
38311
38312 static PyObject *_wrap_ControlNameStr_get(void) {
38313 PyObject *pyobj = NULL;
38314
38315 {
38316 #if wxUSE_UNICODE
38317 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38318 #else
38319 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38320 #endif
38321 }
38322 return pyobj;
38323 }
38324
38325
38326 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38327 PyObject *resultobj = NULL;
38328 wxWindow *arg1 = (wxWindow *) 0 ;
38329 int arg2 = (int) -1 ;
38330 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38331 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38332 wxSize const &arg4_defvalue = wxDefaultSize ;
38333 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38334 long arg5 = (long) 0 ;
38335 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38336 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38337 wxString const &arg7_defvalue = wxPyControlNameStr ;
38338 wxString *arg7 = (wxString *) &arg7_defvalue ;
38339 wxControl *result;
38340 wxPoint temp3 ;
38341 wxSize temp4 ;
38342 bool temp7 = false ;
38343 PyObject * obj0 = 0 ;
38344 PyObject * obj1 = 0 ;
38345 PyObject * obj2 = 0 ;
38346 PyObject * obj3 = 0 ;
38347 PyObject * obj4 = 0 ;
38348 PyObject * obj5 = 0 ;
38349 PyObject * obj6 = 0 ;
38350 char *kwnames[] = {
38351 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38352 };
38353
38354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38356 if (SWIG_arg_fail(1)) SWIG_fail;
38357 if (obj1) {
38358 {
38359 arg2 = static_cast<int >(SWIG_As_int(obj1));
38360 if (SWIG_arg_fail(2)) SWIG_fail;
38361 }
38362 }
38363 if (obj2) {
38364 {
38365 arg3 = &temp3;
38366 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38367 }
38368 }
38369 if (obj3) {
38370 {
38371 arg4 = &temp4;
38372 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38373 }
38374 }
38375 if (obj4) {
38376 {
38377 arg5 = static_cast<long >(SWIG_As_long(obj4));
38378 if (SWIG_arg_fail(5)) SWIG_fail;
38379 }
38380 }
38381 if (obj5) {
38382 {
38383 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38384 if (SWIG_arg_fail(6)) SWIG_fail;
38385 if (arg6 == NULL) {
38386 SWIG_null_ref("wxValidator");
38387 }
38388 if (SWIG_arg_fail(6)) SWIG_fail;
38389 }
38390 }
38391 if (obj6) {
38392 {
38393 arg7 = wxString_in_helper(obj6);
38394 if (arg7 == NULL) SWIG_fail;
38395 temp7 = true;
38396 }
38397 }
38398 {
38399 if (!wxPyCheckForApp()) SWIG_fail;
38400 PyThreadState* __tstate = wxPyBeginAllowThreads();
38401 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38402
38403 wxPyEndAllowThreads(__tstate);
38404 if (PyErr_Occurred()) SWIG_fail;
38405 }
38406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38407 {
38408 if (temp7)
38409 delete arg7;
38410 }
38411 return resultobj;
38412 fail:
38413 {
38414 if (temp7)
38415 delete arg7;
38416 }
38417 return NULL;
38418 }
38419
38420
38421 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38422 PyObject *resultobj = NULL;
38423 wxControl *result;
38424 char *kwnames[] = {
38425 NULL
38426 };
38427
38428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38429 {
38430 if (!wxPyCheckForApp()) SWIG_fail;
38431 PyThreadState* __tstate = wxPyBeginAllowThreads();
38432 result = (wxControl *)new wxControl();
38433
38434 wxPyEndAllowThreads(__tstate);
38435 if (PyErr_Occurred()) SWIG_fail;
38436 }
38437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38438 return resultobj;
38439 fail:
38440 return NULL;
38441 }
38442
38443
38444 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38445 PyObject *resultobj = NULL;
38446 wxControl *arg1 = (wxControl *) 0 ;
38447 wxWindow *arg2 = (wxWindow *) 0 ;
38448 int arg3 = (int) -1 ;
38449 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38450 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38451 wxSize const &arg5_defvalue = wxDefaultSize ;
38452 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38453 long arg6 = (long) 0 ;
38454 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38455 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38456 wxString const &arg8_defvalue = wxPyControlNameStr ;
38457 wxString *arg8 = (wxString *) &arg8_defvalue ;
38458 bool result;
38459 wxPoint temp4 ;
38460 wxSize temp5 ;
38461 bool temp8 = false ;
38462 PyObject * obj0 = 0 ;
38463 PyObject * obj1 = 0 ;
38464 PyObject * obj2 = 0 ;
38465 PyObject * obj3 = 0 ;
38466 PyObject * obj4 = 0 ;
38467 PyObject * obj5 = 0 ;
38468 PyObject * obj6 = 0 ;
38469 PyObject * obj7 = 0 ;
38470 char *kwnames[] = {
38471 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38472 };
38473
38474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38476 if (SWIG_arg_fail(1)) SWIG_fail;
38477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38478 if (SWIG_arg_fail(2)) SWIG_fail;
38479 if (obj2) {
38480 {
38481 arg3 = static_cast<int >(SWIG_As_int(obj2));
38482 if (SWIG_arg_fail(3)) SWIG_fail;
38483 }
38484 }
38485 if (obj3) {
38486 {
38487 arg4 = &temp4;
38488 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38489 }
38490 }
38491 if (obj4) {
38492 {
38493 arg5 = &temp5;
38494 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38495 }
38496 }
38497 if (obj5) {
38498 {
38499 arg6 = static_cast<long >(SWIG_As_long(obj5));
38500 if (SWIG_arg_fail(6)) SWIG_fail;
38501 }
38502 }
38503 if (obj6) {
38504 {
38505 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38506 if (SWIG_arg_fail(7)) SWIG_fail;
38507 if (arg7 == NULL) {
38508 SWIG_null_ref("wxValidator");
38509 }
38510 if (SWIG_arg_fail(7)) SWIG_fail;
38511 }
38512 }
38513 if (obj7) {
38514 {
38515 arg8 = wxString_in_helper(obj7);
38516 if (arg8 == NULL) SWIG_fail;
38517 temp8 = true;
38518 }
38519 }
38520 {
38521 PyThreadState* __tstate = wxPyBeginAllowThreads();
38522 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38523
38524 wxPyEndAllowThreads(__tstate);
38525 if (PyErr_Occurred()) SWIG_fail;
38526 }
38527 {
38528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38529 }
38530 {
38531 if (temp8)
38532 delete arg8;
38533 }
38534 return resultobj;
38535 fail:
38536 {
38537 if (temp8)
38538 delete arg8;
38539 }
38540 return NULL;
38541 }
38542
38543
38544 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38545 PyObject *resultobj = NULL;
38546 wxControl *arg1 = (wxControl *) 0 ;
38547 wxCommandEvent *arg2 = 0 ;
38548 PyObject * obj0 = 0 ;
38549 PyObject * obj1 = 0 ;
38550 char *kwnames[] = {
38551 (char *) "self",(char *) "event", NULL
38552 };
38553
38554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38556 if (SWIG_arg_fail(1)) SWIG_fail;
38557 {
38558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38559 if (SWIG_arg_fail(2)) SWIG_fail;
38560 if (arg2 == NULL) {
38561 SWIG_null_ref("wxCommandEvent");
38562 }
38563 if (SWIG_arg_fail(2)) SWIG_fail;
38564 }
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 (arg1)->Command(*arg2);
38568
38569 wxPyEndAllowThreads(__tstate);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 }
38572 Py_INCREF(Py_None); resultobj = Py_None;
38573 return resultobj;
38574 fail:
38575 return NULL;
38576 }
38577
38578
38579 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38580 PyObject *resultobj = NULL;
38581 wxControl *arg1 = (wxControl *) 0 ;
38582 wxString result;
38583 PyObject * obj0 = 0 ;
38584 char *kwnames[] = {
38585 (char *) "self", NULL
38586 };
38587
38588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38590 if (SWIG_arg_fail(1)) SWIG_fail;
38591 {
38592 PyThreadState* __tstate = wxPyBeginAllowThreads();
38593 result = (arg1)->GetLabel();
38594
38595 wxPyEndAllowThreads(__tstate);
38596 if (PyErr_Occurred()) SWIG_fail;
38597 }
38598 {
38599 #if wxUSE_UNICODE
38600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38601 #else
38602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38603 #endif
38604 }
38605 return resultobj;
38606 fail:
38607 return NULL;
38608 }
38609
38610
38611 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj = NULL;
38613 wxControl *arg1 = (wxControl *) 0 ;
38614 wxString *arg2 = 0 ;
38615 bool temp2 = false ;
38616 PyObject * obj0 = 0 ;
38617 PyObject * obj1 = 0 ;
38618 char *kwnames[] = {
38619 (char *) "self",(char *) "label", NULL
38620 };
38621
38622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38624 if (SWIG_arg_fail(1)) SWIG_fail;
38625 {
38626 arg2 = wxString_in_helper(obj1);
38627 if (arg2 == NULL) SWIG_fail;
38628 temp2 = true;
38629 }
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 (arg1)->SetLabel((wxString const &)*arg2);
38633
38634 wxPyEndAllowThreads(__tstate);
38635 if (PyErr_Occurred()) SWIG_fail;
38636 }
38637 Py_INCREF(Py_None); resultobj = Py_None;
38638 {
38639 if (temp2)
38640 delete arg2;
38641 }
38642 return resultobj;
38643 fail:
38644 {
38645 if (temp2)
38646 delete arg2;
38647 }
38648 return NULL;
38649 }
38650
38651
38652 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38653 PyObject *resultobj = NULL;
38654 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38655 wxVisualAttributes result;
38656 PyObject * obj0 = 0 ;
38657 char *kwnames[] = {
38658 (char *) "variant", NULL
38659 };
38660
38661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38662 if (obj0) {
38663 {
38664 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38665 if (SWIG_arg_fail(1)) SWIG_fail;
38666 }
38667 }
38668 {
38669 if (!wxPyCheckForApp()) SWIG_fail;
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 result = wxControl::GetClassDefaultAttributes(arg1);
38672
38673 wxPyEndAllowThreads(__tstate);
38674 if (PyErr_Occurred()) SWIG_fail;
38675 }
38676 {
38677 wxVisualAttributes * resultptr;
38678 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38680 }
38681 return resultobj;
38682 fail:
38683 return NULL;
38684 }
38685
38686
38687 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38688 PyObject *obj;
38689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38690 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38691 Py_INCREF(obj);
38692 return Py_BuildValue((char *)"");
38693 }
38694 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38695 PyObject *resultobj = NULL;
38696 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38697 wxString *arg2 = 0 ;
38698 PyObject *arg3 = (PyObject *) NULL ;
38699 int result;
38700 bool temp2 = false ;
38701 PyObject * obj0 = 0 ;
38702 PyObject * obj1 = 0 ;
38703 PyObject * obj2 = 0 ;
38704 char *kwnames[] = {
38705 (char *) "self",(char *) "item",(char *) "clientData", NULL
38706 };
38707
38708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38710 if (SWIG_arg_fail(1)) SWIG_fail;
38711 {
38712 arg2 = wxString_in_helper(obj1);
38713 if (arg2 == NULL) SWIG_fail;
38714 temp2 = true;
38715 }
38716 if (obj2) {
38717 arg3 = obj2;
38718 }
38719 {
38720 PyThreadState* __tstate = wxPyBeginAllowThreads();
38721 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38722
38723 wxPyEndAllowThreads(__tstate);
38724 if (PyErr_Occurred()) SWIG_fail;
38725 }
38726 {
38727 resultobj = SWIG_From_int(static_cast<int >(result));
38728 }
38729 {
38730 if (temp2)
38731 delete arg2;
38732 }
38733 return resultobj;
38734 fail:
38735 {
38736 if (temp2)
38737 delete arg2;
38738 }
38739 return NULL;
38740 }
38741
38742
38743 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38744 PyObject *resultobj = NULL;
38745 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38746 wxArrayString *arg2 = 0 ;
38747 bool temp2 = false ;
38748 PyObject * obj0 = 0 ;
38749 PyObject * obj1 = 0 ;
38750 char *kwnames[] = {
38751 (char *) "self",(char *) "strings", NULL
38752 };
38753
38754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38756 if (SWIG_arg_fail(1)) SWIG_fail;
38757 {
38758 if (! PySequence_Check(obj1)) {
38759 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38760 SWIG_fail;
38761 }
38762 arg2 = new wxArrayString;
38763 temp2 = true;
38764 int i, len=PySequence_Length(obj1);
38765 for (i=0; i<len; i++) {
38766 PyObject* item = PySequence_GetItem(obj1, i);
38767 wxString* s = wxString_in_helper(item);
38768 if (PyErr_Occurred()) SWIG_fail;
38769 arg2->Add(*s);
38770 delete s;
38771 Py_DECREF(item);
38772 }
38773 }
38774 {
38775 PyThreadState* __tstate = wxPyBeginAllowThreads();
38776 (arg1)->Append((wxArrayString const &)*arg2);
38777
38778 wxPyEndAllowThreads(__tstate);
38779 if (PyErr_Occurred()) SWIG_fail;
38780 }
38781 Py_INCREF(Py_None); resultobj = Py_None;
38782 {
38783 if (temp2) delete arg2;
38784 }
38785 return resultobj;
38786 fail:
38787 {
38788 if (temp2) delete arg2;
38789 }
38790 return NULL;
38791 }
38792
38793
38794 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38795 PyObject *resultobj = NULL;
38796 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38797 wxString *arg2 = 0 ;
38798 int arg3 ;
38799 PyObject *arg4 = (PyObject *) NULL ;
38800 int result;
38801 bool temp2 = false ;
38802 PyObject * obj0 = 0 ;
38803 PyObject * obj1 = 0 ;
38804 PyObject * obj2 = 0 ;
38805 PyObject * obj3 = 0 ;
38806 char *kwnames[] = {
38807 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38808 };
38809
38810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38812 if (SWIG_arg_fail(1)) SWIG_fail;
38813 {
38814 arg2 = wxString_in_helper(obj1);
38815 if (arg2 == NULL) SWIG_fail;
38816 temp2 = true;
38817 }
38818 {
38819 arg3 = static_cast<int >(SWIG_As_int(obj2));
38820 if (SWIG_arg_fail(3)) SWIG_fail;
38821 }
38822 if (obj3) {
38823 arg4 = obj3;
38824 }
38825 {
38826 PyThreadState* __tstate = wxPyBeginAllowThreads();
38827 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38828
38829 wxPyEndAllowThreads(__tstate);
38830 if (PyErr_Occurred()) SWIG_fail;
38831 }
38832 {
38833 resultobj = SWIG_From_int(static_cast<int >(result));
38834 }
38835 {
38836 if (temp2)
38837 delete arg2;
38838 }
38839 return resultobj;
38840 fail:
38841 {
38842 if (temp2)
38843 delete arg2;
38844 }
38845 return NULL;
38846 }
38847
38848
38849 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38850 PyObject *resultobj = NULL;
38851 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38852 PyObject * obj0 = 0 ;
38853 char *kwnames[] = {
38854 (char *) "self", NULL
38855 };
38856
38857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38859 if (SWIG_arg_fail(1)) SWIG_fail;
38860 {
38861 PyThreadState* __tstate = wxPyBeginAllowThreads();
38862 (arg1)->Clear();
38863
38864 wxPyEndAllowThreads(__tstate);
38865 if (PyErr_Occurred()) SWIG_fail;
38866 }
38867 Py_INCREF(Py_None); resultobj = Py_None;
38868 return resultobj;
38869 fail:
38870 return NULL;
38871 }
38872
38873
38874 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38875 PyObject *resultobj = NULL;
38876 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38877 int arg2 ;
38878 PyObject * obj0 = 0 ;
38879 PyObject * obj1 = 0 ;
38880 char *kwnames[] = {
38881 (char *) "self",(char *) "n", NULL
38882 };
38883
38884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38886 if (SWIG_arg_fail(1)) SWIG_fail;
38887 {
38888 arg2 = static_cast<int >(SWIG_As_int(obj1));
38889 if (SWIG_arg_fail(2)) SWIG_fail;
38890 }
38891 {
38892 PyThreadState* __tstate = wxPyBeginAllowThreads();
38893 (arg1)->Delete(arg2);
38894
38895 wxPyEndAllowThreads(__tstate);
38896 if (PyErr_Occurred()) SWIG_fail;
38897 }
38898 Py_INCREF(Py_None); resultobj = Py_None;
38899 return resultobj;
38900 fail:
38901 return NULL;
38902 }
38903
38904
38905 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38906 PyObject *resultobj = NULL;
38907 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38908 int arg2 ;
38909 PyObject *result;
38910 PyObject * obj0 = 0 ;
38911 PyObject * obj1 = 0 ;
38912 char *kwnames[] = {
38913 (char *) "self",(char *) "n", NULL
38914 };
38915
38916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38918 if (SWIG_arg_fail(1)) SWIG_fail;
38919 {
38920 arg2 = static_cast<int >(SWIG_As_int(obj1));
38921 if (SWIG_arg_fail(2)) SWIG_fail;
38922 }
38923 {
38924 PyThreadState* __tstate = wxPyBeginAllowThreads();
38925 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38926
38927 wxPyEndAllowThreads(__tstate);
38928 if (PyErr_Occurred()) SWIG_fail;
38929 }
38930 resultobj = result;
38931 return resultobj;
38932 fail:
38933 return NULL;
38934 }
38935
38936
38937 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38938 PyObject *resultobj = NULL;
38939 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38940 int arg2 ;
38941 PyObject *arg3 = (PyObject *) 0 ;
38942 PyObject * obj0 = 0 ;
38943 PyObject * obj1 = 0 ;
38944 PyObject * obj2 = 0 ;
38945 char *kwnames[] = {
38946 (char *) "self",(char *) "n",(char *) "clientData", NULL
38947 };
38948
38949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38951 if (SWIG_arg_fail(1)) SWIG_fail;
38952 {
38953 arg2 = static_cast<int >(SWIG_As_int(obj1));
38954 if (SWIG_arg_fail(2)) SWIG_fail;
38955 }
38956 arg3 = obj2;
38957 {
38958 PyThreadState* __tstate = wxPyBeginAllowThreads();
38959 wxItemContainer_SetClientData(arg1,arg2,arg3);
38960
38961 wxPyEndAllowThreads(__tstate);
38962 if (PyErr_Occurred()) SWIG_fail;
38963 }
38964 Py_INCREF(Py_None); resultobj = Py_None;
38965 return resultobj;
38966 fail:
38967 return NULL;
38968 }
38969
38970
38971 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38972 PyObject *resultobj = NULL;
38973 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38974 int result;
38975 PyObject * obj0 = 0 ;
38976 char *kwnames[] = {
38977 (char *) "self", NULL
38978 };
38979
38980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38982 if (SWIG_arg_fail(1)) SWIG_fail;
38983 {
38984 PyThreadState* __tstate = wxPyBeginAllowThreads();
38985 result = (int)((wxItemContainer const *)arg1)->GetCount();
38986
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = SWIG_From_int(static_cast<int >(result));
38992 }
38993 return resultobj;
38994 fail:
38995 return NULL;
38996 }
38997
38998
38999 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
39000 PyObject *resultobj = NULL;
39001 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39002 bool result;
39003 PyObject * obj0 = 0 ;
39004 char *kwnames[] = {
39005 (char *) "self", NULL
39006 };
39007
39008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
39009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39010 if (SWIG_arg_fail(1)) SWIG_fail;
39011 {
39012 PyThreadState* __tstate = wxPyBeginAllowThreads();
39013 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
39014
39015 wxPyEndAllowThreads(__tstate);
39016 if (PyErr_Occurred()) SWIG_fail;
39017 }
39018 {
39019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39020 }
39021 return resultobj;
39022 fail:
39023 return NULL;
39024 }
39025
39026
39027 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
39028 PyObject *resultobj = NULL;
39029 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39030 int arg2 ;
39031 wxString result;
39032 PyObject * obj0 = 0 ;
39033 PyObject * obj1 = 0 ;
39034 char *kwnames[] = {
39035 (char *) "self",(char *) "n", NULL
39036 };
39037
39038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
39039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39040 if (SWIG_arg_fail(1)) SWIG_fail;
39041 {
39042 arg2 = static_cast<int >(SWIG_As_int(obj1));
39043 if (SWIG_arg_fail(2)) SWIG_fail;
39044 }
39045 {
39046 PyThreadState* __tstate = wxPyBeginAllowThreads();
39047 result = ((wxItemContainer const *)arg1)->GetString(arg2);
39048
39049 wxPyEndAllowThreads(__tstate);
39050 if (PyErr_Occurred()) SWIG_fail;
39051 }
39052 {
39053 #if wxUSE_UNICODE
39054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39055 #else
39056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39057 #endif
39058 }
39059 return resultobj;
39060 fail:
39061 return NULL;
39062 }
39063
39064
39065 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
39066 PyObject *resultobj = NULL;
39067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39068 wxArrayString result;
39069 PyObject * obj0 = 0 ;
39070 char *kwnames[] = {
39071 (char *) "self", NULL
39072 };
39073
39074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
39075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39076 if (SWIG_arg_fail(1)) SWIG_fail;
39077 {
39078 PyThreadState* __tstate = wxPyBeginAllowThreads();
39079 result = ((wxItemContainer const *)arg1)->GetStrings();
39080
39081 wxPyEndAllowThreads(__tstate);
39082 if (PyErr_Occurred()) SWIG_fail;
39083 }
39084 {
39085 resultobj = wxArrayString2PyList_helper(result);
39086 }
39087 return resultobj;
39088 fail:
39089 return NULL;
39090 }
39091
39092
39093 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
39094 PyObject *resultobj = NULL;
39095 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39096 int arg2 ;
39097 wxString *arg3 = 0 ;
39098 bool temp3 = false ;
39099 PyObject * obj0 = 0 ;
39100 PyObject * obj1 = 0 ;
39101 PyObject * obj2 = 0 ;
39102 char *kwnames[] = {
39103 (char *) "self",(char *) "n",(char *) "s", NULL
39104 };
39105
39106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
39107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39108 if (SWIG_arg_fail(1)) SWIG_fail;
39109 {
39110 arg2 = static_cast<int >(SWIG_As_int(obj1));
39111 if (SWIG_arg_fail(2)) SWIG_fail;
39112 }
39113 {
39114 arg3 = wxString_in_helper(obj2);
39115 if (arg3 == NULL) SWIG_fail;
39116 temp3 = true;
39117 }
39118 {
39119 PyThreadState* __tstate = wxPyBeginAllowThreads();
39120 (arg1)->SetString(arg2,(wxString const &)*arg3);
39121
39122 wxPyEndAllowThreads(__tstate);
39123 if (PyErr_Occurred()) SWIG_fail;
39124 }
39125 Py_INCREF(Py_None); resultobj = Py_None;
39126 {
39127 if (temp3)
39128 delete arg3;
39129 }
39130 return resultobj;
39131 fail:
39132 {
39133 if (temp3)
39134 delete arg3;
39135 }
39136 return NULL;
39137 }
39138
39139
39140 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39141 PyObject *resultobj = NULL;
39142 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39143 wxString *arg2 = 0 ;
39144 int result;
39145 bool temp2 = false ;
39146 PyObject * obj0 = 0 ;
39147 PyObject * obj1 = 0 ;
39148 char *kwnames[] = {
39149 (char *) "self",(char *) "s", NULL
39150 };
39151
39152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39154 if (SWIG_arg_fail(1)) SWIG_fail;
39155 {
39156 arg2 = wxString_in_helper(obj1);
39157 if (arg2 == NULL) SWIG_fail;
39158 temp2 = true;
39159 }
39160 {
39161 PyThreadState* __tstate = wxPyBeginAllowThreads();
39162 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39163
39164 wxPyEndAllowThreads(__tstate);
39165 if (PyErr_Occurred()) SWIG_fail;
39166 }
39167 {
39168 resultobj = SWIG_From_int(static_cast<int >(result));
39169 }
39170 {
39171 if (temp2)
39172 delete arg2;
39173 }
39174 return resultobj;
39175 fail:
39176 {
39177 if (temp2)
39178 delete arg2;
39179 }
39180 return NULL;
39181 }
39182
39183
39184 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39185 PyObject *resultobj = NULL;
39186 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39187 int arg2 ;
39188 PyObject * obj0 = 0 ;
39189 PyObject * obj1 = 0 ;
39190 char *kwnames[] = {
39191 (char *) "self",(char *) "n", NULL
39192 };
39193
39194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39196 if (SWIG_arg_fail(1)) SWIG_fail;
39197 {
39198 arg2 = static_cast<int >(SWIG_As_int(obj1));
39199 if (SWIG_arg_fail(2)) SWIG_fail;
39200 }
39201 {
39202 PyThreadState* __tstate = wxPyBeginAllowThreads();
39203 (arg1)->SetSelection(arg2);
39204
39205 wxPyEndAllowThreads(__tstate);
39206 if (PyErr_Occurred()) SWIG_fail;
39207 }
39208 Py_INCREF(Py_None); resultobj = Py_None;
39209 return resultobj;
39210 fail:
39211 return NULL;
39212 }
39213
39214
39215 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39216 PyObject *resultobj = NULL;
39217 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39218 int result;
39219 PyObject * obj0 = 0 ;
39220 char *kwnames[] = {
39221 (char *) "self", NULL
39222 };
39223
39224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39226 if (SWIG_arg_fail(1)) SWIG_fail;
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39230
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 {
39235 resultobj = SWIG_From_int(static_cast<int >(result));
39236 }
39237 return resultobj;
39238 fail:
39239 return NULL;
39240 }
39241
39242
39243 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39244 PyObject *resultobj = NULL;
39245 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39246 wxString *arg2 = 0 ;
39247 bool result;
39248 bool temp2 = false ;
39249 PyObject * obj0 = 0 ;
39250 PyObject * obj1 = 0 ;
39251 char *kwnames[] = {
39252 (char *) "self",(char *) "s", NULL
39253 };
39254
39255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39257 if (SWIG_arg_fail(1)) SWIG_fail;
39258 {
39259 arg2 = wxString_in_helper(obj1);
39260 if (arg2 == NULL) SWIG_fail;
39261 temp2 = true;
39262 }
39263 {
39264 PyThreadState* __tstate = wxPyBeginAllowThreads();
39265 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39266
39267 wxPyEndAllowThreads(__tstate);
39268 if (PyErr_Occurred()) SWIG_fail;
39269 }
39270 {
39271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39272 }
39273 {
39274 if (temp2)
39275 delete arg2;
39276 }
39277 return resultobj;
39278 fail:
39279 {
39280 if (temp2)
39281 delete arg2;
39282 }
39283 return NULL;
39284 }
39285
39286
39287 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39288 PyObject *resultobj = NULL;
39289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39290 wxString result;
39291 PyObject * obj0 = 0 ;
39292 char *kwnames[] = {
39293 (char *) "self", NULL
39294 };
39295
39296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39298 if (SWIG_arg_fail(1)) SWIG_fail;
39299 {
39300 PyThreadState* __tstate = wxPyBeginAllowThreads();
39301 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39302
39303 wxPyEndAllowThreads(__tstate);
39304 if (PyErr_Occurred()) SWIG_fail;
39305 }
39306 {
39307 #if wxUSE_UNICODE
39308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39309 #else
39310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39311 #endif
39312 }
39313 return resultobj;
39314 fail:
39315 return NULL;
39316 }
39317
39318
39319 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39320 PyObject *resultobj = NULL;
39321 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39322 int arg2 ;
39323 PyObject * obj0 = 0 ;
39324 PyObject * obj1 = 0 ;
39325 char *kwnames[] = {
39326 (char *) "self",(char *) "n", NULL
39327 };
39328
39329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39331 if (SWIG_arg_fail(1)) SWIG_fail;
39332 {
39333 arg2 = static_cast<int >(SWIG_As_int(obj1));
39334 if (SWIG_arg_fail(2)) SWIG_fail;
39335 }
39336 {
39337 PyThreadState* __tstate = wxPyBeginAllowThreads();
39338 (arg1)->Select(arg2);
39339
39340 wxPyEndAllowThreads(__tstate);
39341 if (PyErr_Occurred()) SWIG_fail;
39342 }
39343 Py_INCREF(Py_None); resultobj = Py_None;
39344 return resultobj;
39345 fail:
39346 return NULL;
39347 }
39348
39349
39350 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39351 PyObject *obj;
39352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39353 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39354 Py_INCREF(obj);
39355 return Py_BuildValue((char *)"");
39356 }
39357 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39358 PyObject *obj;
39359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39360 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39361 Py_INCREF(obj);
39362 return Py_BuildValue((char *)"");
39363 }
39364 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39365 PyObject *resultobj = NULL;
39366 wxSizerItem *result;
39367 char *kwnames[] = {
39368 NULL
39369 };
39370
39371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39372 {
39373 PyThreadState* __tstate = wxPyBeginAllowThreads();
39374 result = (wxSizerItem *)new wxSizerItem();
39375
39376 wxPyEndAllowThreads(__tstate);
39377 if (PyErr_Occurred()) SWIG_fail;
39378 }
39379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39380 return resultobj;
39381 fail:
39382 return NULL;
39383 }
39384
39385
39386 static PyObject *_wrap_delete_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39387 PyObject *resultobj = NULL;
39388 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39389 PyObject * obj0 = 0 ;
39390 char *kwnames[] = {
39391 (char *) "self", NULL
39392 };
39393
39394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SizerItem",kwnames,&obj0)) goto fail;
39395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39396 if (SWIG_arg_fail(1)) SWIG_fail;
39397 {
39398 PyThreadState* __tstate = wxPyBeginAllowThreads();
39399 delete arg1;
39400
39401 wxPyEndAllowThreads(__tstate);
39402 if (PyErr_Occurred()) SWIG_fail;
39403 }
39404 Py_INCREF(Py_None); resultobj = Py_None;
39405 return resultobj;
39406 fail:
39407 return NULL;
39408 }
39409
39410
39411 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39412 PyObject *resultobj = NULL;
39413 wxWindow *arg1 = (wxWindow *) 0 ;
39414 int arg2 ;
39415 int arg3 ;
39416 int arg4 ;
39417 PyObject *arg5 = (PyObject *) NULL ;
39418 wxSizerItem *result;
39419 PyObject * obj0 = 0 ;
39420 PyObject * obj1 = 0 ;
39421 PyObject * obj2 = 0 ;
39422 PyObject * obj3 = 0 ;
39423 PyObject * obj4 = 0 ;
39424 char *kwnames[] = {
39425 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39426 };
39427
39428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39430 if (SWIG_arg_fail(1)) SWIG_fail;
39431 {
39432 arg2 = static_cast<int >(SWIG_As_int(obj1));
39433 if (SWIG_arg_fail(2)) SWIG_fail;
39434 }
39435 {
39436 arg3 = static_cast<int >(SWIG_As_int(obj2));
39437 if (SWIG_arg_fail(3)) SWIG_fail;
39438 }
39439 {
39440 arg4 = static_cast<int >(SWIG_As_int(obj3));
39441 if (SWIG_arg_fail(4)) SWIG_fail;
39442 }
39443 if (obj4) {
39444 arg5 = obj4;
39445 }
39446 {
39447 PyThreadState* __tstate = wxPyBeginAllowThreads();
39448 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39449
39450 wxPyEndAllowThreads(__tstate);
39451 if (PyErr_Occurred()) SWIG_fail;
39452 }
39453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39454 return resultobj;
39455 fail:
39456 return NULL;
39457 }
39458
39459
39460 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39461 PyObject *resultobj = NULL;
39462 int arg1 ;
39463 int arg2 ;
39464 int arg3 ;
39465 int arg4 ;
39466 int arg5 ;
39467 PyObject *arg6 = (PyObject *) NULL ;
39468 wxSizerItem *result;
39469 PyObject * obj0 = 0 ;
39470 PyObject * obj1 = 0 ;
39471 PyObject * obj2 = 0 ;
39472 PyObject * obj3 = 0 ;
39473 PyObject * obj4 = 0 ;
39474 PyObject * obj5 = 0 ;
39475 char *kwnames[] = {
39476 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39477 };
39478
39479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39480 {
39481 arg1 = static_cast<int >(SWIG_As_int(obj0));
39482 if (SWIG_arg_fail(1)) SWIG_fail;
39483 }
39484 {
39485 arg2 = static_cast<int >(SWIG_As_int(obj1));
39486 if (SWIG_arg_fail(2)) SWIG_fail;
39487 }
39488 {
39489 arg3 = static_cast<int >(SWIG_As_int(obj2));
39490 if (SWIG_arg_fail(3)) SWIG_fail;
39491 }
39492 {
39493 arg4 = static_cast<int >(SWIG_As_int(obj3));
39494 if (SWIG_arg_fail(4)) SWIG_fail;
39495 }
39496 {
39497 arg5 = static_cast<int >(SWIG_As_int(obj4));
39498 if (SWIG_arg_fail(5)) SWIG_fail;
39499 }
39500 if (obj5) {
39501 arg6 = obj5;
39502 }
39503 {
39504 PyThreadState* __tstate = wxPyBeginAllowThreads();
39505 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39506
39507 wxPyEndAllowThreads(__tstate);
39508 if (PyErr_Occurred()) SWIG_fail;
39509 }
39510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39511 return resultobj;
39512 fail:
39513 return NULL;
39514 }
39515
39516
39517 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39518 PyObject *resultobj = NULL;
39519 wxSizer *arg1 = (wxSizer *) 0 ;
39520 int arg2 ;
39521 int arg3 ;
39522 int arg4 ;
39523 PyObject *arg5 = (PyObject *) NULL ;
39524 wxSizerItem *result;
39525 PyObject * obj0 = 0 ;
39526 PyObject * obj1 = 0 ;
39527 PyObject * obj2 = 0 ;
39528 PyObject * obj3 = 0 ;
39529 PyObject * obj4 = 0 ;
39530 char *kwnames[] = {
39531 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39532 };
39533
39534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
39536 if (SWIG_arg_fail(1)) SWIG_fail;
39537 {
39538 arg2 = static_cast<int >(SWIG_As_int(obj1));
39539 if (SWIG_arg_fail(2)) SWIG_fail;
39540 }
39541 {
39542 arg3 = static_cast<int >(SWIG_As_int(obj2));
39543 if (SWIG_arg_fail(3)) SWIG_fail;
39544 }
39545 {
39546 arg4 = static_cast<int >(SWIG_As_int(obj3));
39547 if (SWIG_arg_fail(4)) SWIG_fail;
39548 }
39549 if (obj4) {
39550 arg5 = obj4;
39551 }
39552 {
39553 PyThreadState* __tstate = wxPyBeginAllowThreads();
39554 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39555
39556 wxPyEndAllowThreads(__tstate);
39557 if (PyErr_Occurred()) SWIG_fail;
39558 }
39559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39560 return resultobj;
39561 fail:
39562 return NULL;
39563 }
39564
39565
39566 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39567 PyObject *resultobj = NULL;
39568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39569 PyObject * obj0 = 0 ;
39570 char *kwnames[] = {
39571 (char *) "self", NULL
39572 };
39573
39574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39576 if (SWIG_arg_fail(1)) SWIG_fail;
39577 {
39578 PyThreadState* __tstate = wxPyBeginAllowThreads();
39579 (arg1)->DeleteWindows();
39580
39581 wxPyEndAllowThreads(__tstate);
39582 if (PyErr_Occurred()) SWIG_fail;
39583 }
39584 Py_INCREF(Py_None); resultobj = Py_None;
39585 return resultobj;
39586 fail:
39587 return NULL;
39588 }
39589
39590
39591 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39592 PyObject *resultobj = NULL;
39593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39594 PyObject * obj0 = 0 ;
39595 char *kwnames[] = {
39596 (char *) "self", NULL
39597 };
39598
39599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39601 if (SWIG_arg_fail(1)) SWIG_fail;
39602 {
39603 PyThreadState* __tstate = wxPyBeginAllowThreads();
39604 (arg1)->DetachSizer();
39605
39606 wxPyEndAllowThreads(__tstate);
39607 if (PyErr_Occurred()) SWIG_fail;
39608 }
39609 Py_INCREF(Py_None); resultobj = Py_None;
39610 return resultobj;
39611 fail:
39612 return NULL;
39613 }
39614
39615
39616 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39617 PyObject *resultobj = NULL;
39618 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39619 wxSize result;
39620 PyObject * obj0 = 0 ;
39621 char *kwnames[] = {
39622 (char *) "self", NULL
39623 };
39624
39625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39627 if (SWIG_arg_fail(1)) SWIG_fail;
39628 {
39629 PyThreadState* __tstate = wxPyBeginAllowThreads();
39630 result = (arg1)->GetSize();
39631
39632 wxPyEndAllowThreads(__tstate);
39633 if (PyErr_Occurred()) SWIG_fail;
39634 }
39635 {
39636 wxSize * resultptr;
39637 resultptr = new wxSize(static_cast<wxSize & >(result));
39638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39639 }
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39647 PyObject *resultobj = NULL;
39648 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39649 wxSize result;
39650 PyObject * obj0 = 0 ;
39651 char *kwnames[] = {
39652 (char *) "self", NULL
39653 };
39654
39655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39657 if (SWIG_arg_fail(1)) SWIG_fail;
39658 {
39659 PyThreadState* __tstate = wxPyBeginAllowThreads();
39660 result = (arg1)->CalcMin();
39661
39662 wxPyEndAllowThreads(__tstate);
39663 if (PyErr_Occurred()) SWIG_fail;
39664 }
39665 {
39666 wxSize * resultptr;
39667 resultptr = new wxSize(static_cast<wxSize & >(result));
39668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39669 }
39670 return resultobj;
39671 fail:
39672 return NULL;
39673 }
39674
39675
39676 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39677 PyObject *resultobj = NULL;
39678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39679 wxPoint *arg2 = 0 ;
39680 wxSize *arg3 = 0 ;
39681 wxPoint temp2 ;
39682 wxSize temp3 ;
39683 PyObject * obj0 = 0 ;
39684 PyObject * obj1 = 0 ;
39685 PyObject * obj2 = 0 ;
39686 char *kwnames[] = {
39687 (char *) "self",(char *) "pos",(char *) "size", NULL
39688 };
39689
39690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39692 if (SWIG_arg_fail(1)) SWIG_fail;
39693 {
39694 arg2 = &temp2;
39695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39696 }
39697 {
39698 arg3 = &temp3;
39699 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39700 }
39701 {
39702 PyThreadState* __tstate = wxPyBeginAllowThreads();
39703 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
39704
39705 wxPyEndAllowThreads(__tstate);
39706 if (PyErr_Occurred()) SWIG_fail;
39707 }
39708 Py_INCREF(Py_None); resultobj = Py_None;
39709 return resultobj;
39710 fail:
39711 return NULL;
39712 }
39713
39714
39715 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39716 PyObject *resultobj = NULL;
39717 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39718 wxSize result;
39719 PyObject * obj0 = 0 ;
39720 char *kwnames[] = {
39721 (char *) "self", NULL
39722 };
39723
39724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39726 if (SWIG_arg_fail(1)) SWIG_fail;
39727 {
39728 PyThreadState* __tstate = wxPyBeginAllowThreads();
39729 result = (arg1)->GetMinSize();
39730
39731 wxPyEndAllowThreads(__tstate);
39732 if (PyErr_Occurred()) SWIG_fail;
39733 }
39734 {
39735 wxSize * resultptr;
39736 resultptr = new wxSize(static_cast<wxSize & >(result));
39737 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39738 }
39739 return resultobj;
39740 fail:
39741 return NULL;
39742 }
39743
39744
39745 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39746 PyObject *resultobj = NULL;
39747 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39748 wxSize result;
39749 PyObject * obj0 = 0 ;
39750 char *kwnames[] = {
39751 (char *) "self", NULL
39752 };
39753
39754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39756 if (SWIG_arg_fail(1)) SWIG_fail;
39757 {
39758 PyThreadState* __tstate = wxPyBeginAllowThreads();
39759 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39760
39761 wxPyEndAllowThreads(__tstate);
39762 if (PyErr_Occurred()) SWIG_fail;
39763 }
39764 {
39765 wxSize * resultptr;
39766 resultptr = new wxSize(static_cast<wxSize & >(result));
39767 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39768 }
39769 return resultobj;
39770 fail:
39771 return NULL;
39772 }
39773
39774
39775 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39776 PyObject *resultobj = NULL;
39777 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39778 int arg2 ;
39779 int arg3 ;
39780 PyObject * obj0 = 0 ;
39781 PyObject * obj1 = 0 ;
39782 PyObject * obj2 = 0 ;
39783 char *kwnames[] = {
39784 (char *) "self",(char *) "x",(char *) "y", NULL
39785 };
39786
39787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39789 if (SWIG_arg_fail(1)) SWIG_fail;
39790 {
39791 arg2 = static_cast<int >(SWIG_As_int(obj1));
39792 if (SWIG_arg_fail(2)) SWIG_fail;
39793 }
39794 {
39795 arg3 = static_cast<int >(SWIG_As_int(obj2));
39796 if (SWIG_arg_fail(3)) SWIG_fail;
39797 }
39798 {
39799 PyThreadState* __tstate = wxPyBeginAllowThreads();
39800 (arg1)->SetInitSize(arg2,arg3);
39801
39802 wxPyEndAllowThreads(__tstate);
39803 if (PyErr_Occurred()) SWIG_fail;
39804 }
39805 Py_INCREF(Py_None); resultobj = Py_None;
39806 return resultobj;
39807 fail:
39808 return NULL;
39809 }
39810
39811
39812 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39813 PyObject *resultobj = NULL;
39814 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39815 int arg2 ;
39816 int arg3 ;
39817 PyObject * obj0 = 0 ;
39818 PyObject * obj1 = 0 ;
39819 PyObject * obj2 = 0 ;
39820 char *kwnames[] = {
39821 (char *) "self",(char *) "width",(char *) "height", NULL
39822 };
39823
39824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39826 if (SWIG_arg_fail(1)) SWIG_fail;
39827 {
39828 arg2 = static_cast<int >(SWIG_As_int(obj1));
39829 if (SWIG_arg_fail(2)) SWIG_fail;
39830 }
39831 {
39832 arg3 = static_cast<int >(SWIG_As_int(obj2));
39833 if (SWIG_arg_fail(3)) SWIG_fail;
39834 }
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 (arg1)->SetRatio(arg2,arg3);
39838
39839 wxPyEndAllowThreads(__tstate);
39840 if (PyErr_Occurred()) SWIG_fail;
39841 }
39842 Py_INCREF(Py_None); resultobj = Py_None;
39843 return resultobj;
39844 fail:
39845 return NULL;
39846 }
39847
39848
39849 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39850 PyObject *resultobj = NULL;
39851 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39852 wxSize *arg2 = 0 ;
39853 wxSize temp2 ;
39854 PyObject * obj0 = 0 ;
39855 PyObject * obj1 = 0 ;
39856 char *kwnames[] = {
39857 (char *) "self",(char *) "size", NULL
39858 };
39859
39860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39862 if (SWIG_arg_fail(1)) SWIG_fail;
39863 {
39864 arg2 = &temp2;
39865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39866 }
39867 {
39868 PyThreadState* __tstate = wxPyBeginAllowThreads();
39869 (arg1)->SetRatio((wxSize const &)*arg2);
39870
39871 wxPyEndAllowThreads(__tstate);
39872 if (PyErr_Occurred()) SWIG_fail;
39873 }
39874 Py_INCREF(Py_None); resultobj = Py_None;
39875 return resultobj;
39876 fail:
39877 return NULL;
39878 }
39879
39880
39881 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39882 PyObject *resultobj = NULL;
39883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39884 float arg2 ;
39885 PyObject * obj0 = 0 ;
39886 PyObject * obj1 = 0 ;
39887 char *kwnames[] = {
39888 (char *) "self",(char *) "ratio", NULL
39889 };
39890
39891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39893 if (SWIG_arg_fail(1)) SWIG_fail;
39894 {
39895 arg2 = static_cast<float >(SWIG_As_float(obj1));
39896 if (SWIG_arg_fail(2)) SWIG_fail;
39897 }
39898 {
39899 PyThreadState* __tstate = wxPyBeginAllowThreads();
39900 (arg1)->SetRatio(arg2);
39901
39902 wxPyEndAllowThreads(__tstate);
39903 if (PyErr_Occurred()) SWIG_fail;
39904 }
39905 Py_INCREF(Py_None); resultobj = Py_None;
39906 return resultobj;
39907 fail:
39908 return NULL;
39909 }
39910
39911
39912 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39913 PyObject *resultobj = NULL;
39914 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39915 float result;
39916 PyObject * obj0 = 0 ;
39917 char *kwnames[] = {
39918 (char *) "self", NULL
39919 };
39920
39921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39923 if (SWIG_arg_fail(1)) SWIG_fail;
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 result = (float)(arg1)->GetRatio();
39927
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 {
39932 resultobj = SWIG_From_float(static_cast<float >(result));
39933 }
39934 return resultobj;
39935 fail:
39936 return NULL;
39937 }
39938
39939
39940 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39941 PyObject *resultobj = NULL;
39942 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39943 wxRect result;
39944 PyObject * obj0 = 0 ;
39945 char *kwnames[] = {
39946 (char *) "self", NULL
39947 };
39948
39949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39951 if (SWIG_arg_fail(1)) SWIG_fail;
39952 {
39953 PyThreadState* __tstate = wxPyBeginAllowThreads();
39954 result = (arg1)->GetRect();
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 {
39960 wxRect * resultptr;
39961 resultptr = new wxRect(static_cast<wxRect & >(result));
39962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39963 }
39964 return resultobj;
39965 fail:
39966 return NULL;
39967 }
39968
39969
39970 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39971 PyObject *resultobj = NULL;
39972 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39973 bool result;
39974 PyObject * obj0 = 0 ;
39975 char *kwnames[] = {
39976 (char *) "self", NULL
39977 };
39978
39979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39981 if (SWIG_arg_fail(1)) SWIG_fail;
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 result = (bool)(arg1)->IsWindow();
39985
39986 wxPyEndAllowThreads(__tstate);
39987 if (PyErr_Occurred()) SWIG_fail;
39988 }
39989 {
39990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39991 }
39992 return resultobj;
39993 fail:
39994 return NULL;
39995 }
39996
39997
39998 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39999 PyObject *resultobj = NULL;
40000 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40001 bool result;
40002 PyObject * obj0 = 0 ;
40003 char *kwnames[] = {
40004 (char *) "self", NULL
40005 };
40006
40007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
40008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40009 if (SWIG_arg_fail(1)) SWIG_fail;
40010 {
40011 PyThreadState* __tstate = wxPyBeginAllowThreads();
40012 result = (bool)(arg1)->IsSizer();
40013
40014 wxPyEndAllowThreads(__tstate);
40015 if (PyErr_Occurred()) SWIG_fail;
40016 }
40017 {
40018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40019 }
40020 return resultobj;
40021 fail:
40022 return NULL;
40023 }
40024
40025
40026 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40027 PyObject *resultobj = NULL;
40028 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40029 bool result;
40030 PyObject * obj0 = 0 ;
40031 char *kwnames[] = {
40032 (char *) "self", NULL
40033 };
40034
40035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
40036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40037 if (SWIG_arg_fail(1)) SWIG_fail;
40038 {
40039 PyThreadState* __tstate = wxPyBeginAllowThreads();
40040 result = (bool)(arg1)->IsSpacer();
40041
40042 wxPyEndAllowThreads(__tstate);
40043 if (PyErr_Occurred()) SWIG_fail;
40044 }
40045 {
40046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40047 }
40048 return resultobj;
40049 fail:
40050 return NULL;
40051 }
40052
40053
40054 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
40055 PyObject *resultobj = NULL;
40056 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40057 int arg2 ;
40058 PyObject * obj0 = 0 ;
40059 PyObject * obj1 = 0 ;
40060 char *kwnames[] = {
40061 (char *) "self",(char *) "proportion", NULL
40062 };
40063
40064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
40065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40066 if (SWIG_arg_fail(1)) SWIG_fail;
40067 {
40068 arg2 = static_cast<int >(SWIG_As_int(obj1));
40069 if (SWIG_arg_fail(2)) SWIG_fail;
40070 }
40071 {
40072 PyThreadState* __tstate = wxPyBeginAllowThreads();
40073 (arg1)->SetProportion(arg2);
40074
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 Py_INCREF(Py_None); resultobj = Py_None;
40079 return resultobj;
40080 fail:
40081 return NULL;
40082 }
40083
40084
40085 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
40086 PyObject *resultobj = NULL;
40087 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40088 int result;
40089 PyObject * obj0 = 0 ;
40090 char *kwnames[] = {
40091 (char *) "self", NULL
40092 };
40093
40094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
40095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40096 if (SWIG_arg_fail(1)) SWIG_fail;
40097 {
40098 PyThreadState* __tstate = wxPyBeginAllowThreads();
40099 result = (int)(arg1)->GetProportion();
40100
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 {
40105 resultobj = SWIG_From_int(static_cast<int >(result));
40106 }
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj = NULL;
40115 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40116 int arg2 ;
40117 PyObject * obj0 = 0 ;
40118 PyObject * obj1 = 0 ;
40119 char *kwnames[] = {
40120 (char *) "self",(char *) "flag", NULL
40121 };
40122
40123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
40124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40125 if (SWIG_arg_fail(1)) SWIG_fail;
40126 {
40127 arg2 = static_cast<int >(SWIG_As_int(obj1));
40128 if (SWIG_arg_fail(2)) SWIG_fail;
40129 }
40130 {
40131 PyThreadState* __tstate = wxPyBeginAllowThreads();
40132 (arg1)->SetFlag(arg2);
40133
40134 wxPyEndAllowThreads(__tstate);
40135 if (PyErr_Occurred()) SWIG_fail;
40136 }
40137 Py_INCREF(Py_None); resultobj = Py_None;
40138 return resultobj;
40139 fail:
40140 return NULL;
40141 }
40142
40143
40144 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40145 PyObject *resultobj = NULL;
40146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40147 int result;
40148 PyObject * obj0 = 0 ;
40149 char *kwnames[] = {
40150 (char *) "self", NULL
40151 };
40152
40153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40155 if (SWIG_arg_fail(1)) SWIG_fail;
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 result = (int)(arg1)->GetFlag();
40159
40160 wxPyEndAllowThreads(__tstate);
40161 if (PyErr_Occurred()) SWIG_fail;
40162 }
40163 {
40164 resultobj = SWIG_From_int(static_cast<int >(result));
40165 }
40166 return resultobj;
40167 fail:
40168 return NULL;
40169 }
40170
40171
40172 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40173 PyObject *resultobj = NULL;
40174 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40175 int arg2 ;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 char *kwnames[] = {
40179 (char *) "self",(char *) "border", NULL
40180 };
40181
40182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40184 if (SWIG_arg_fail(1)) SWIG_fail;
40185 {
40186 arg2 = static_cast<int >(SWIG_As_int(obj1));
40187 if (SWIG_arg_fail(2)) SWIG_fail;
40188 }
40189 {
40190 PyThreadState* __tstate = wxPyBeginAllowThreads();
40191 (arg1)->SetBorder(arg2);
40192
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 Py_INCREF(Py_None); resultobj = Py_None;
40197 return resultobj;
40198 fail:
40199 return NULL;
40200 }
40201
40202
40203 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40204 PyObject *resultobj = NULL;
40205 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40206 int result;
40207 PyObject * obj0 = 0 ;
40208 char *kwnames[] = {
40209 (char *) "self", NULL
40210 };
40211
40212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40214 if (SWIG_arg_fail(1)) SWIG_fail;
40215 {
40216 PyThreadState* __tstate = wxPyBeginAllowThreads();
40217 result = (int)(arg1)->GetBorder();
40218
40219 wxPyEndAllowThreads(__tstate);
40220 if (PyErr_Occurred()) SWIG_fail;
40221 }
40222 {
40223 resultobj = SWIG_From_int(static_cast<int >(result));
40224 }
40225 return resultobj;
40226 fail:
40227 return NULL;
40228 }
40229
40230
40231 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40232 PyObject *resultobj = NULL;
40233 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40234 wxWindow *result;
40235 PyObject * obj0 = 0 ;
40236 char *kwnames[] = {
40237 (char *) "self", NULL
40238 };
40239
40240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40242 if (SWIG_arg_fail(1)) SWIG_fail;
40243 {
40244 PyThreadState* __tstate = wxPyBeginAllowThreads();
40245 result = (wxWindow *)(arg1)->GetWindow();
40246
40247 wxPyEndAllowThreads(__tstate);
40248 if (PyErr_Occurred()) SWIG_fail;
40249 }
40250 {
40251 resultobj = wxPyMake_wxObject(result, 0);
40252 }
40253 return resultobj;
40254 fail:
40255 return NULL;
40256 }
40257
40258
40259 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40260 PyObject *resultobj = NULL;
40261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40262 wxWindow *arg2 = (wxWindow *) 0 ;
40263 PyObject * obj0 = 0 ;
40264 PyObject * obj1 = 0 ;
40265 char *kwnames[] = {
40266 (char *) "self",(char *) "window", NULL
40267 };
40268
40269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
40270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40271 if (SWIG_arg_fail(1)) SWIG_fail;
40272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40273 if (SWIG_arg_fail(2)) SWIG_fail;
40274 {
40275 PyThreadState* __tstate = wxPyBeginAllowThreads();
40276 (arg1)->SetWindow(arg2);
40277
40278 wxPyEndAllowThreads(__tstate);
40279 if (PyErr_Occurred()) SWIG_fail;
40280 }
40281 Py_INCREF(Py_None); resultobj = Py_None;
40282 return resultobj;
40283 fail:
40284 return NULL;
40285 }
40286
40287
40288 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40289 PyObject *resultobj = NULL;
40290 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40291 wxSizer *result;
40292 PyObject * obj0 = 0 ;
40293 char *kwnames[] = {
40294 (char *) "self", NULL
40295 };
40296
40297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40299 if (SWIG_arg_fail(1)) SWIG_fail;
40300 {
40301 PyThreadState* __tstate = wxPyBeginAllowThreads();
40302 result = (wxSizer *)(arg1)->GetSizer();
40303
40304 wxPyEndAllowThreads(__tstate);
40305 if (PyErr_Occurred()) SWIG_fail;
40306 }
40307 {
40308 resultobj = wxPyMake_wxObject(result, (bool)0);
40309 }
40310 return resultobj;
40311 fail:
40312 return NULL;
40313 }
40314
40315
40316 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj = NULL;
40318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40319 wxSizer *arg2 = (wxSizer *) 0 ;
40320 PyObject * obj0 = 0 ;
40321 PyObject * obj1 = 0 ;
40322 char *kwnames[] = {
40323 (char *) "self",(char *) "sizer", NULL
40324 };
40325
40326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40328 if (SWIG_arg_fail(1)) SWIG_fail;
40329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40330 if (SWIG_arg_fail(2)) SWIG_fail;
40331 {
40332 PyThreadState* __tstate = wxPyBeginAllowThreads();
40333 (arg1)->SetSizer(arg2);
40334
40335 wxPyEndAllowThreads(__tstate);
40336 if (PyErr_Occurred()) SWIG_fail;
40337 }
40338 Py_INCREF(Py_None); resultobj = Py_None;
40339 return resultobj;
40340 fail:
40341 return NULL;
40342 }
40343
40344
40345 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40346 PyObject *resultobj = NULL;
40347 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40348 wxSize *result;
40349 PyObject * obj0 = 0 ;
40350 char *kwnames[] = {
40351 (char *) "self", NULL
40352 };
40353
40354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40356 if (SWIG_arg_fail(1)) SWIG_fail;
40357 {
40358 PyThreadState* __tstate = wxPyBeginAllowThreads();
40359 {
40360 wxSize const &_result_ref = (arg1)->GetSpacer();
40361 result = (wxSize *) &_result_ref;
40362 }
40363
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj = NULL;
40376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40377 wxSize *arg2 = 0 ;
40378 wxSize temp2 ;
40379 PyObject * obj0 = 0 ;
40380 PyObject * obj1 = 0 ;
40381 char *kwnames[] = {
40382 (char *) "self",(char *) "size", NULL
40383 };
40384
40385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40387 if (SWIG_arg_fail(1)) SWIG_fail;
40388 {
40389 arg2 = &temp2;
40390 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40391 }
40392 {
40393 PyThreadState* __tstate = wxPyBeginAllowThreads();
40394 (arg1)->SetSpacer((wxSize const &)*arg2);
40395
40396 wxPyEndAllowThreads(__tstate);
40397 if (PyErr_Occurred()) SWIG_fail;
40398 }
40399 Py_INCREF(Py_None); resultobj = Py_None;
40400 return resultobj;
40401 fail:
40402 return NULL;
40403 }
40404
40405
40406 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40407 PyObject *resultobj = NULL;
40408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40409 bool arg2 ;
40410 PyObject * obj0 = 0 ;
40411 PyObject * obj1 = 0 ;
40412 char *kwnames[] = {
40413 (char *) "self",(char *) "show", NULL
40414 };
40415
40416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40418 if (SWIG_arg_fail(1)) SWIG_fail;
40419 {
40420 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40421 if (SWIG_arg_fail(2)) SWIG_fail;
40422 }
40423 {
40424 PyThreadState* __tstate = wxPyBeginAllowThreads();
40425 (arg1)->Show(arg2);
40426
40427 wxPyEndAllowThreads(__tstate);
40428 if (PyErr_Occurred()) SWIG_fail;
40429 }
40430 Py_INCREF(Py_None); resultobj = Py_None;
40431 return resultobj;
40432 fail:
40433 return NULL;
40434 }
40435
40436
40437 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40438 PyObject *resultobj = NULL;
40439 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40440 bool result;
40441 PyObject * obj0 = 0 ;
40442 char *kwnames[] = {
40443 (char *) "self", NULL
40444 };
40445
40446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40448 if (SWIG_arg_fail(1)) SWIG_fail;
40449 {
40450 PyThreadState* __tstate = wxPyBeginAllowThreads();
40451 result = (bool)(arg1)->IsShown();
40452
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 {
40457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40458 }
40459 return resultobj;
40460 fail:
40461 return NULL;
40462 }
40463
40464
40465 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40466 PyObject *resultobj = NULL;
40467 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40468 wxPoint result;
40469 PyObject * obj0 = 0 ;
40470 char *kwnames[] = {
40471 (char *) "self", NULL
40472 };
40473
40474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40476 if (SWIG_arg_fail(1)) SWIG_fail;
40477 {
40478 PyThreadState* __tstate = wxPyBeginAllowThreads();
40479 result = (arg1)->GetPosition();
40480
40481 wxPyEndAllowThreads(__tstate);
40482 if (PyErr_Occurred()) SWIG_fail;
40483 }
40484 {
40485 wxPoint * resultptr;
40486 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40488 }
40489 return resultobj;
40490 fail:
40491 return NULL;
40492 }
40493
40494
40495 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40496 PyObject *resultobj = NULL;
40497 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40498 PyObject *result;
40499 PyObject * obj0 = 0 ;
40500 char *kwnames[] = {
40501 (char *) "self", NULL
40502 };
40503
40504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40506 if (SWIG_arg_fail(1)) SWIG_fail;
40507 {
40508 PyThreadState* __tstate = wxPyBeginAllowThreads();
40509 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40510
40511 wxPyEndAllowThreads(__tstate);
40512 if (PyErr_Occurred()) SWIG_fail;
40513 }
40514 resultobj = result;
40515 return resultobj;
40516 fail:
40517 return NULL;
40518 }
40519
40520
40521 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40522 PyObject *resultobj = NULL;
40523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40524 PyObject *arg2 = (PyObject *) 0 ;
40525 PyObject * obj0 = 0 ;
40526 PyObject * obj1 = 0 ;
40527 char *kwnames[] = {
40528 (char *) "self",(char *) "userData", NULL
40529 };
40530
40531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40533 if (SWIG_arg_fail(1)) SWIG_fail;
40534 arg2 = obj1;
40535 {
40536 PyThreadState* __tstate = wxPyBeginAllowThreads();
40537 wxSizerItem_SetUserData(arg1,arg2);
40538
40539 wxPyEndAllowThreads(__tstate);
40540 if (PyErr_Occurred()) SWIG_fail;
40541 }
40542 Py_INCREF(Py_None); resultobj = Py_None;
40543 return resultobj;
40544 fail:
40545 return NULL;
40546 }
40547
40548
40549 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40550 PyObject *obj;
40551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40552 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40553 Py_INCREF(obj);
40554 return Py_BuildValue((char *)"");
40555 }
40556 static PyObject *_wrap_delete_Sizer(PyObject *, PyObject *args, PyObject *kwargs) {
40557 PyObject *resultobj = NULL;
40558 wxSizer *arg1 = (wxSizer *) 0 ;
40559 PyObject * obj0 = 0 ;
40560 char *kwnames[] = {
40561 (char *) "self", NULL
40562 };
40563
40564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sizer",kwnames,&obj0)) goto fail;
40565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40566 if (SWIG_arg_fail(1)) SWIG_fail;
40567 {
40568 PyThreadState* __tstate = wxPyBeginAllowThreads();
40569 delete arg1;
40570
40571 wxPyEndAllowThreads(__tstate);
40572 if (PyErr_Occurred()) SWIG_fail;
40573 }
40574 Py_INCREF(Py_None); resultobj = Py_None;
40575 return resultobj;
40576 fail:
40577 return NULL;
40578 }
40579
40580
40581 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40582 PyObject *resultobj = NULL;
40583 wxSizer *arg1 = (wxSizer *) 0 ;
40584 PyObject *arg2 = (PyObject *) 0 ;
40585 PyObject * obj0 = 0 ;
40586 PyObject * obj1 = 0 ;
40587 char *kwnames[] = {
40588 (char *) "self",(char *) "_self", NULL
40589 };
40590
40591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40593 if (SWIG_arg_fail(1)) SWIG_fail;
40594 arg2 = obj1;
40595 {
40596 PyThreadState* __tstate = wxPyBeginAllowThreads();
40597 wxSizer__setOORInfo(arg1,arg2);
40598
40599 wxPyEndAllowThreads(__tstate);
40600 if (PyErr_Occurred()) SWIG_fail;
40601 }
40602 Py_INCREF(Py_None); resultobj = Py_None;
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj = NULL;
40611 wxSizer *arg1 = (wxSizer *) 0 ;
40612 PyObject *arg2 = (PyObject *) 0 ;
40613 int arg3 = (int) 0 ;
40614 int arg4 = (int) 0 ;
40615 int arg5 = (int) 0 ;
40616 PyObject *arg6 = (PyObject *) NULL ;
40617 wxSizerItem *result;
40618 PyObject * obj0 = 0 ;
40619 PyObject * obj1 = 0 ;
40620 PyObject * obj2 = 0 ;
40621 PyObject * obj3 = 0 ;
40622 PyObject * obj4 = 0 ;
40623 PyObject * obj5 = 0 ;
40624 char *kwnames[] = {
40625 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40626 };
40627
40628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40630 if (SWIG_arg_fail(1)) SWIG_fail;
40631 arg2 = obj1;
40632 if (obj2) {
40633 {
40634 arg3 = static_cast<int >(SWIG_As_int(obj2));
40635 if (SWIG_arg_fail(3)) SWIG_fail;
40636 }
40637 }
40638 if (obj3) {
40639 {
40640 arg4 = static_cast<int >(SWIG_As_int(obj3));
40641 if (SWIG_arg_fail(4)) SWIG_fail;
40642 }
40643 }
40644 if (obj4) {
40645 {
40646 arg5 = static_cast<int >(SWIG_As_int(obj4));
40647 if (SWIG_arg_fail(5)) SWIG_fail;
40648 }
40649 }
40650 if (obj5) {
40651 arg6 = obj5;
40652 }
40653 {
40654 PyThreadState* __tstate = wxPyBeginAllowThreads();
40655 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40656
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40661 return resultobj;
40662 fail:
40663 return NULL;
40664 }
40665
40666
40667 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40668 PyObject *resultobj = NULL;
40669 wxSizer *arg1 = (wxSizer *) 0 ;
40670 int arg2 ;
40671 PyObject *arg3 = (PyObject *) 0 ;
40672 int arg4 = (int) 0 ;
40673 int arg5 = (int) 0 ;
40674 int arg6 = (int) 0 ;
40675 PyObject *arg7 = (PyObject *) NULL ;
40676 wxSizerItem *result;
40677 PyObject * obj0 = 0 ;
40678 PyObject * obj1 = 0 ;
40679 PyObject * obj2 = 0 ;
40680 PyObject * obj3 = 0 ;
40681 PyObject * obj4 = 0 ;
40682 PyObject * obj5 = 0 ;
40683 PyObject * obj6 = 0 ;
40684 char *kwnames[] = {
40685 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40686 };
40687
40688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40690 if (SWIG_arg_fail(1)) SWIG_fail;
40691 {
40692 arg2 = static_cast<int >(SWIG_As_int(obj1));
40693 if (SWIG_arg_fail(2)) SWIG_fail;
40694 }
40695 arg3 = obj2;
40696 if (obj3) {
40697 {
40698 arg4 = static_cast<int >(SWIG_As_int(obj3));
40699 if (SWIG_arg_fail(4)) SWIG_fail;
40700 }
40701 }
40702 if (obj4) {
40703 {
40704 arg5 = static_cast<int >(SWIG_As_int(obj4));
40705 if (SWIG_arg_fail(5)) SWIG_fail;
40706 }
40707 }
40708 if (obj5) {
40709 {
40710 arg6 = static_cast<int >(SWIG_As_int(obj5));
40711 if (SWIG_arg_fail(6)) SWIG_fail;
40712 }
40713 }
40714 if (obj6) {
40715 arg7 = obj6;
40716 }
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40720
40721 wxPyEndAllowThreads(__tstate);
40722 if (PyErr_Occurred()) SWIG_fail;
40723 }
40724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40725 return resultobj;
40726 fail:
40727 return NULL;
40728 }
40729
40730
40731 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40732 PyObject *resultobj = NULL;
40733 wxSizer *arg1 = (wxSizer *) 0 ;
40734 PyObject *arg2 = (PyObject *) 0 ;
40735 int arg3 = (int) 0 ;
40736 int arg4 = (int) 0 ;
40737 int arg5 = (int) 0 ;
40738 PyObject *arg6 = (PyObject *) NULL ;
40739 wxSizerItem *result;
40740 PyObject * obj0 = 0 ;
40741 PyObject * obj1 = 0 ;
40742 PyObject * obj2 = 0 ;
40743 PyObject * obj3 = 0 ;
40744 PyObject * obj4 = 0 ;
40745 PyObject * obj5 = 0 ;
40746 char *kwnames[] = {
40747 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40748 };
40749
40750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40752 if (SWIG_arg_fail(1)) SWIG_fail;
40753 arg2 = obj1;
40754 if (obj2) {
40755 {
40756 arg3 = static_cast<int >(SWIG_As_int(obj2));
40757 if (SWIG_arg_fail(3)) SWIG_fail;
40758 }
40759 }
40760 if (obj3) {
40761 {
40762 arg4 = static_cast<int >(SWIG_As_int(obj3));
40763 if (SWIG_arg_fail(4)) SWIG_fail;
40764 }
40765 }
40766 if (obj4) {
40767 {
40768 arg5 = static_cast<int >(SWIG_As_int(obj4));
40769 if (SWIG_arg_fail(5)) SWIG_fail;
40770 }
40771 }
40772 if (obj5) {
40773 arg6 = obj5;
40774 }
40775 {
40776 PyThreadState* __tstate = wxPyBeginAllowThreads();
40777 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40778
40779 wxPyEndAllowThreads(__tstate);
40780 if (PyErr_Occurred()) SWIG_fail;
40781 }
40782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40783 return resultobj;
40784 fail:
40785 return NULL;
40786 }
40787
40788
40789 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40790 PyObject *resultobj = NULL;
40791 wxSizer *arg1 = (wxSizer *) 0 ;
40792 PyObject *arg2 = (PyObject *) 0 ;
40793 bool result;
40794 PyObject * obj0 = 0 ;
40795 PyObject * obj1 = 0 ;
40796 char *kwnames[] = {
40797 (char *) "self",(char *) "item", NULL
40798 };
40799
40800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40802 if (SWIG_arg_fail(1)) SWIG_fail;
40803 arg2 = obj1;
40804 {
40805 PyThreadState* __tstate = wxPyBeginAllowThreads();
40806 result = (bool)wxSizer_Remove(arg1,arg2);
40807
40808 wxPyEndAllowThreads(__tstate);
40809 if (PyErr_Occurred()) SWIG_fail;
40810 }
40811 {
40812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40813 }
40814 return resultobj;
40815 fail:
40816 return NULL;
40817 }
40818
40819
40820 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40821 PyObject *resultobj = NULL;
40822 wxSizer *arg1 = (wxSizer *) 0 ;
40823 PyObject *arg2 = (PyObject *) 0 ;
40824 bool result;
40825 PyObject * obj0 = 0 ;
40826 PyObject * obj1 = 0 ;
40827 char *kwnames[] = {
40828 (char *) "self",(char *) "item", NULL
40829 };
40830
40831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40833 if (SWIG_arg_fail(1)) SWIG_fail;
40834 arg2 = obj1;
40835 {
40836 PyThreadState* __tstate = wxPyBeginAllowThreads();
40837 result = (bool)wxSizer_Detach(arg1,arg2);
40838
40839 wxPyEndAllowThreads(__tstate);
40840 if (PyErr_Occurred()) SWIG_fail;
40841 }
40842 {
40843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40844 }
40845 return resultobj;
40846 fail:
40847 return NULL;
40848 }
40849
40850
40851 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40852 PyObject *resultobj = NULL;
40853 wxSizer *arg1 = (wxSizer *) 0 ;
40854 PyObject *arg2 = (PyObject *) 0 ;
40855 wxSizerItem *result;
40856 PyObject * obj0 = 0 ;
40857 PyObject * obj1 = 0 ;
40858 char *kwnames[] = {
40859 (char *) "self",(char *) "item", NULL
40860 };
40861
40862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40864 if (SWIG_arg_fail(1)) SWIG_fail;
40865 arg2 = obj1;
40866 {
40867 PyThreadState* __tstate = wxPyBeginAllowThreads();
40868 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40869
40870 wxPyEndAllowThreads(__tstate);
40871 if (PyErr_Occurred()) SWIG_fail;
40872 }
40873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40874 return resultobj;
40875 fail:
40876 return NULL;
40877 }
40878
40879
40880 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40881 PyObject *resultobj = NULL;
40882 wxSizer *arg1 = (wxSizer *) 0 ;
40883 PyObject *arg2 = (PyObject *) 0 ;
40884 wxSize *arg3 = 0 ;
40885 wxSize temp3 ;
40886 PyObject * obj0 = 0 ;
40887 PyObject * obj1 = 0 ;
40888 PyObject * obj2 = 0 ;
40889 char *kwnames[] = {
40890 (char *) "self",(char *) "item",(char *) "size", NULL
40891 };
40892
40893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40895 if (SWIG_arg_fail(1)) SWIG_fail;
40896 arg2 = obj1;
40897 {
40898 arg3 = &temp3;
40899 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40900 }
40901 {
40902 PyThreadState* __tstate = wxPyBeginAllowThreads();
40903 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40904
40905 wxPyEndAllowThreads(__tstate);
40906 if (PyErr_Occurred()) SWIG_fail;
40907 }
40908 Py_INCREF(Py_None); resultobj = Py_None;
40909 return resultobj;
40910 fail:
40911 return NULL;
40912 }
40913
40914
40915 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40916 PyObject *resultobj = NULL;
40917 wxSizer *arg1 = (wxSizer *) 0 ;
40918 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40919 wxSizerItem *result;
40920 PyObject * obj0 = 0 ;
40921 PyObject * obj1 = 0 ;
40922 char *kwnames[] = {
40923 (char *) "self",(char *) "item", NULL
40924 };
40925
40926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40928 if (SWIG_arg_fail(1)) SWIG_fail;
40929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40930 if (SWIG_arg_fail(2)) SWIG_fail;
40931 {
40932 PyThreadState* __tstate = wxPyBeginAllowThreads();
40933 result = (wxSizerItem *)(arg1)->Add(arg2);
40934
40935 wxPyEndAllowThreads(__tstate);
40936 if (PyErr_Occurred()) SWIG_fail;
40937 }
40938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40939 return resultobj;
40940 fail:
40941 return NULL;
40942 }
40943
40944
40945 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40946 PyObject *resultobj = NULL;
40947 wxSizer *arg1 = (wxSizer *) 0 ;
40948 size_t arg2 ;
40949 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40950 wxSizerItem *result;
40951 PyObject * obj0 = 0 ;
40952 PyObject * obj1 = 0 ;
40953 PyObject * obj2 = 0 ;
40954 char *kwnames[] = {
40955 (char *) "self",(char *) "index",(char *) "item", NULL
40956 };
40957
40958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40960 if (SWIG_arg_fail(1)) SWIG_fail;
40961 {
40962 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40963 if (SWIG_arg_fail(2)) SWIG_fail;
40964 }
40965 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40966 if (SWIG_arg_fail(3)) SWIG_fail;
40967 {
40968 PyThreadState* __tstate = wxPyBeginAllowThreads();
40969 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40970
40971 wxPyEndAllowThreads(__tstate);
40972 if (PyErr_Occurred()) SWIG_fail;
40973 }
40974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40975 return resultobj;
40976 fail:
40977 return NULL;
40978 }
40979
40980
40981 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40982 PyObject *resultobj = NULL;
40983 wxSizer *arg1 = (wxSizer *) 0 ;
40984 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40985 wxSizerItem *result;
40986 PyObject * obj0 = 0 ;
40987 PyObject * obj1 = 0 ;
40988 char *kwnames[] = {
40989 (char *) "self",(char *) "item", NULL
40990 };
40991
40992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40994 if (SWIG_arg_fail(1)) SWIG_fail;
40995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40996 if (SWIG_arg_fail(2)) SWIG_fail;
40997 {
40998 PyThreadState* __tstate = wxPyBeginAllowThreads();
40999 result = (wxSizerItem *)(arg1)->Prepend(arg2);
41000
41001 wxPyEndAllowThreads(__tstate);
41002 if (PyErr_Occurred()) SWIG_fail;
41003 }
41004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
41005 return resultobj;
41006 fail:
41007 return NULL;
41008 }
41009
41010
41011 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
41012 PyObject *resultobj = NULL;
41013 wxSizer *arg1 = (wxSizer *) 0 ;
41014 int arg2 ;
41015 int arg3 ;
41016 int arg4 ;
41017 int arg5 ;
41018 PyObject * obj0 = 0 ;
41019 PyObject * obj1 = 0 ;
41020 PyObject * obj2 = 0 ;
41021 PyObject * obj3 = 0 ;
41022 PyObject * obj4 = 0 ;
41023 char *kwnames[] = {
41024 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
41025 };
41026
41027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
41028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41029 if (SWIG_arg_fail(1)) SWIG_fail;
41030 {
41031 arg2 = static_cast<int >(SWIG_As_int(obj1));
41032 if (SWIG_arg_fail(2)) SWIG_fail;
41033 }
41034 {
41035 arg3 = static_cast<int >(SWIG_As_int(obj2));
41036 if (SWIG_arg_fail(3)) SWIG_fail;
41037 }
41038 {
41039 arg4 = static_cast<int >(SWIG_As_int(obj3));
41040 if (SWIG_arg_fail(4)) SWIG_fail;
41041 }
41042 {
41043 arg5 = static_cast<int >(SWIG_As_int(obj4));
41044 if (SWIG_arg_fail(5)) SWIG_fail;
41045 }
41046 {
41047 PyThreadState* __tstate = wxPyBeginAllowThreads();
41048 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
41049
41050 wxPyEndAllowThreads(__tstate);
41051 if (PyErr_Occurred()) SWIG_fail;
41052 }
41053 Py_INCREF(Py_None); resultobj = Py_None;
41054 return resultobj;
41055 fail:
41056 return NULL;
41057 }
41058
41059
41060 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41061 PyObject *resultobj = NULL;
41062 wxSizer *arg1 = (wxSizer *) 0 ;
41063 wxSize *arg2 = 0 ;
41064 wxSize temp2 ;
41065 PyObject * obj0 = 0 ;
41066 PyObject * obj1 = 0 ;
41067 char *kwnames[] = {
41068 (char *) "self",(char *) "size", NULL
41069 };
41070
41071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
41072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41073 if (SWIG_arg_fail(1)) SWIG_fail;
41074 {
41075 arg2 = &temp2;
41076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41077 }
41078 {
41079 PyThreadState* __tstate = wxPyBeginAllowThreads();
41080 (arg1)->SetMinSize((wxSize const &)*arg2);
41081
41082 wxPyEndAllowThreads(__tstate);
41083 if (PyErr_Occurred()) SWIG_fail;
41084 }
41085 Py_INCREF(Py_None); resultobj = Py_None;
41086 return resultobj;
41087 fail:
41088 return NULL;
41089 }
41090
41091
41092 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
41093 PyObject *resultobj = NULL;
41094 wxSizer *arg1 = (wxSizer *) 0 ;
41095 wxSize result;
41096 PyObject * obj0 = 0 ;
41097 char *kwnames[] = {
41098 (char *) "self", NULL
41099 };
41100
41101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
41102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41103 if (SWIG_arg_fail(1)) SWIG_fail;
41104 {
41105 PyThreadState* __tstate = wxPyBeginAllowThreads();
41106 result = (arg1)->GetSize();
41107
41108 wxPyEndAllowThreads(__tstate);
41109 if (PyErr_Occurred()) SWIG_fail;
41110 }
41111 {
41112 wxSize * resultptr;
41113 resultptr = new wxSize(static_cast<wxSize & >(result));
41114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41115 }
41116 return resultobj;
41117 fail:
41118 return NULL;
41119 }
41120
41121
41122 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41123 PyObject *resultobj = NULL;
41124 wxSizer *arg1 = (wxSizer *) 0 ;
41125 wxPoint result;
41126 PyObject * obj0 = 0 ;
41127 char *kwnames[] = {
41128 (char *) "self", NULL
41129 };
41130
41131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
41132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41133 if (SWIG_arg_fail(1)) SWIG_fail;
41134 {
41135 PyThreadState* __tstate = wxPyBeginAllowThreads();
41136 result = (arg1)->GetPosition();
41137
41138 wxPyEndAllowThreads(__tstate);
41139 if (PyErr_Occurred()) SWIG_fail;
41140 }
41141 {
41142 wxPoint * resultptr;
41143 resultptr = new wxPoint(static_cast<wxPoint & >(result));
41144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
41145 }
41146 return resultobj;
41147 fail:
41148 return NULL;
41149 }
41150
41151
41152 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41153 PyObject *resultobj = NULL;
41154 wxSizer *arg1 = (wxSizer *) 0 ;
41155 wxSize result;
41156 PyObject * obj0 = 0 ;
41157 char *kwnames[] = {
41158 (char *) "self", NULL
41159 };
41160
41161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
41162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41163 if (SWIG_arg_fail(1)) SWIG_fail;
41164 {
41165 PyThreadState* __tstate = wxPyBeginAllowThreads();
41166 result = (arg1)->GetMinSize();
41167
41168 wxPyEndAllowThreads(__tstate);
41169 if (PyErr_Occurred()) SWIG_fail;
41170 }
41171 {
41172 wxSize * resultptr;
41173 resultptr = new wxSize(static_cast<wxSize & >(result));
41174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41175 }
41176 return resultobj;
41177 fail:
41178 return NULL;
41179 }
41180
41181
41182 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41183 PyObject *resultobj = NULL;
41184 wxSizer *arg1 = (wxSizer *) 0 ;
41185 PyObject * obj0 = 0 ;
41186 char *kwnames[] = {
41187 (char *) "self", NULL
41188 };
41189
41190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41192 if (SWIG_arg_fail(1)) SWIG_fail;
41193 {
41194 PyThreadState* __tstate = wxPyBeginAllowThreads();
41195 (arg1)->RecalcSizes();
41196
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 Py_INCREF(Py_None); resultobj = Py_None;
41201 return resultobj;
41202 fail:
41203 return NULL;
41204 }
41205
41206
41207 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41208 PyObject *resultobj = NULL;
41209 wxSizer *arg1 = (wxSizer *) 0 ;
41210 wxSize result;
41211 PyObject * obj0 = 0 ;
41212 char *kwnames[] = {
41213 (char *) "self", NULL
41214 };
41215
41216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41218 if (SWIG_arg_fail(1)) SWIG_fail;
41219 {
41220 PyThreadState* __tstate = wxPyBeginAllowThreads();
41221 result = (arg1)->CalcMin();
41222
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 {
41227 wxSize * resultptr;
41228 resultptr = new wxSize(static_cast<wxSize & >(result));
41229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41230 }
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41238 PyObject *resultobj = NULL;
41239 wxSizer *arg1 = (wxSizer *) 0 ;
41240 PyObject * obj0 = 0 ;
41241 char *kwnames[] = {
41242 (char *) "self", NULL
41243 };
41244
41245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41247 if (SWIG_arg_fail(1)) SWIG_fail;
41248 {
41249 PyThreadState* __tstate = wxPyBeginAllowThreads();
41250 (arg1)->Layout();
41251
41252 wxPyEndAllowThreads(__tstate);
41253 if (PyErr_Occurred()) SWIG_fail;
41254 }
41255 Py_INCREF(Py_None); resultobj = Py_None;
41256 return resultobj;
41257 fail:
41258 return NULL;
41259 }
41260
41261
41262 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41263 PyObject *resultobj = NULL;
41264 wxSizer *arg1 = (wxSizer *) 0 ;
41265 wxWindow *arg2 = (wxWindow *) 0 ;
41266 wxSize result;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 char *kwnames[] = {
41270 (char *) "self",(char *) "window", NULL
41271 };
41272
41273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41275 if (SWIG_arg_fail(1)) SWIG_fail;
41276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41277 if (SWIG_arg_fail(2)) SWIG_fail;
41278 {
41279 PyThreadState* __tstate = wxPyBeginAllowThreads();
41280 result = (arg1)->Fit(arg2);
41281
41282 wxPyEndAllowThreads(__tstate);
41283 if (PyErr_Occurred()) SWIG_fail;
41284 }
41285 {
41286 wxSize * resultptr;
41287 resultptr = new wxSize(static_cast<wxSize & >(result));
41288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41289 }
41290 return resultobj;
41291 fail:
41292 return NULL;
41293 }
41294
41295
41296 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41297 PyObject *resultobj = NULL;
41298 wxSizer *arg1 = (wxSizer *) 0 ;
41299 wxWindow *arg2 = (wxWindow *) 0 ;
41300 PyObject * obj0 = 0 ;
41301 PyObject * obj1 = 0 ;
41302 char *kwnames[] = {
41303 (char *) "self",(char *) "window", NULL
41304 };
41305
41306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41308 if (SWIG_arg_fail(1)) SWIG_fail;
41309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41310 if (SWIG_arg_fail(2)) SWIG_fail;
41311 {
41312 PyThreadState* __tstate = wxPyBeginAllowThreads();
41313 (arg1)->FitInside(arg2);
41314
41315 wxPyEndAllowThreads(__tstate);
41316 if (PyErr_Occurred()) SWIG_fail;
41317 }
41318 Py_INCREF(Py_None); resultobj = Py_None;
41319 return resultobj;
41320 fail:
41321 return NULL;
41322 }
41323
41324
41325 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41326 PyObject *resultobj = NULL;
41327 wxSizer *arg1 = (wxSizer *) 0 ;
41328 wxWindow *arg2 = (wxWindow *) 0 ;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 char *kwnames[] = {
41332 (char *) "self",(char *) "window", NULL
41333 };
41334
41335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41337 if (SWIG_arg_fail(1)) SWIG_fail;
41338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41339 if (SWIG_arg_fail(2)) SWIG_fail;
41340 {
41341 PyThreadState* __tstate = wxPyBeginAllowThreads();
41342 (arg1)->SetSizeHints(arg2);
41343
41344 wxPyEndAllowThreads(__tstate);
41345 if (PyErr_Occurred()) SWIG_fail;
41346 }
41347 Py_INCREF(Py_None); resultobj = Py_None;
41348 return resultobj;
41349 fail:
41350 return NULL;
41351 }
41352
41353
41354 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41355 PyObject *resultobj = NULL;
41356 wxSizer *arg1 = (wxSizer *) 0 ;
41357 wxWindow *arg2 = (wxWindow *) 0 ;
41358 PyObject * obj0 = 0 ;
41359 PyObject * obj1 = 0 ;
41360 char *kwnames[] = {
41361 (char *) "self",(char *) "window", NULL
41362 };
41363
41364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41366 if (SWIG_arg_fail(1)) SWIG_fail;
41367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41368 if (SWIG_arg_fail(2)) SWIG_fail;
41369 {
41370 PyThreadState* __tstate = wxPyBeginAllowThreads();
41371 (arg1)->SetVirtualSizeHints(arg2);
41372
41373 wxPyEndAllowThreads(__tstate);
41374 if (PyErr_Occurred()) SWIG_fail;
41375 }
41376 Py_INCREF(Py_None); resultobj = Py_None;
41377 return resultobj;
41378 fail:
41379 return NULL;
41380 }
41381
41382
41383 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41384 PyObject *resultobj = NULL;
41385 wxSizer *arg1 = (wxSizer *) 0 ;
41386 bool arg2 = (bool) false ;
41387 PyObject * obj0 = 0 ;
41388 PyObject * obj1 = 0 ;
41389 char *kwnames[] = {
41390 (char *) "self",(char *) "deleteWindows", NULL
41391 };
41392
41393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41395 if (SWIG_arg_fail(1)) SWIG_fail;
41396 if (obj1) {
41397 {
41398 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41399 if (SWIG_arg_fail(2)) SWIG_fail;
41400 }
41401 }
41402 {
41403 PyThreadState* __tstate = wxPyBeginAllowThreads();
41404 (arg1)->Clear(arg2);
41405
41406 wxPyEndAllowThreads(__tstate);
41407 if (PyErr_Occurred()) SWIG_fail;
41408 }
41409 Py_INCREF(Py_None); resultobj = Py_None;
41410 return resultobj;
41411 fail:
41412 return NULL;
41413 }
41414
41415
41416 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41417 PyObject *resultobj = NULL;
41418 wxSizer *arg1 = (wxSizer *) 0 ;
41419 PyObject * obj0 = 0 ;
41420 char *kwnames[] = {
41421 (char *) "self", NULL
41422 };
41423
41424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41426 if (SWIG_arg_fail(1)) SWIG_fail;
41427 {
41428 PyThreadState* __tstate = wxPyBeginAllowThreads();
41429 (arg1)->DeleteWindows();
41430
41431 wxPyEndAllowThreads(__tstate);
41432 if (PyErr_Occurred()) SWIG_fail;
41433 }
41434 Py_INCREF(Py_None); resultobj = Py_None;
41435 return resultobj;
41436 fail:
41437 return NULL;
41438 }
41439
41440
41441 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41442 PyObject *resultobj = NULL;
41443 wxSizer *arg1 = (wxSizer *) 0 ;
41444 PyObject *result;
41445 PyObject * obj0 = 0 ;
41446 char *kwnames[] = {
41447 (char *) "self", NULL
41448 };
41449
41450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41452 if (SWIG_arg_fail(1)) SWIG_fail;
41453 {
41454 PyThreadState* __tstate = wxPyBeginAllowThreads();
41455 result = (PyObject *)wxSizer_GetChildren(arg1);
41456
41457 wxPyEndAllowThreads(__tstate);
41458 if (PyErr_Occurred()) SWIG_fail;
41459 }
41460 resultobj = result;
41461 return resultobj;
41462 fail:
41463 return NULL;
41464 }
41465
41466
41467 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41468 PyObject *resultobj = NULL;
41469 wxSizer *arg1 = (wxSizer *) 0 ;
41470 PyObject *arg2 = (PyObject *) 0 ;
41471 bool arg3 = (bool) true ;
41472 bool arg4 = (bool) false ;
41473 bool result;
41474 PyObject * obj0 = 0 ;
41475 PyObject * obj1 = 0 ;
41476 PyObject * obj2 = 0 ;
41477 PyObject * obj3 = 0 ;
41478 char *kwnames[] = {
41479 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41480 };
41481
41482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41484 if (SWIG_arg_fail(1)) SWIG_fail;
41485 arg2 = obj1;
41486 if (obj2) {
41487 {
41488 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41489 if (SWIG_arg_fail(3)) SWIG_fail;
41490 }
41491 }
41492 if (obj3) {
41493 {
41494 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41495 if (SWIG_arg_fail(4)) SWIG_fail;
41496 }
41497 }
41498 {
41499 PyThreadState* __tstate = wxPyBeginAllowThreads();
41500 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41501
41502 wxPyEndAllowThreads(__tstate);
41503 if (PyErr_Occurred()) SWIG_fail;
41504 }
41505 {
41506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41507 }
41508 return resultobj;
41509 fail:
41510 return NULL;
41511 }
41512
41513
41514 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41515 PyObject *resultobj = NULL;
41516 wxSizer *arg1 = (wxSizer *) 0 ;
41517 PyObject *arg2 = (PyObject *) 0 ;
41518 bool result;
41519 PyObject * obj0 = 0 ;
41520 PyObject * obj1 = 0 ;
41521 char *kwnames[] = {
41522 (char *) "self",(char *) "item", NULL
41523 };
41524
41525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41527 if (SWIG_arg_fail(1)) SWIG_fail;
41528 arg2 = obj1;
41529 {
41530 PyThreadState* __tstate = wxPyBeginAllowThreads();
41531 result = (bool)wxSizer_IsShown(arg1,arg2);
41532
41533 wxPyEndAllowThreads(__tstate);
41534 if (PyErr_Occurred()) SWIG_fail;
41535 }
41536 {
41537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41538 }
41539 return resultobj;
41540 fail:
41541 return NULL;
41542 }
41543
41544
41545 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41546 PyObject *resultobj = NULL;
41547 wxSizer *arg1 = (wxSizer *) 0 ;
41548 bool arg2 ;
41549 PyObject * obj0 = 0 ;
41550 PyObject * obj1 = 0 ;
41551 char *kwnames[] = {
41552 (char *) "self",(char *) "show", NULL
41553 };
41554
41555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41557 if (SWIG_arg_fail(1)) SWIG_fail;
41558 {
41559 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41560 if (SWIG_arg_fail(2)) SWIG_fail;
41561 }
41562 {
41563 PyThreadState* __tstate = wxPyBeginAllowThreads();
41564 (arg1)->ShowItems(arg2);
41565
41566 wxPyEndAllowThreads(__tstate);
41567 if (PyErr_Occurred()) SWIG_fail;
41568 }
41569 Py_INCREF(Py_None); resultobj = Py_None;
41570 return resultobj;
41571 fail:
41572 return NULL;
41573 }
41574
41575
41576 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41577 PyObject *obj;
41578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41579 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41580 Py_INCREF(obj);
41581 return Py_BuildValue((char *)"");
41582 }
41583 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41584 PyObject *resultobj = NULL;
41585 wxPySizer *result;
41586 char *kwnames[] = {
41587 NULL
41588 };
41589
41590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41591 {
41592 PyThreadState* __tstate = wxPyBeginAllowThreads();
41593 result = (wxPySizer *)new wxPySizer();
41594
41595 wxPyEndAllowThreads(__tstate);
41596 if (PyErr_Occurred()) SWIG_fail;
41597 }
41598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41599 return resultobj;
41600 fail:
41601 return NULL;
41602 }
41603
41604
41605 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41606 PyObject *resultobj = NULL;
41607 wxPySizer *arg1 = (wxPySizer *) 0 ;
41608 PyObject *arg2 = (PyObject *) 0 ;
41609 PyObject *arg3 = (PyObject *) 0 ;
41610 PyObject * obj0 = 0 ;
41611 PyObject * obj1 = 0 ;
41612 PyObject * obj2 = 0 ;
41613 char *kwnames[] = {
41614 (char *) "self",(char *) "self",(char *) "_class", NULL
41615 };
41616
41617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41619 if (SWIG_arg_fail(1)) SWIG_fail;
41620 arg2 = obj1;
41621 arg3 = obj2;
41622 {
41623 PyThreadState* __tstate = wxPyBeginAllowThreads();
41624 (arg1)->_setCallbackInfo(arg2,arg3);
41625
41626 wxPyEndAllowThreads(__tstate);
41627 if (PyErr_Occurred()) SWIG_fail;
41628 }
41629 Py_INCREF(Py_None); resultobj = Py_None;
41630 return resultobj;
41631 fail:
41632 return NULL;
41633 }
41634
41635
41636 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41637 PyObject *obj;
41638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41639 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41640 Py_INCREF(obj);
41641 return Py_BuildValue((char *)"");
41642 }
41643 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41644 PyObject *resultobj = NULL;
41645 int arg1 = (int) wxHORIZONTAL ;
41646 wxBoxSizer *result;
41647 PyObject * obj0 = 0 ;
41648 char *kwnames[] = {
41649 (char *) "orient", NULL
41650 };
41651
41652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41653 if (obj0) {
41654 {
41655 arg1 = static_cast<int >(SWIG_As_int(obj0));
41656 if (SWIG_arg_fail(1)) SWIG_fail;
41657 }
41658 }
41659 {
41660 PyThreadState* __tstate = wxPyBeginAllowThreads();
41661 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41662
41663 wxPyEndAllowThreads(__tstate);
41664 if (PyErr_Occurred()) SWIG_fail;
41665 }
41666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41674 PyObject *resultobj = NULL;
41675 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41676 int result;
41677 PyObject * obj0 = 0 ;
41678 char *kwnames[] = {
41679 (char *) "self", NULL
41680 };
41681
41682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41684 if (SWIG_arg_fail(1)) SWIG_fail;
41685 {
41686 PyThreadState* __tstate = wxPyBeginAllowThreads();
41687 result = (int)(arg1)->GetOrientation();
41688
41689 wxPyEndAllowThreads(__tstate);
41690 if (PyErr_Occurred()) SWIG_fail;
41691 }
41692 {
41693 resultobj = SWIG_From_int(static_cast<int >(result));
41694 }
41695 return resultobj;
41696 fail:
41697 return NULL;
41698 }
41699
41700
41701 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41702 PyObject *resultobj = NULL;
41703 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41704 int arg2 ;
41705 PyObject * obj0 = 0 ;
41706 PyObject * obj1 = 0 ;
41707 char *kwnames[] = {
41708 (char *) "self",(char *) "orient", NULL
41709 };
41710
41711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41713 if (SWIG_arg_fail(1)) SWIG_fail;
41714 {
41715 arg2 = static_cast<int >(SWIG_As_int(obj1));
41716 if (SWIG_arg_fail(2)) SWIG_fail;
41717 }
41718 {
41719 PyThreadState* __tstate = wxPyBeginAllowThreads();
41720 (arg1)->SetOrientation(arg2);
41721
41722 wxPyEndAllowThreads(__tstate);
41723 if (PyErr_Occurred()) SWIG_fail;
41724 }
41725 Py_INCREF(Py_None); resultobj = Py_None;
41726 return resultobj;
41727 fail:
41728 return NULL;
41729 }
41730
41731
41732 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41733 PyObject *obj;
41734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41735 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41736 Py_INCREF(obj);
41737 return Py_BuildValue((char *)"");
41738 }
41739 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41740 PyObject *resultobj = NULL;
41741 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41742 int arg2 = (int) wxHORIZONTAL ;
41743 wxStaticBoxSizer *result;
41744 PyObject * obj0 = 0 ;
41745 PyObject * obj1 = 0 ;
41746 char *kwnames[] = {
41747 (char *) "box",(char *) "orient", NULL
41748 };
41749
41750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41752 if (SWIG_arg_fail(1)) SWIG_fail;
41753 if (obj1) {
41754 {
41755 arg2 = static_cast<int >(SWIG_As_int(obj1));
41756 if (SWIG_arg_fail(2)) SWIG_fail;
41757 }
41758 }
41759 {
41760 PyThreadState* __tstate = wxPyBeginAllowThreads();
41761 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41762
41763 wxPyEndAllowThreads(__tstate);
41764 if (PyErr_Occurred()) SWIG_fail;
41765 }
41766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41767 return resultobj;
41768 fail:
41769 return NULL;
41770 }
41771
41772
41773 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41774 PyObject *resultobj = NULL;
41775 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41776 wxStaticBox *result;
41777 PyObject * obj0 = 0 ;
41778 char *kwnames[] = {
41779 (char *) "self", NULL
41780 };
41781
41782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41784 if (SWIG_arg_fail(1)) SWIG_fail;
41785 {
41786 PyThreadState* __tstate = wxPyBeginAllowThreads();
41787 result = (wxStaticBox *)(arg1)->GetStaticBox();
41788
41789 wxPyEndAllowThreads(__tstate);
41790 if (PyErr_Occurred()) SWIG_fail;
41791 }
41792 {
41793 resultobj = wxPyMake_wxObject(result, (bool)0);
41794 }
41795 return resultobj;
41796 fail:
41797 return NULL;
41798 }
41799
41800
41801 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41802 PyObject *obj;
41803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41804 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41805 Py_INCREF(obj);
41806 return Py_BuildValue((char *)"");
41807 }
41808 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41809 PyObject *resultobj = NULL;
41810 int arg1 = (int) 1 ;
41811 int arg2 = (int) 0 ;
41812 int arg3 = (int) 0 ;
41813 int arg4 = (int) 0 ;
41814 wxGridSizer *result;
41815 PyObject * obj0 = 0 ;
41816 PyObject * obj1 = 0 ;
41817 PyObject * obj2 = 0 ;
41818 PyObject * obj3 = 0 ;
41819 char *kwnames[] = {
41820 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41821 };
41822
41823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41824 if (obj0) {
41825 {
41826 arg1 = static_cast<int >(SWIG_As_int(obj0));
41827 if (SWIG_arg_fail(1)) SWIG_fail;
41828 }
41829 }
41830 if (obj1) {
41831 {
41832 arg2 = static_cast<int >(SWIG_As_int(obj1));
41833 if (SWIG_arg_fail(2)) SWIG_fail;
41834 }
41835 }
41836 if (obj2) {
41837 {
41838 arg3 = static_cast<int >(SWIG_As_int(obj2));
41839 if (SWIG_arg_fail(3)) SWIG_fail;
41840 }
41841 }
41842 if (obj3) {
41843 {
41844 arg4 = static_cast<int >(SWIG_As_int(obj3));
41845 if (SWIG_arg_fail(4)) SWIG_fail;
41846 }
41847 }
41848 {
41849 PyThreadState* __tstate = wxPyBeginAllowThreads();
41850 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41851
41852 wxPyEndAllowThreads(__tstate);
41853 if (PyErr_Occurred()) SWIG_fail;
41854 }
41855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41856 return resultobj;
41857 fail:
41858 return NULL;
41859 }
41860
41861
41862 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41863 PyObject *resultobj = NULL;
41864 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41865 int arg2 ;
41866 PyObject * obj0 = 0 ;
41867 PyObject * obj1 = 0 ;
41868 char *kwnames[] = {
41869 (char *) "self",(char *) "cols", NULL
41870 };
41871
41872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41874 if (SWIG_arg_fail(1)) SWIG_fail;
41875 {
41876 arg2 = static_cast<int >(SWIG_As_int(obj1));
41877 if (SWIG_arg_fail(2)) SWIG_fail;
41878 }
41879 {
41880 PyThreadState* __tstate = wxPyBeginAllowThreads();
41881 (arg1)->SetCols(arg2);
41882
41883 wxPyEndAllowThreads(__tstate);
41884 if (PyErr_Occurred()) SWIG_fail;
41885 }
41886 Py_INCREF(Py_None); resultobj = Py_None;
41887 return resultobj;
41888 fail:
41889 return NULL;
41890 }
41891
41892
41893 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41894 PyObject *resultobj = NULL;
41895 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41896 int arg2 ;
41897 PyObject * obj0 = 0 ;
41898 PyObject * obj1 = 0 ;
41899 char *kwnames[] = {
41900 (char *) "self",(char *) "rows", NULL
41901 };
41902
41903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41905 if (SWIG_arg_fail(1)) SWIG_fail;
41906 {
41907 arg2 = static_cast<int >(SWIG_As_int(obj1));
41908 if (SWIG_arg_fail(2)) SWIG_fail;
41909 }
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 (arg1)->SetRows(arg2);
41913
41914 wxPyEndAllowThreads(__tstate);
41915 if (PyErr_Occurred()) SWIG_fail;
41916 }
41917 Py_INCREF(Py_None); resultobj = Py_None;
41918 return resultobj;
41919 fail:
41920 return NULL;
41921 }
41922
41923
41924 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41925 PyObject *resultobj = NULL;
41926 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41927 int arg2 ;
41928 PyObject * obj0 = 0 ;
41929 PyObject * obj1 = 0 ;
41930 char *kwnames[] = {
41931 (char *) "self",(char *) "gap", NULL
41932 };
41933
41934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41936 if (SWIG_arg_fail(1)) SWIG_fail;
41937 {
41938 arg2 = static_cast<int >(SWIG_As_int(obj1));
41939 if (SWIG_arg_fail(2)) SWIG_fail;
41940 }
41941 {
41942 PyThreadState* __tstate = wxPyBeginAllowThreads();
41943 (arg1)->SetVGap(arg2);
41944
41945 wxPyEndAllowThreads(__tstate);
41946 if (PyErr_Occurred()) SWIG_fail;
41947 }
41948 Py_INCREF(Py_None); resultobj = Py_None;
41949 return resultobj;
41950 fail:
41951 return NULL;
41952 }
41953
41954
41955 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41956 PyObject *resultobj = NULL;
41957 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41958 int arg2 ;
41959 PyObject * obj0 = 0 ;
41960 PyObject * obj1 = 0 ;
41961 char *kwnames[] = {
41962 (char *) "self",(char *) "gap", NULL
41963 };
41964
41965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41967 if (SWIG_arg_fail(1)) SWIG_fail;
41968 {
41969 arg2 = static_cast<int >(SWIG_As_int(obj1));
41970 if (SWIG_arg_fail(2)) SWIG_fail;
41971 }
41972 {
41973 PyThreadState* __tstate = wxPyBeginAllowThreads();
41974 (arg1)->SetHGap(arg2);
41975
41976 wxPyEndAllowThreads(__tstate);
41977 if (PyErr_Occurred()) SWIG_fail;
41978 }
41979 Py_INCREF(Py_None); resultobj = Py_None;
41980 return resultobj;
41981 fail:
41982 return NULL;
41983 }
41984
41985
41986 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41987 PyObject *resultobj = NULL;
41988 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41989 int result;
41990 PyObject * obj0 = 0 ;
41991 char *kwnames[] = {
41992 (char *) "self", NULL
41993 };
41994
41995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41997 if (SWIG_arg_fail(1)) SWIG_fail;
41998 {
41999 PyThreadState* __tstate = wxPyBeginAllowThreads();
42000 result = (int)(arg1)->GetCols();
42001
42002 wxPyEndAllowThreads(__tstate);
42003 if (PyErr_Occurred()) SWIG_fail;
42004 }
42005 {
42006 resultobj = SWIG_From_int(static_cast<int >(result));
42007 }
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
42015 PyObject *resultobj = NULL;
42016 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
42017 int result;
42018 PyObject * obj0 = 0 ;
42019 char *kwnames[] = {
42020 (char *) "self", NULL
42021 };
42022
42023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
42024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
42025 if (SWIG_arg_fail(1)) SWIG_fail;
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = (int)(arg1)->GetRows();
42029
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 {
42034 resultobj = SWIG_From_int(static_cast<int >(result));
42035 }
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
42043 PyObject *resultobj = NULL;
42044 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
42045 int result;
42046 PyObject * obj0 = 0 ;
42047 char *kwnames[] = {
42048 (char *) "self", NULL
42049 };
42050
42051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
42052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
42053 if (SWIG_arg_fail(1)) SWIG_fail;
42054 {
42055 PyThreadState* __tstate = wxPyBeginAllowThreads();
42056 result = (int)(arg1)->GetVGap();
42057
42058 wxPyEndAllowThreads(__tstate);
42059 if (PyErr_Occurred()) SWIG_fail;
42060 }
42061 {
42062 resultobj = SWIG_From_int(static_cast<int >(result));
42063 }
42064 return resultobj;
42065 fail:
42066 return NULL;
42067 }
42068
42069
42070 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
42071 PyObject *resultobj = NULL;
42072 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
42073 int result;
42074 PyObject * obj0 = 0 ;
42075 char *kwnames[] = {
42076 (char *) "self", NULL
42077 };
42078
42079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
42080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
42081 if (SWIG_arg_fail(1)) SWIG_fail;
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 result = (int)(arg1)->GetHGap();
42085
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 {
42090 resultobj = SWIG_From_int(static_cast<int >(result));
42091 }
42092 return resultobj;
42093 fail:
42094 return NULL;
42095 }
42096
42097
42098 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
42099 PyObject *obj;
42100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42101 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
42102 Py_INCREF(obj);
42103 return Py_BuildValue((char *)"");
42104 }
42105 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42106 PyObject *resultobj = NULL;
42107 int arg1 = (int) 1 ;
42108 int arg2 = (int) 0 ;
42109 int arg3 = (int) 0 ;
42110 int arg4 = (int) 0 ;
42111 wxFlexGridSizer *result;
42112 PyObject * obj0 = 0 ;
42113 PyObject * obj1 = 0 ;
42114 PyObject * obj2 = 0 ;
42115 PyObject * obj3 = 0 ;
42116 char *kwnames[] = {
42117 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
42118 };
42119
42120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42121 if (obj0) {
42122 {
42123 arg1 = static_cast<int >(SWIG_As_int(obj0));
42124 if (SWIG_arg_fail(1)) SWIG_fail;
42125 }
42126 }
42127 if (obj1) {
42128 {
42129 arg2 = static_cast<int >(SWIG_As_int(obj1));
42130 if (SWIG_arg_fail(2)) SWIG_fail;
42131 }
42132 }
42133 if (obj2) {
42134 {
42135 arg3 = static_cast<int >(SWIG_As_int(obj2));
42136 if (SWIG_arg_fail(3)) SWIG_fail;
42137 }
42138 }
42139 if (obj3) {
42140 {
42141 arg4 = static_cast<int >(SWIG_As_int(obj3));
42142 if (SWIG_arg_fail(4)) SWIG_fail;
42143 }
42144 }
42145 {
42146 PyThreadState* __tstate = wxPyBeginAllowThreads();
42147 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
42148
42149 wxPyEndAllowThreads(__tstate);
42150 if (PyErr_Occurred()) SWIG_fail;
42151 }
42152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
42153 return resultobj;
42154 fail:
42155 return NULL;
42156 }
42157
42158
42159 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42160 PyObject *resultobj = NULL;
42161 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42162 size_t arg2 ;
42163 int arg3 = (int) 0 ;
42164 PyObject * obj0 = 0 ;
42165 PyObject * obj1 = 0 ;
42166 PyObject * obj2 = 0 ;
42167 char *kwnames[] = {
42168 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42169 };
42170
42171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42173 if (SWIG_arg_fail(1)) SWIG_fail;
42174 {
42175 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42176 if (SWIG_arg_fail(2)) SWIG_fail;
42177 }
42178 if (obj2) {
42179 {
42180 arg3 = static_cast<int >(SWIG_As_int(obj2));
42181 if (SWIG_arg_fail(3)) SWIG_fail;
42182 }
42183 }
42184 {
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 (arg1)->AddGrowableRow(arg2,arg3);
42187
42188 wxPyEndAllowThreads(__tstate);
42189 if (PyErr_Occurred()) SWIG_fail;
42190 }
42191 Py_INCREF(Py_None); resultobj = Py_None;
42192 return resultobj;
42193 fail:
42194 return NULL;
42195 }
42196
42197
42198 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42199 PyObject *resultobj = NULL;
42200 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42201 size_t arg2 ;
42202 PyObject * obj0 = 0 ;
42203 PyObject * obj1 = 0 ;
42204 char *kwnames[] = {
42205 (char *) "self",(char *) "idx", NULL
42206 };
42207
42208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42210 if (SWIG_arg_fail(1)) SWIG_fail;
42211 {
42212 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42213 if (SWIG_arg_fail(2)) SWIG_fail;
42214 }
42215 {
42216 PyThreadState* __tstate = wxPyBeginAllowThreads();
42217 (arg1)->RemoveGrowableRow(arg2);
42218
42219 wxPyEndAllowThreads(__tstate);
42220 if (PyErr_Occurred()) SWIG_fail;
42221 }
42222 Py_INCREF(Py_None); resultobj = Py_None;
42223 return resultobj;
42224 fail:
42225 return NULL;
42226 }
42227
42228
42229 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42230 PyObject *resultobj = NULL;
42231 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42232 size_t arg2 ;
42233 int arg3 = (int) 0 ;
42234 PyObject * obj0 = 0 ;
42235 PyObject * obj1 = 0 ;
42236 PyObject * obj2 = 0 ;
42237 char *kwnames[] = {
42238 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42239 };
42240
42241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42243 if (SWIG_arg_fail(1)) SWIG_fail;
42244 {
42245 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42246 if (SWIG_arg_fail(2)) SWIG_fail;
42247 }
42248 if (obj2) {
42249 {
42250 arg3 = static_cast<int >(SWIG_As_int(obj2));
42251 if (SWIG_arg_fail(3)) SWIG_fail;
42252 }
42253 }
42254 {
42255 PyThreadState* __tstate = wxPyBeginAllowThreads();
42256 (arg1)->AddGrowableCol(arg2,arg3);
42257
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 Py_INCREF(Py_None); resultobj = Py_None;
42262 return resultobj;
42263 fail:
42264 return NULL;
42265 }
42266
42267
42268 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42269 PyObject *resultobj = NULL;
42270 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42271 size_t arg2 ;
42272 PyObject * obj0 = 0 ;
42273 PyObject * obj1 = 0 ;
42274 char *kwnames[] = {
42275 (char *) "self",(char *) "idx", NULL
42276 };
42277
42278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42280 if (SWIG_arg_fail(1)) SWIG_fail;
42281 {
42282 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42283 if (SWIG_arg_fail(2)) SWIG_fail;
42284 }
42285 {
42286 PyThreadState* __tstate = wxPyBeginAllowThreads();
42287 (arg1)->RemoveGrowableCol(arg2);
42288
42289 wxPyEndAllowThreads(__tstate);
42290 if (PyErr_Occurred()) SWIG_fail;
42291 }
42292 Py_INCREF(Py_None); resultobj = Py_None;
42293 return resultobj;
42294 fail:
42295 return NULL;
42296 }
42297
42298
42299 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42300 PyObject *resultobj = NULL;
42301 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42302 int arg2 ;
42303 PyObject * obj0 = 0 ;
42304 PyObject * obj1 = 0 ;
42305 char *kwnames[] = {
42306 (char *) "self",(char *) "direction", NULL
42307 };
42308
42309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42311 if (SWIG_arg_fail(1)) SWIG_fail;
42312 {
42313 arg2 = static_cast<int >(SWIG_As_int(obj1));
42314 if (SWIG_arg_fail(2)) SWIG_fail;
42315 }
42316 {
42317 PyThreadState* __tstate = wxPyBeginAllowThreads();
42318 (arg1)->SetFlexibleDirection(arg2);
42319
42320 wxPyEndAllowThreads(__tstate);
42321 if (PyErr_Occurred()) SWIG_fail;
42322 }
42323 Py_INCREF(Py_None); resultobj = Py_None;
42324 return resultobj;
42325 fail:
42326 return NULL;
42327 }
42328
42329
42330 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42331 PyObject *resultobj = NULL;
42332 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42333 int result;
42334 PyObject * obj0 = 0 ;
42335 char *kwnames[] = {
42336 (char *) "self", NULL
42337 };
42338
42339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42341 if (SWIG_arg_fail(1)) SWIG_fail;
42342 {
42343 PyThreadState* __tstate = wxPyBeginAllowThreads();
42344 result = (int)(arg1)->GetFlexibleDirection();
42345
42346 wxPyEndAllowThreads(__tstate);
42347 if (PyErr_Occurred()) SWIG_fail;
42348 }
42349 {
42350 resultobj = SWIG_From_int(static_cast<int >(result));
42351 }
42352 return resultobj;
42353 fail:
42354 return NULL;
42355 }
42356
42357
42358 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42359 PyObject *resultobj = NULL;
42360 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42361 wxFlexSizerGrowMode arg2 ;
42362 PyObject * obj0 = 0 ;
42363 PyObject * obj1 = 0 ;
42364 char *kwnames[] = {
42365 (char *) "self",(char *) "mode", NULL
42366 };
42367
42368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42370 if (SWIG_arg_fail(1)) SWIG_fail;
42371 {
42372 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42373 if (SWIG_arg_fail(2)) SWIG_fail;
42374 }
42375 {
42376 PyThreadState* __tstate = wxPyBeginAllowThreads();
42377 (arg1)->SetNonFlexibleGrowMode(arg2);
42378
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 Py_INCREF(Py_None); resultobj = Py_None;
42383 return resultobj;
42384 fail:
42385 return NULL;
42386 }
42387
42388
42389 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42390 PyObject *resultobj = NULL;
42391 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42392 wxFlexSizerGrowMode result;
42393 PyObject * obj0 = 0 ;
42394 char *kwnames[] = {
42395 (char *) "self", NULL
42396 };
42397
42398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42400 if (SWIG_arg_fail(1)) SWIG_fail;
42401 {
42402 PyThreadState* __tstate = wxPyBeginAllowThreads();
42403 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42404
42405 wxPyEndAllowThreads(__tstate);
42406 if (PyErr_Occurred()) SWIG_fail;
42407 }
42408 resultobj = SWIG_From_int((result));
42409 return resultobj;
42410 fail:
42411 return NULL;
42412 }
42413
42414
42415 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42416 PyObject *resultobj = NULL;
42417 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42418 wxArrayInt *result;
42419 PyObject * obj0 = 0 ;
42420 char *kwnames[] = {
42421 (char *) "self", NULL
42422 };
42423
42424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42426 if (SWIG_arg_fail(1)) SWIG_fail;
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 {
42430 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42431 result = (wxArrayInt *) &_result_ref;
42432 }
42433
42434 wxPyEndAllowThreads(__tstate);
42435 if (PyErr_Occurred()) SWIG_fail;
42436 }
42437 {
42438 resultobj = PyList_New(0);
42439 size_t idx;
42440 for (idx = 0; idx < result->GetCount(); idx += 1) {
42441 PyObject* val = PyInt_FromLong( result->Item(idx) );
42442 PyList_Append(resultobj, val);
42443 Py_DECREF(val);
42444 }
42445 }
42446 return resultobj;
42447 fail:
42448 return NULL;
42449 }
42450
42451
42452 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42453 PyObject *resultobj = NULL;
42454 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42455 wxArrayInt *result;
42456 PyObject * obj0 = 0 ;
42457 char *kwnames[] = {
42458 (char *) "self", NULL
42459 };
42460
42461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42463 if (SWIG_arg_fail(1)) SWIG_fail;
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 {
42467 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42468 result = (wxArrayInt *) &_result_ref;
42469 }
42470
42471 wxPyEndAllowThreads(__tstate);
42472 if (PyErr_Occurred()) SWIG_fail;
42473 }
42474 {
42475 resultobj = PyList_New(0);
42476 size_t idx;
42477 for (idx = 0; idx < result->GetCount(); idx += 1) {
42478 PyObject* val = PyInt_FromLong( result->Item(idx) );
42479 PyList_Append(resultobj, val);
42480 Py_DECREF(val);
42481 }
42482 }
42483 return resultobj;
42484 fail:
42485 return NULL;
42486 }
42487
42488
42489 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42490 PyObject *obj;
42491 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42492 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42493 Py_INCREF(obj);
42494 return Py_BuildValue((char *)"");
42495 }
42496 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42497 PyObject *resultobj = NULL;
42498 wxStdDialogButtonSizer *result;
42499 char *kwnames[] = {
42500 NULL
42501 };
42502
42503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42504 {
42505 PyThreadState* __tstate = wxPyBeginAllowThreads();
42506 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42507
42508 wxPyEndAllowThreads(__tstate);
42509 if (PyErr_Occurred()) SWIG_fail;
42510 }
42511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42512 return resultobj;
42513 fail:
42514 return NULL;
42515 }
42516
42517
42518 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42519 PyObject *resultobj = NULL;
42520 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42521 wxButton *arg2 = (wxButton *) 0 ;
42522 PyObject * obj0 = 0 ;
42523 PyObject * obj1 = 0 ;
42524 char *kwnames[] = {
42525 (char *) "self",(char *) "button", NULL
42526 };
42527
42528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42530 if (SWIG_arg_fail(1)) SWIG_fail;
42531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42532 if (SWIG_arg_fail(2)) SWIG_fail;
42533 {
42534 PyThreadState* __tstate = wxPyBeginAllowThreads();
42535 (arg1)->AddButton(arg2);
42536
42537 wxPyEndAllowThreads(__tstate);
42538 if (PyErr_Occurred()) SWIG_fail;
42539 }
42540 Py_INCREF(Py_None); resultobj = Py_None;
42541 return resultobj;
42542 fail:
42543 return NULL;
42544 }
42545
42546
42547 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42548 PyObject *resultobj = NULL;
42549 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42550 PyObject * obj0 = 0 ;
42551 char *kwnames[] = {
42552 (char *) "self", NULL
42553 };
42554
42555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42557 if (SWIG_arg_fail(1)) SWIG_fail;
42558 {
42559 PyThreadState* __tstate = wxPyBeginAllowThreads();
42560 (arg1)->Realize();
42561
42562 wxPyEndAllowThreads(__tstate);
42563 if (PyErr_Occurred()) SWIG_fail;
42564 }
42565 Py_INCREF(Py_None); resultobj = Py_None;
42566 return resultobj;
42567 fail:
42568 return NULL;
42569 }
42570
42571
42572 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42573 PyObject *resultobj = NULL;
42574 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42575 wxButton *arg2 = (wxButton *) 0 ;
42576 PyObject * obj0 = 0 ;
42577 PyObject * obj1 = 0 ;
42578 char *kwnames[] = {
42579 (char *) "self",(char *) "button", NULL
42580 };
42581
42582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42584 if (SWIG_arg_fail(1)) SWIG_fail;
42585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42586 if (SWIG_arg_fail(2)) SWIG_fail;
42587 {
42588 PyThreadState* __tstate = wxPyBeginAllowThreads();
42589 (arg1)->SetAffirmativeButton(arg2);
42590
42591 wxPyEndAllowThreads(__tstate);
42592 if (PyErr_Occurred()) SWIG_fail;
42593 }
42594 Py_INCREF(Py_None); resultobj = Py_None;
42595 return resultobj;
42596 fail:
42597 return NULL;
42598 }
42599
42600
42601 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42602 PyObject *resultobj = NULL;
42603 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42604 wxButton *arg2 = (wxButton *) 0 ;
42605 PyObject * obj0 = 0 ;
42606 PyObject * obj1 = 0 ;
42607 char *kwnames[] = {
42608 (char *) "self",(char *) "button", NULL
42609 };
42610
42611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42613 if (SWIG_arg_fail(1)) SWIG_fail;
42614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42615 if (SWIG_arg_fail(2)) SWIG_fail;
42616 {
42617 PyThreadState* __tstate = wxPyBeginAllowThreads();
42618 (arg1)->SetNegativeButton(arg2);
42619
42620 wxPyEndAllowThreads(__tstate);
42621 if (PyErr_Occurred()) SWIG_fail;
42622 }
42623 Py_INCREF(Py_None); resultobj = Py_None;
42624 return resultobj;
42625 fail:
42626 return NULL;
42627 }
42628
42629
42630 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42631 PyObject *resultobj = NULL;
42632 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42633 wxButton *arg2 = (wxButton *) 0 ;
42634 PyObject * obj0 = 0 ;
42635 PyObject * obj1 = 0 ;
42636 char *kwnames[] = {
42637 (char *) "self",(char *) "button", NULL
42638 };
42639
42640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42642 if (SWIG_arg_fail(1)) SWIG_fail;
42643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42644 if (SWIG_arg_fail(2)) SWIG_fail;
42645 {
42646 PyThreadState* __tstate = wxPyBeginAllowThreads();
42647 (arg1)->SetCancelButton(arg2);
42648
42649 wxPyEndAllowThreads(__tstate);
42650 if (PyErr_Occurred()) SWIG_fail;
42651 }
42652 Py_INCREF(Py_None); resultobj = Py_None;
42653 return resultobj;
42654 fail:
42655 return NULL;
42656 }
42657
42658
42659 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42660 PyObject *resultobj = NULL;
42661 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42662 wxButton *result;
42663 PyObject * obj0 = 0 ;
42664 char *kwnames[] = {
42665 (char *) "self", NULL
42666 };
42667
42668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42670 if (SWIG_arg_fail(1)) SWIG_fail;
42671 {
42672 PyThreadState* __tstate = wxPyBeginAllowThreads();
42673 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42674
42675 wxPyEndAllowThreads(__tstate);
42676 if (PyErr_Occurred()) SWIG_fail;
42677 }
42678 {
42679 resultobj = wxPyMake_wxObject(result, (bool)0);
42680 }
42681 return resultobj;
42682 fail:
42683 return NULL;
42684 }
42685
42686
42687 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42688 PyObject *resultobj = NULL;
42689 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42690 wxButton *result;
42691 PyObject * obj0 = 0 ;
42692 char *kwnames[] = {
42693 (char *) "self", NULL
42694 };
42695
42696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42698 if (SWIG_arg_fail(1)) SWIG_fail;
42699 {
42700 PyThreadState* __tstate = wxPyBeginAllowThreads();
42701 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42702
42703 wxPyEndAllowThreads(__tstate);
42704 if (PyErr_Occurred()) SWIG_fail;
42705 }
42706 {
42707 resultobj = wxPyMake_wxObject(result, (bool)0);
42708 }
42709 return resultobj;
42710 fail:
42711 return NULL;
42712 }
42713
42714
42715 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42716 PyObject *resultobj = NULL;
42717 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42718 wxButton *result;
42719 PyObject * obj0 = 0 ;
42720 char *kwnames[] = {
42721 (char *) "self", NULL
42722 };
42723
42724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42726 if (SWIG_arg_fail(1)) SWIG_fail;
42727 {
42728 PyThreadState* __tstate = wxPyBeginAllowThreads();
42729 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42730
42731 wxPyEndAllowThreads(__tstate);
42732 if (PyErr_Occurred()) SWIG_fail;
42733 }
42734 {
42735 resultobj = wxPyMake_wxObject(result, (bool)0);
42736 }
42737 return resultobj;
42738 fail:
42739 return NULL;
42740 }
42741
42742
42743 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42744 PyObject *resultobj = NULL;
42745 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42746 wxButton *result;
42747 PyObject * obj0 = 0 ;
42748 char *kwnames[] = {
42749 (char *) "self", NULL
42750 };
42751
42752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42754 if (SWIG_arg_fail(1)) SWIG_fail;
42755 {
42756 PyThreadState* __tstate = wxPyBeginAllowThreads();
42757 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42758
42759 wxPyEndAllowThreads(__tstate);
42760 if (PyErr_Occurred()) SWIG_fail;
42761 }
42762 {
42763 resultobj = wxPyMake_wxObject(result, (bool)0);
42764 }
42765 return resultobj;
42766 fail:
42767 return NULL;
42768 }
42769
42770
42771 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42772 PyObject *resultobj = NULL;
42773 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42774 wxButton *result;
42775 PyObject * obj0 = 0 ;
42776 char *kwnames[] = {
42777 (char *) "self", NULL
42778 };
42779
42780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42782 if (SWIG_arg_fail(1)) SWIG_fail;
42783 {
42784 PyThreadState* __tstate = wxPyBeginAllowThreads();
42785 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42786
42787 wxPyEndAllowThreads(__tstate);
42788 if (PyErr_Occurred()) SWIG_fail;
42789 }
42790 {
42791 resultobj = wxPyMake_wxObject(result, (bool)0);
42792 }
42793 return resultobj;
42794 fail:
42795 return NULL;
42796 }
42797
42798
42799 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42800 PyObject *obj;
42801 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42802 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42803 Py_INCREF(obj);
42804 return Py_BuildValue((char *)"");
42805 }
42806 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42807 PyObject *resultobj = NULL;
42808 int arg1 = (int) 0 ;
42809 int arg2 = (int) 0 ;
42810 wxGBPosition *result;
42811 PyObject * obj0 = 0 ;
42812 PyObject * obj1 = 0 ;
42813 char *kwnames[] = {
42814 (char *) "row",(char *) "col", NULL
42815 };
42816
42817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42818 if (obj0) {
42819 {
42820 arg1 = static_cast<int >(SWIG_As_int(obj0));
42821 if (SWIG_arg_fail(1)) SWIG_fail;
42822 }
42823 }
42824 if (obj1) {
42825 {
42826 arg2 = static_cast<int >(SWIG_As_int(obj1));
42827 if (SWIG_arg_fail(2)) SWIG_fail;
42828 }
42829 }
42830 {
42831 PyThreadState* __tstate = wxPyBeginAllowThreads();
42832 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42833
42834 wxPyEndAllowThreads(__tstate);
42835 if (PyErr_Occurred()) SWIG_fail;
42836 }
42837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42838 return resultobj;
42839 fail:
42840 return NULL;
42841 }
42842
42843
42844 static PyObject *_wrap_delete_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42845 PyObject *resultobj = NULL;
42846 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42847 PyObject * obj0 = 0 ;
42848 char *kwnames[] = {
42849 (char *) "self", NULL
42850 };
42851
42852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBPosition",kwnames,&obj0)) goto fail;
42853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42854 if (SWIG_arg_fail(1)) SWIG_fail;
42855 {
42856 PyThreadState* __tstate = wxPyBeginAllowThreads();
42857 delete arg1;
42858
42859 wxPyEndAllowThreads(__tstate);
42860 if (PyErr_Occurred()) SWIG_fail;
42861 }
42862 Py_INCREF(Py_None); resultobj = Py_None;
42863 return resultobj;
42864 fail:
42865 return NULL;
42866 }
42867
42868
42869 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42870 PyObject *resultobj = NULL;
42871 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42872 int result;
42873 PyObject * obj0 = 0 ;
42874 char *kwnames[] = {
42875 (char *) "self", NULL
42876 };
42877
42878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42880 if (SWIG_arg_fail(1)) SWIG_fail;
42881 {
42882 PyThreadState* __tstate = wxPyBeginAllowThreads();
42883 result = (int)((wxGBPosition const *)arg1)->GetRow();
42884
42885 wxPyEndAllowThreads(__tstate);
42886 if (PyErr_Occurred()) SWIG_fail;
42887 }
42888 {
42889 resultobj = SWIG_From_int(static_cast<int >(result));
42890 }
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42898 PyObject *resultobj = NULL;
42899 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42900 int result;
42901 PyObject * obj0 = 0 ;
42902 char *kwnames[] = {
42903 (char *) "self", NULL
42904 };
42905
42906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42908 if (SWIG_arg_fail(1)) SWIG_fail;
42909 {
42910 PyThreadState* __tstate = wxPyBeginAllowThreads();
42911 result = (int)((wxGBPosition const *)arg1)->GetCol();
42912
42913 wxPyEndAllowThreads(__tstate);
42914 if (PyErr_Occurred()) SWIG_fail;
42915 }
42916 {
42917 resultobj = SWIG_From_int(static_cast<int >(result));
42918 }
42919 return resultobj;
42920 fail:
42921 return NULL;
42922 }
42923
42924
42925 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42926 PyObject *resultobj = NULL;
42927 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42928 int arg2 ;
42929 PyObject * obj0 = 0 ;
42930 PyObject * obj1 = 0 ;
42931 char *kwnames[] = {
42932 (char *) "self",(char *) "row", NULL
42933 };
42934
42935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42937 if (SWIG_arg_fail(1)) SWIG_fail;
42938 {
42939 arg2 = static_cast<int >(SWIG_As_int(obj1));
42940 if (SWIG_arg_fail(2)) SWIG_fail;
42941 }
42942 {
42943 PyThreadState* __tstate = wxPyBeginAllowThreads();
42944 (arg1)->SetRow(arg2);
42945
42946 wxPyEndAllowThreads(__tstate);
42947 if (PyErr_Occurred()) SWIG_fail;
42948 }
42949 Py_INCREF(Py_None); resultobj = Py_None;
42950 return resultobj;
42951 fail:
42952 return NULL;
42953 }
42954
42955
42956 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42957 PyObject *resultobj = NULL;
42958 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42959 int arg2 ;
42960 PyObject * obj0 = 0 ;
42961 PyObject * obj1 = 0 ;
42962 char *kwnames[] = {
42963 (char *) "self",(char *) "col", NULL
42964 };
42965
42966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42968 if (SWIG_arg_fail(1)) SWIG_fail;
42969 {
42970 arg2 = static_cast<int >(SWIG_As_int(obj1));
42971 if (SWIG_arg_fail(2)) SWIG_fail;
42972 }
42973 {
42974 PyThreadState* __tstate = wxPyBeginAllowThreads();
42975 (arg1)->SetCol(arg2);
42976
42977 wxPyEndAllowThreads(__tstate);
42978 if (PyErr_Occurred()) SWIG_fail;
42979 }
42980 Py_INCREF(Py_None); resultobj = Py_None;
42981 return resultobj;
42982 fail:
42983 return NULL;
42984 }
42985
42986
42987 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42988 PyObject *resultobj = NULL;
42989 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42990 wxGBPosition *arg2 = 0 ;
42991 bool result;
42992 wxGBPosition temp2 ;
42993 PyObject * obj0 = 0 ;
42994 PyObject * obj1 = 0 ;
42995 char *kwnames[] = {
42996 (char *) "self",(char *) "other", NULL
42997 };
42998
42999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
43000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43001 if (SWIG_arg_fail(1)) SWIG_fail;
43002 {
43003 arg2 = &temp2;
43004 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43005 }
43006 {
43007 PyThreadState* __tstate = wxPyBeginAllowThreads();
43008 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
43009
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 {
43014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43015 }
43016 return resultobj;
43017 fail:
43018 return NULL;
43019 }
43020
43021
43022 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43023 PyObject *resultobj = NULL;
43024 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43025 wxGBPosition *arg2 = 0 ;
43026 bool result;
43027 wxGBPosition temp2 ;
43028 PyObject * obj0 = 0 ;
43029 PyObject * obj1 = 0 ;
43030 char *kwnames[] = {
43031 (char *) "self",(char *) "other", NULL
43032 };
43033
43034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
43035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43036 if (SWIG_arg_fail(1)) SWIG_fail;
43037 {
43038 arg2 = &temp2;
43039 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43040 }
43041 {
43042 PyThreadState* __tstate = wxPyBeginAllowThreads();
43043 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
43044
43045 wxPyEndAllowThreads(__tstate);
43046 if (PyErr_Occurred()) SWIG_fail;
43047 }
43048 {
43049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43050 }
43051 return resultobj;
43052 fail:
43053 return NULL;
43054 }
43055
43056
43057 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43058 PyObject *resultobj = NULL;
43059 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43060 int arg2 = (int) 0 ;
43061 int arg3 = (int) 0 ;
43062 PyObject * obj0 = 0 ;
43063 PyObject * obj1 = 0 ;
43064 PyObject * obj2 = 0 ;
43065 char *kwnames[] = {
43066 (char *) "self",(char *) "row",(char *) "col", NULL
43067 };
43068
43069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43071 if (SWIG_arg_fail(1)) SWIG_fail;
43072 if (obj1) {
43073 {
43074 arg2 = static_cast<int >(SWIG_As_int(obj1));
43075 if (SWIG_arg_fail(2)) SWIG_fail;
43076 }
43077 }
43078 if (obj2) {
43079 {
43080 arg3 = static_cast<int >(SWIG_As_int(obj2));
43081 if (SWIG_arg_fail(3)) SWIG_fail;
43082 }
43083 }
43084 {
43085 PyThreadState* __tstate = wxPyBeginAllowThreads();
43086 wxGBPosition_Set(arg1,arg2,arg3);
43087
43088 wxPyEndAllowThreads(__tstate);
43089 if (PyErr_Occurred()) SWIG_fail;
43090 }
43091 Py_INCREF(Py_None); resultobj = Py_None;
43092 return resultobj;
43093 fail:
43094 return NULL;
43095 }
43096
43097
43098 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43099 PyObject *resultobj = NULL;
43100 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43101 PyObject *result;
43102 PyObject * obj0 = 0 ;
43103 char *kwnames[] = {
43104 (char *) "self", NULL
43105 };
43106
43107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
43108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43109 if (SWIG_arg_fail(1)) SWIG_fail;
43110 {
43111 PyThreadState* __tstate = wxPyBeginAllowThreads();
43112 result = (PyObject *)wxGBPosition_Get(arg1);
43113
43114 wxPyEndAllowThreads(__tstate);
43115 if (PyErr_Occurred()) SWIG_fail;
43116 }
43117 resultobj = result;
43118 return resultobj;
43119 fail:
43120 return NULL;
43121 }
43122
43123
43124 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
43125 PyObject *obj;
43126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43127 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
43128 Py_INCREF(obj);
43129 return Py_BuildValue((char *)"");
43130 }
43131 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43132 PyObject *resultobj = NULL;
43133 int arg1 = (int) 1 ;
43134 int arg2 = (int) 1 ;
43135 wxGBSpan *result;
43136 PyObject * obj0 = 0 ;
43137 PyObject * obj1 = 0 ;
43138 char *kwnames[] = {
43139 (char *) "rowspan",(char *) "colspan", NULL
43140 };
43141
43142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
43143 if (obj0) {
43144 {
43145 arg1 = static_cast<int >(SWIG_As_int(obj0));
43146 if (SWIG_arg_fail(1)) SWIG_fail;
43147 }
43148 }
43149 if (obj1) {
43150 {
43151 arg2 = static_cast<int >(SWIG_As_int(obj1));
43152 if (SWIG_arg_fail(2)) SWIG_fail;
43153 }
43154 }
43155 {
43156 PyThreadState* __tstate = wxPyBeginAllowThreads();
43157 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
43158
43159 wxPyEndAllowThreads(__tstate);
43160 if (PyErr_Occurred()) SWIG_fail;
43161 }
43162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
43163 return resultobj;
43164 fail:
43165 return NULL;
43166 }
43167
43168
43169 static PyObject *_wrap_delete_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43170 PyObject *resultobj = NULL;
43171 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43172 PyObject * obj0 = 0 ;
43173 char *kwnames[] = {
43174 (char *) "self", NULL
43175 };
43176
43177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSpan",kwnames,&obj0)) goto fail;
43178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43179 if (SWIG_arg_fail(1)) SWIG_fail;
43180 {
43181 PyThreadState* __tstate = wxPyBeginAllowThreads();
43182 delete arg1;
43183
43184 wxPyEndAllowThreads(__tstate);
43185 if (PyErr_Occurred()) SWIG_fail;
43186 }
43187 Py_INCREF(Py_None); resultobj = Py_None;
43188 return resultobj;
43189 fail:
43190 return NULL;
43191 }
43192
43193
43194 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43195 PyObject *resultobj = NULL;
43196 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43197 int result;
43198 PyObject * obj0 = 0 ;
43199 char *kwnames[] = {
43200 (char *) "self", NULL
43201 };
43202
43203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
43204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43205 if (SWIG_arg_fail(1)) SWIG_fail;
43206 {
43207 PyThreadState* __tstate = wxPyBeginAllowThreads();
43208 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
43209
43210 wxPyEndAllowThreads(__tstate);
43211 if (PyErr_Occurred()) SWIG_fail;
43212 }
43213 {
43214 resultobj = SWIG_From_int(static_cast<int >(result));
43215 }
43216 return resultobj;
43217 fail:
43218 return NULL;
43219 }
43220
43221
43222 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43223 PyObject *resultobj = NULL;
43224 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43225 int result;
43226 PyObject * obj0 = 0 ;
43227 char *kwnames[] = {
43228 (char *) "self", NULL
43229 };
43230
43231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43233 if (SWIG_arg_fail(1)) SWIG_fail;
43234 {
43235 PyThreadState* __tstate = wxPyBeginAllowThreads();
43236 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43237
43238 wxPyEndAllowThreads(__tstate);
43239 if (PyErr_Occurred()) SWIG_fail;
43240 }
43241 {
43242 resultobj = SWIG_From_int(static_cast<int >(result));
43243 }
43244 return resultobj;
43245 fail:
43246 return NULL;
43247 }
43248
43249
43250 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43251 PyObject *resultobj = NULL;
43252 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43253 int arg2 ;
43254 PyObject * obj0 = 0 ;
43255 PyObject * obj1 = 0 ;
43256 char *kwnames[] = {
43257 (char *) "self",(char *) "rowspan", NULL
43258 };
43259
43260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43262 if (SWIG_arg_fail(1)) SWIG_fail;
43263 {
43264 arg2 = static_cast<int >(SWIG_As_int(obj1));
43265 if (SWIG_arg_fail(2)) SWIG_fail;
43266 }
43267 {
43268 PyThreadState* __tstate = wxPyBeginAllowThreads();
43269 (arg1)->SetRowspan(arg2);
43270
43271 wxPyEndAllowThreads(__tstate);
43272 if (PyErr_Occurred()) SWIG_fail;
43273 }
43274 Py_INCREF(Py_None); resultobj = Py_None;
43275 return resultobj;
43276 fail:
43277 return NULL;
43278 }
43279
43280
43281 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43282 PyObject *resultobj = NULL;
43283 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43284 int arg2 ;
43285 PyObject * obj0 = 0 ;
43286 PyObject * obj1 = 0 ;
43287 char *kwnames[] = {
43288 (char *) "self",(char *) "colspan", NULL
43289 };
43290
43291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43293 if (SWIG_arg_fail(1)) SWIG_fail;
43294 {
43295 arg2 = static_cast<int >(SWIG_As_int(obj1));
43296 if (SWIG_arg_fail(2)) SWIG_fail;
43297 }
43298 {
43299 PyThreadState* __tstate = wxPyBeginAllowThreads();
43300 (arg1)->SetColspan(arg2);
43301
43302 wxPyEndAllowThreads(__tstate);
43303 if (PyErr_Occurred()) SWIG_fail;
43304 }
43305 Py_INCREF(Py_None); resultobj = Py_None;
43306 return resultobj;
43307 fail:
43308 return NULL;
43309 }
43310
43311
43312 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43313 PyObject *resultobj = NULL;
43314 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43315 wxGBSpan *arg2 = 0 ;
43316 bool result;
43317 wxGBSpan temp2 ;
43318 PyObject * obj0 = 0 ;
43319 PyObject * obj1 = 0 ;
43320 char *kwnames[] = {
43321 (char *) "self",(char *) "other", NULL
43322 };
43323
43324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43326 if (SWIG_arg_fail(1)) SWIG_fail;
43327 {
43328 arg2 = &temp2;
43329 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43330 }
43331 {
43332 PyThreadState* __tstate = wxPyBeginAllowThreads();
43333 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43334
43335 wxPyEndAllowThreads(__tstate);
43336 if (PyErr_Occurred()) SWIG_fail;
43337 }
43338 {
43339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43340 }
43341 return resultobj;
43342 fail:
43343 return NULL;
43344 }
43345
43346
43347 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43348 PyObject *resultobj = NULL;
43349 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43350 wxGBSpan *arg2 = 0 ;
43351 bool result;
43352 wxGBSpan temp2 ;
43353 PyObject * obj0 = 0 ;
43354 PyObject * obj1 = 0 ;
43355 char *kwnames[] = {
43356 (char *) "self",(char *) "other", NULL
43357 };
43358
43359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43361 if (SWIG_arg_fail(1)) SWIG_fail;
43362 {
43363 arg2 = &temp2;
43364 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43365 }
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43369
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 {
43374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43375 }
43376 return resultobj;
43377 fail:
43378 return NULL;
43379 }
43380
43381
43382 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43383 PyObject *resultobj = NULL;
43384 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43385 int arg2 = (int) 1 ;
43386 int arg3 = (int) 1 ;
43387 PyObject * obj0 = 0 ;
43388 PyObject * obj1 = 0 ;
43389 PyObject * obj2 = 0 ;
43390 char *kwnames[] = {
43391 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43392 };
43393
43394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43396 if (SWIG_arg_fail(1)) SWIG_fail;
43397 if (obj1) {
43398 {
43399 arg2 = static_cast<int >(SWIG_As_int(obj1));
43400 if (SWIG_arg_fail(2)) SWIG_fail;
43401 }
43402 }
43403 if (obj2) {
43404 {
43405 arg3 = static_cast<int >(SWIG_As_int(obj2));
43406 if (SWIG_arg_fail(3)) SWIG_fail;
43407 }
43408 }
43409 {
43410 PyThreadState* __tstate = wxPyBeginAllowThreads();
43411 wxGBSpan_Set(arg1,arg2,arg3);
43412
43413 wxPyEndAllowThreads(__tstate);
43414 if (PyErr_Occurred()) SWIG_fail;
43415 }
43416 Py_INCREF(Py_None); resultobj = Py_None;
43417 return resultobj;
43418 fail:
43419 return NULL;
43420 }
43421
43422
43423 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43424 PyObject *resultobj = NULL;
43425 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43426 PyObject *result;
43427 PyObject * obj0 = 0 ;
43428 char *kwnames[] = {
43429 (char *) "self", NULL
43430 };
43431
43432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43434 if (SWIG_arg_fail(1)) SWIG_fail;
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 result = (PyObject *)wxGBSpan_Get(arg1);
43438
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 resultobj = result;
43443 return resultobj;
43444 fail:
43445 return NULL;
43446 }
43447
43448
43449 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43450 PyObject *obj;
43451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43452 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43453 Py_INCREF(obj);
43454 return Py_BuildValue((char *)"");
43455 }
43456 static int _wrap_DefaultSpan_set(PyObject *) {
43457 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43458 return 1;
43459 }
43460
43461
43462 static PyObject *_wrap_DefaultSpan_get(void) {
43463 PyObject *pyobj = NULL;
43464
43465 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43466 return pyobj;
43467 }
43468
43469
43470 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43471 PyObject *resultobj = NULL;
43472 wxGBSizerItem *result;
43473 char *kwnames[] = {
43474 NULL
43475 };
43476
43477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43478 {
43479 PyThreadState* __tstate = wxPyBeginAllowThreads();
43480 result = (wxGBSizerItem *)new wxGBSizerItem();
43481
43482 wxPyEndAllowThreads(__tstate);
43483 if (PyErr_Occurred()) SWIG_fail;
43484 }
43485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43486 return resultobj;
43487 fail:
43488 return NULL;
43489 }
43490
43491
43492 static PyObject *_wrap_delete_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43493 PyObject *resultobj = NULL;
43494 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43495 PyObject * obj0 = 0 ;
43496 char *kwnames[] = {
43497 (char *) "self", NULL
43498 };
43499
43500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSizerItem",kwnames,&obj0)) goto fail;
43501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43502 if (SWIG_arg_fail(1)) SWIG_fail;
43503 {
43504 PyThreadState* __tstate = wxPyBeginAllowThreads();
43505 delete arg1;
43506
43507 wxPyEndAllowThreads(__tstate);
43508 if (PyErr_Occurred()) SWIG_fail;
43509 }
43510 Py_INCREF(Py_None); resultobj = Py_None;
43511 return resultobj;
43512 fail:
43513 return NULL;
43514 }
43515
43516
43517 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43518 PyObject *resultobj = NULL;
43519 wxWindow *arg1 = (wxWindow *) 0 ;
43520 wxGBPosition *arg2 = 0 ;
43521 wxGBSpan *arg3 = 0 ;
43522 int arg4 ;
43523 int arg5 ;
43524 PyObject *arg6 = (PyObject *) NULL ;
43525 wxGBSizerItem *result;
43526 wxGBPosition temp2 ;
43527 wxGBSpan temp3 ;
43528 PyObject * obj0 = 0 ;
43529 PyObject * obj1 = 0 ;
43530 PyObject * obj2 = 0 ;
43531 PyObject * obj3 = 0 ;
43532 PyObject * obj4 = 0 ;
43533 PyObject * obj5 = 0 ;
43534 char *kwnames[] = {
43535 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43536 };
43537
43538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43540 if (SWIG_arg_fail(1)) SWIG_fail;
43541 {
43542 arg2 = &temp2;
43543 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43544 }
43545 {
43546 arg3 = &temp3;
43547 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43548 }
43549 {
43550 arg4 = static_cast<int >(SWIG_As_int(obj3));
43551 if (SWIG_arg_fail(4)) SWIG_fail;
43552 }
43553 {
43554 arg5 = static_cast<int >(SWIG_As_int(obj4));
43555 if (SWIG_arg_fail(5)) SWIG_fail;
43556 }
43557 if (obj5) {
43558 arg6 = obj5;
43559 }
43560 {
43561 PyThreadState* __tstate = wxPyBeginAllowThreads();
43562 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43563
43564 wxPyEndAllowThreads(__tstate);
43565 if (PyErr_Occurred()) SWIG_fail;
43566 }
43567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43568 return resultobj;
43569 fail:
43570 return NULL;
43571 }
43572
43573
43574 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43575 PyObject *resultobj = NULL;
43576 wxSizer *arg1 = (wxSizer *) 0 ;
43577 wxGBPosition *arg2 = 0 ;
43578 wxGBSpan *arg3 = 0 ;
43579 int arg4 ;
43580 int arg5 ;
43581 PyObject *arg6 = (PyObject *) NULL ;
43582 wxGBSizerItem *result;
43583 wxGBPosition temp2 ;
43584 wxGBSpan temp3 ;
43585 PyObject * obj0 = 0 ;
43586 PyObject * obj1 = 0 ;
43587 PyObject * obj2 = 0 ;
43588 PyObject * obj3 = 0 ;
43589 PyObject * obj4 = 0 ;
43590 PyObject * obj5 = 0 ;
43591 char *kwnames[] = {
43592 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43593 };
43594
43595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43597 if (SWIG_arg_fail(1)) SWIG_fail;
43598 {
43599 arg2 = &temp2;
43600 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43601 }
43602 {
43603 arg3 = &temp3;
43604 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43605 }
43606 {
43607 arg4 = static_cast<int >(SWIG_As_int(obj3));
43608 if (SWIG_arg_fail(4)) SWIG_fail;
43609 }
43610 {
43611 arg5 = static_cast<int >(SWIG_As_int(obj4));
43612 if (SWIG_arg_fail(5)) SWIG_fail;
43613 }
43614 if (obj5) {
43615 arg6 = obj5;
43616 }
43617 {
43618 PyThreadState* __tstate = wxPyBeginAllowThreads();
43619 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43620
43621 wxPyEndAllowThreads(__tstate);
43622 if (PyErr_Occurred()) SWIG_fail;
43623 }
43624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43625 return resultobj;
43626 fail:
43627 return NULL;
43628 }
43629
43630
43631 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43632 PyObject *resultobj = NULL;
43633 int arg1 ;
43634 int arg2 ;
43635 wxGBPosition *arg3 = 0 ;
43636 wxGBSpan *arg4 = 0 ;
43637 int arg5 ;
43638 int arg6 ;
43639 PyObject *arg7 = (PyObject *) NULL ;
43640 wxGBSizerItem *result;
43641 wxGBPosition temp3 ;
43642 wxGBSpan temp4 ;
43643 PyObject * obj0 = 0 ;
43644 PyObject * obj1 = 0 ;
43645 PyObject * obj2 = 0 ;
43646 PyObject * obj3 = 0 ;
43647 PyObject * obj4 = 0 ;
43648 PyObject * obj5 = 0 ;
43649 PyObject * obj6 = 0 ;
43650 char *kwnames[] = {
43651 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43652 };
43653
43654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43655 {
43656 arg1 = static_cast<int >(SWIG_As_int(obj0));
43657 if (SWIG_arg_fail(1)) SWIG_fail;
43658 }
43659 {
43660 arg2 = static_cast<int >(SWIG_As_int(obj1));
43661 if (SWIG_arg_fail(2)) SWIG_fail;
43662 }
43663 {
43664 arg3 = &temp3;
43665 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43666 }
43667 {
43668 arg4 = &temp4;
43669 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43670 }
43671 {
43672 arg5 = static_cast<int >(SWIG_As_int(obj4));
43673 if (SWIG_arg_fail(5)) SWIG_fail;
43674 }
43675 {
43676 arg6 = static_cast<int >(SWIG_As_int(obj5));
43677 if (SWIG_arg_fail(6)) SWIG_fail;
43678 }
43679 if (obj6) {
43680 arg7 = obj6;
43681 }
43682 {
43683 PyThreadState* __tstate = wxPyBeginAllowThreads();
43684 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43685
43686 wxPyEndAllowThreads(__tstate);
43687 if (PyErr_Occurred()) SWIG_fail;
43688 }
43689 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43690 return resultobj;
43691 fail:
43692 return NULL;
43693 }
43694
43695
43696 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43697 PyObject *resultobj = NULL;
43698 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43699 wxGBPosition result;
43700 PyObject * obj0 = 0 ;
43701 char *kwnames[] = {
43702 (char *) "self", NULL
43703 };
43704
43705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43707 if (SWIG_arg_fail(1)) SWIG_fail;
43708 {
43709 PyThreadState* __tstate = wxPyBeginAllowThreads();
43710 result = ((wxGBSizerItem const *)arg1)->GetPos();
43711
43712 wxPyEndAllowThreads(__tstate);
43713 if (PyErr_Occurred()) SWIG_fail;
43714 }
43715 {
43716 wxGBPosition * resultptr;
43717 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43718 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43719 }
43720 return resultobj;
43721 fail:
43722 return NULL;
43723 }
43724
43725
43726 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43727 PyObject *resultobj = NULL;
43728 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43729 wxGBSpan result;
43730 PyObject * obj0 = 0 ;
43731 char *kwnames[] = {
43732 (char *) "self", NULL
43733 };
43734
43735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43737 if (SWIG_arg_fail(1)) SWIG_fail;
43738 {
43739 PyThreadState* __tstate = wxPyBeginAllowThreads();
43740 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43741
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 {
43746 wxGBSpan * resultptr;
43747 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43748 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43749 }
43750 return resultobj;
43751 fail:
43752 return NULL;
43753 }
43754
43755
43756 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43757 PyObject *resultobj = NULL;
43758 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43759 wxGBPosition *arg2 = 0 ;
43760 bool result;
43761 wxGBPosition temp2 ;
43762 PyObject * obj0 = 0 ;
43763 PyObject * obj1 = 0 ;
43764 char *kwnames[] = {
43765 (char *) "self",(char *) "pos", NULL
43766 };
43767
43768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43770 if (SWIG_arg_fail(1)) SWIG_fail;
43771 {
43772 arg2 = &temp2;
43773 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43774 }
43775 {
43776 PyThreadState* __tstate = wxPyBeginAllowThreads();
43777 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43778
43779 wxPyEndAllowThreads(__tstate);
43780 if (PyErr_Occurred()) SWIG_fail;
43781 }
43782 {
43783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43784 }
43785 return resultobj;
43786 fail:
43787 return NULL;
43788 }
43789
43790
43791 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43792 PyObject *resultobj = NULL;
43793 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43794 wxGBSpan *arg2 = 0 ;
43795 bool result;
43796 wxGBSpan temp2 ;
43797 PyObject * obj0 = 0 ;
43798 PyObject * obj1 = 0 ;
43799 char *kwnames[] = {
43800 (char *) "self",(char *) "span", NULL
43801 };
43802
43803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43805 if (SWIG_arg_fail(1)) SWIG_fail;
43806 {
43807 arg2 = &temp2;
43808 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43809 }
43810 {
43811 PyThreadState* __tstate = wxPyBeginAllowThreads();
43812 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43813
43814 wxPyEndAllowThreads(__tstate);
43815 if (PyErr_Occurred()) SWIG_fail;
43816 }
43817 {
43818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43819 }
43820 return resultobj;
43821 fail:
43822 return NULL;
43823 }
43824
43825
43826 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43827 PyObject *resultobj = NULL;
43828 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43829 wxGBSizerItem *arg2 = 0 ;
43830 bool result;
43831 PyObject * obj0 = 0 ;
43832 PyObject * obj1 = 0 ;
43833 char *kwnames[] = {
43834 (char *) "self",(char *) "other", NULL
43835 };
43836
43837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43839 if (SWIG_arg_fail(1)) SWIG_fail;
43840 {
43841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43842 if (SWIG_arg_fail(2)) SWIG_fail;
43843 if (arg2 == NULL) {
43844 SWIG_null_ref("wxGBSizerItem");
43845 }
43846 if (SWIG_arg_fail(2)) SWIG_fail;
43847 }
43848 {
43849 PyThreadState* __tstate = wxPyBeginAllowThreads();
43850 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43851
43852 wxPyEndAllowThreads(__tstate);
43853 if (PyErr_Occurred()) SWIG_fail;
43854 }
43855 {
43856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43857 }
43858 return resultobj;
43859 fail:
43860 return NULL;
43861 }
43862
43863
43864 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43865 PyObject *resultobj = NULL;
43866 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43867 wxGBPosition *arg2 = 0 ;
43868 wxGBSpan *arg3 = 0 ;
43869 bool result;
43870 wxGBPosition temp2 ;
43871 wxGBSpan temp3 ;
43872 PyObject * obj0 = 0 ;
43873 PyObject * obj1 = 0 ;
43874 PyObject * obj2 = 0 ;
43875 char *kwnames[] = {
43876 (char *) "self",(char *) "pos",(char *) "span", NULL
43877 };
43878
43879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43881 if (SWIG_arg_fail(1)) SWIG_fail;
43882 {
43883 arg2 = &temp2;
43884 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43885 }
43886 {
43887 arg3 = &temp3;
43888 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43889 }
43890 {
43891 PyThreadState* __tstate = wxPyBeginAllowThreads();
43892 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43893
43894 wxPyEndAllowThreads(__tstate);
43895 if (PyErr_Occurred()) SWIG_fail;
43896 }
43897 {
43898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43899 }
43900 return resultobj;
43901 fail:
43902 return NULL;
43903 }
43904
43905
43906 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43907 PyObject *resultobj = NULL;
43908 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43909 wxGBPosition result;
43910 PyObject * obj0 = 0 ;
43911 char *kwnames[] = {
43912 (char *) "self", NULL
43913 };
43914
43915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43917 if (SWIG_arg_fail(1)) SWIG_fail;
43918 {
43919 PyThreadState* __tstate = wxPyBeginAllowThreads();
43920 result = wxGBSizerItem_GetEndPos(arg1);
43921
43922 wxPyEndAllowThreads(__tstate);
43923 if (PyErr_Occurred()) SWIG_fail;
43924 }
43925 {
43926 wxGBPosition * resultptr;
43927 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43929 }
43930 return resultobj;
43931 fail:
43932 return NULL;
43933 }
43934
43935
43936 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43937 PyObject *resultobj = NULL;
43938 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43939 wxGridBagSizer *result;
43940 PyObject * obj0 = 0 ;
43941 char *kwnames[] = {
43942 (char *) "self", NULL
43943 };
43944
43945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43947 if (SWIG_arg_fail(1)) SWIG_fail;
43948 {
43949 PyThreadState* __tstate = wxPyBeginAllowThreads();
43950 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43951
43952 wxPyEndAllowThreads(__tstate);
43953 if (PyErr_Occurred()) SWIG_fail;
43954 }
43955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43956 return resultobj;
43957 fail:
43958 return NULL;
43959 }
43960
43961
43962 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43963 PyObject *resultobj = NULL;
43964 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43965 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43966 PyObject * obj0 = 0 ;
43967 PyObject * obj1 = 0 ;
43968 char *kwnames[] = {
43969 (char *) "self",(char *) "sizer", NULL
43970 };
43971
43972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43974 if (SWIG_arg_fail(1)) SWIG_fail;
43975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43976 if (SWIG_arg_fail(2)) SWIG_fail;
43977 {
43978 PyThreadState* __tstate = wxPyBeginAllowThreads();
43979 (arg1)->SetGBSizer(arg2);
43980
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 Py_INCREF(Py_None); resultobj = Py_None;
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43992 PyObject *obj;
43993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43994 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43995 Py_INCREF(obj);
43996 return Py_BuildValue((char *)"");
43997 }
43998 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43999 PyObject *resultobj = NULL;
44000 int arg1 = (int) 0 ;
44001 int arg2 = (int) 0 ;
44002 wxGridBagSizer *result;
44003 PyObject * obj0 = 0 ;
44004 PyObject * obj1 = 0 ;
44005 char *kwnames[] = {
44006 (char *) "vgap",(char *) "hgap", NULL
44007 };
44008
44009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
44010 if (obj0) {
44011 {
44012 arg1 = static_cast<int >(SWIG_As_int(obj0));
44013 if (SWIG_arg_fail(1)) SWIG_fail;
44014 }
44015 }
44016 if (obj1) {
44017 {
44018 arg2 = static_cast<int >(SWIG_As_int(obj1));
44019 if (SWIG_arg_fail(2)) SWIG_fail;
44020 }
44021 }
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
44025
44026 wxPyEndAllowThreads(__tstate);
44027 if (PyErr_Occurred()) SWIG_fail;
44028 }
44029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
44030 return resultobj;
44031 fail:
44032 return NULL;
44033 }
44034
44035
44036 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
44037 PyObject *resultobj = NULL;
44038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44039 PyObject *arg2 = (PyObject *) 0 ;
44040 wxGBPosition *arg3 = 0 ;
44041 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
44042 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
44043 int arg5 = (int) 0 ;
44044 int arg6 = (int) 0 ;
44045 PyObject *arg7 = (PyObject *) NULL ;
44046 wxGBSizerItem *result;
44047 wxGBPosition temp3 ;
44048 wxGBSpan temp4 ;
44049 PyObject * obj0 = 0 ;
44050 PyObject * obj1 = 0 ;
44051 PyObject * obj2 = 0 ;
44052 PyObject * obj3 = 0 ;
44053 PyObject * obj4 = 0 ;
44054 PyObject * obj5 = 0 ;
44055 PyObject * obj6 = 0 ;
44056 char *kwnames[] = {
44057 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
44058 };
44059
44060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
44061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44062 if (SWIG_arg_fail(1)) SWIG_fail;
44063 arg2 = obj1;
44064 {
44065 arg3 = &temp3;
44066 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44067 }
44068 if (obj3) {
44069 {
44070 arg4 = &temp4;
44071 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
44072 }
44073 }
44074 if (obj4) {
44075 {
44076 arg5 = static_cast<int >(SWIG_As_int(obj4));
44077 if (SWIG_arg_fail(5)) SWIG_fail;
44078 }
44079 }
44080 if (obj5) {
44081 {
44082 arg6 = static_cast<int >(SWIG_As_int(obj5));
44083 if (SWIG_arg_fail(6)) SWIG_fail;
44084 }
44085 }
44086 if (obj6) {
44087 arg7 = obj6;
44088 }
44089 {
44090 PyThreadState* __tstate = wxPyBeginAllowThreads();
44091 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
44092
44093 wxPyEndAllowThreads(__tstate);
44094 if (PyErr_Occurred()) SWIG_fail;
44095 }
44096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44097 return resultobj;
44098 fail:
44099 return NULL;
44100 }
44101
44102
44103 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
44104 PyObject *resultobj = NULL;
44105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44106 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44107 wxGBSizerItem *result;
44108 PyObject * obj0 = 0 ;
44109 PyObject * obj1 = 0 ;
44110 char *kwnames[] = {
44111 (char *) "self",(char *) "item", NULL
44112 };
44113
44114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
44115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44116 if (SWIG_arg_fail(1)) SWIG_fail;
44117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
44118 if (SWIG_arg_fail(2)) SWIG_fail;
44119 {
44120 PyThreadState* __tstate = wxPyBeginAllowThreads();
44121 result = (wxGBSizerItem *)(arg1)->Add(arg2);
44122
44123 wxPyEndAllowThreads(__tstate);
44124 if (PyErr_Occurred()) SWIG_fail;
44125 }
44126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44134 PyObject *resultobj = NULL;
44135 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44136 int arg2 ;
44137 int arg3 ;
44138 wxSize result;
44139 PyObject * obj0 = 0 ;
44140 PyObject * obj1 = 0 ;
44141 PyObject * obj2 = 0 ;
44142 char *kwnames[] = {
44143 (char *) "self",(char *) "row",(char *) "col", NULL
44144 };
44145
44146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
44147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44148 if (SWIG_arg_fail(1)) SWIG_fail;
44149 {
44150 arg2 = static_cast<int >(SWIG_As_int(obj1));
44151 if (SWIG_arg_fail(2)) SWIG_fail;
44152 }
44153 {
44154 arg3 = static_cast<int >(SWIG_As_int(obj2));
44155 if (SWIG_arg_fail(3)) SWIG_fail;
44156 }
44157 {
44158 PyThreadState* __tstate = wxPyBeginAllowThreads();
44159 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
44160
44161 wxPyEndAllowThreads(__tstate);
44162 if (PyErr_Occurred()) SWIG_fail;
44163 }
44164 {
44165 wxSize * resultptr;
44166 resultptr = new wxSize(static_cast<wxSize & >(result));
44167 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44168 }
44169 return resultobj;
44170 fail:
44171 return NULL;
44172 }
44173
44174
44175 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44176 PyObject *resultobj = NULL;
44177 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44178 wxSize result;
44179 PyObject * obj0 = 0 ;
44180 char *kwnames[] = {
44181 (char *) "self", NULL
44182 };
44183
44184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
44185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44186 if (SWIG_arg_fail(1)) SWIG_fail;
44187 {
44188 PyThreadState* __tstate = wxPyBeginAllowThreads();
44189 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
44190
44191 wxPyEndAllowThreads(__tstate);
44192 if (PyErr_Occurred()) SWIG_fail;
44193 }
44194 {
44195 wxSize * resultptr;
44196 resultptr = new wxSize(static_cast<wxSize & >(result));
44197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44198 }
44199 return resultobj;
44200 fail:
44201 return NULL;
44202 }
44203
44204
44205 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44206 PyObject *resultobj = NULL;
44207 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44208 wxSize *arg2 = 0 ;
44209 wxSize temp2 ;
44210 PyObject * obj0 = 0 ;
44211 PyObject * obj1 = 0 ;
44212 char *kwnames[] = {
44213 (char *) "self",(char *) "sz", NULL
44214 };
44215
44216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
44217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44218 if (SWIG_arg_fail(1)) SWIG_fail;
44219 {
44220 arg2 = &temp2;
44221 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44222 }
44223 {
44224 PyThreadState* __tstate = wxPyBeginAllowThreads();
44225 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
44226
44227 wxPyEndAllowThreads(__tstate);
44228 if (PyErr_Occurred()) SWIG_fail;
44229 }
44230 Py_INCREF(Py_None); resultobj = Py_None;
44231 return resultobj;
44232 fail:
44233 return NULL;
44234 }
44235
44236
44237 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44238 PyObject *resultobj = NULL;
44239 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44240 wxWindow *arg2 = (wxWindow *) 0 ;
44241 wxGBPosition result;
44242 PyObject * obj0 = 0 ;
44243 PyObject * obj1 = 0 ;
44244
44245 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44247 if (SWIG_arg_fail(1)) SWIG_fail;
44248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44249 if (SWIG_arg_fail(2)) SWIG_fail;
44250 {
44251 PyThreadState* __tstate = wxPyBeginAllowThreads();
44252 result = (arg1)->GetItemPosition(arg2);
44253
44254 wxPyEndAllowThreads(__tstate);
44255 if (PyErr_Occurred()) SWIG_fail;
44256 }
44257 {
44258 wxGBPosition * resultptr;
44259 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44261 }
44262 return resultobj;
44263 fail:
44264 return NULL;
44265 }
44266
44267
44268 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44269 PyObject *resultobj = NULL;
44270 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44271 wxSizer *arg2 = (wxSizer *) 0 ;
44272 wxGBPosition result;
44273 PyObject * obj0 = 0 ;
44274 PyObject * obj1 = 0 ;
44275
44276 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44278 if (SWIG_arg_fail(1)) SWIG_fail;
44279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44280 if (SWIG_arg_fail(2)) SWIG_fail;
44281 {
44282 PyThreadState* __tstate = wxPyBeginAllowThreads();
44283 result = (arg1)->GetItemPosition(arg2);
44284
44285 wxPyEndAllowThreads(__tstate);
44286 if (PyErr_Occurred()) SWIG_fail;
44287 }
44288 {
44289 wxGBPosition * resultptr;
44290 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44292 }
44293 return resultobj;
44294 fail:
44295 return NULL;
44296 }
44297
44298
44299 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44300 PyObject *resultobj = NULL;
44301 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44302 size_t arg2 ;
44303 wxGBPosition result;
44304 PyObject * obj0 = 0 ;
44305 PyObject * obj1 = 0 ;
44306
44307 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44309 if (SWIG_arg_fail(1)) SWIG_fail;
44310 {
44311 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44312 if (SWIG_arg_fail(2)) SWIG_fail;
44313 }
44314 {
44315 PyThreadState* __tstate = wxPyBeginAllowThreads();
44316 result = (arg1)->GetItemPosition(arg2);
44317
44318 wxPyEndAllowThreads(__tstate);
44319 if (PyErr_Occurred()) SWIG_fail;
44320 }
44321 {
44322 wxGBPosition * resultptr;
44323 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44325 }
44326 return resultobj;
44327 fail:
44328 return NULL;
44329 }
44330
44331
44332 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44333 int argc;
44334 PyObject *argv[3];
44335 int ii;
44336
44337 argc = PyObject_Length(args);
44338 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44339 argv[ii] = PyTuple_GetItem(args,ii);
44340 }
44341 if (argc == 2) {
44342 int _v;
44343 {
44344 void *ptr;
44345 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44346 _v = 0;
44347 PyErr_Clear();
44348 } else {
44349 _v = 1;
44350 }
44351 }
44352 if (_v) {
44353 {
44354 void *ptr;
44355 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44356 _v = 0;
44357 PyErr_Clear();
44358 } else {
44359 _v = 1;
44360 }
44361 }
44362 if (_v) {
44363 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44364 }
44365 }
44366 }
44367 if (argc == 2) {
44368 int _v;
44369 {
44370 void *ptr;
44371 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44372 _v = 0;
44373 PyErr_Clear();
44374 } else {
44375 _v = 1;
44376 }
44377 }
44378 if (_v) {
44379 {
44380 void *ptr;
44381 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44382 _v = 0;
44383 PyErr_Clear();
44384 } else {
44385 _v = 1;
44386 }
44387 }
44388 if (_v) {
44389 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44390 }
44391 }
44392 }
44393 if (argc == 2) {
44394 int _v;
44395 {
44396 void *ptr;
44397 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44398 _v = 0;
44399 PyErr_Clear();
44400 } else {
44401 _v = 1;
44402 }
44403 }
44404 if (_v) {
44405 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44406 if (_v) {
44407 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44408 }
44409 }
44410 }
44411
44412 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44413 return NULL;
44414 }
44415
44416
44417 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44418 PyObject *resultobj = NULL;
44419 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44420 wxWindow *arg2 = (wxWindow *) 0 ;
44421 wxGBPosition *arg3 = 0 ;
44422 bool result;
44423 wxGBPosition temp3 ;
44424 PyObject * obj0 = 0 ;
44425 PyObject * obj1 = 0 ;
44426 PyObject * obj2 = 0 ;
44427
44428 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44430 if (SWIG_arg_fail(1)) SWIG_fail;
44431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44432 if (SWIG_arg_fail(2)) SWIG_fail;
44433 {
44434 arg3 = &temp3;
44435 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44436 }
44437 {
44438 PyThreadState* __tstate = wxPyBeginAllowThreads();
44439 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44440
44441 wxPyEndAllowThreads(__tstate);
44442 if (PyErr_Occurred()) SWIG_fail;
44443 }
44444 {
44445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44446 }
44447 return resultobj;
44448 fail:
44449 return NULL;
44450 }
44451
44452
44453 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44454 PyObject *resultobj = NULL;
44455 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44456 wxSizer *arg2 = (wxSizer *) 0 ;
44457 wxGBPosition *arg3 = 0 ;
44458 bool result;
44459 wxGBPosition temp3 ;
44460 PyObject * obj0 = 0 ;
44461 PyObject * obj1 = 0 ;
44462 PyObject * obj2 = 0 ;
44463
44464 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44466 if (SWIG_arg_fail(1)) SWIG_fail;
44467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44468 if (SWIG_arg_fail(2)) SWIG_fail;
44469 {
44470 arg3 = &temp3;
44471 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44472 }
44473 {
44474 PyThreadState* __tstate = wxPyBeginAllowThreads();
44475 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44476
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 {
44481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44482 }
44483 return resultobj;
44484 fail:
44485 return NULL;
44486 }
44487
44488
44489 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44490 PyObject *resultobj = NULL;
44491 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44492 size_t arg2 ;
44493 wxGBPosition *arg3 = 0 ;
44494 bool result;
44495 wxGBPosition temp3 ;
44496 PyObject * obj0 = 0 ;
44497 PyObject * obj1 = 0 ;
44498 PyObject * obj2 = 0 ;
44499
44500 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44502 if (SWIG_arg_fail(1)) SWIG_fail;
44503 {
44504 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44505 if (SWIG_arg_fail(2)) SWIG_fail;
44506 }
44507 {
44508 arg3 = &temp3;
44509 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44510 }
44511 {
44512 PyThreadState* __tstate = wxPyBeginAllowThreads();
44513 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44514
44515 wxPyEndAllowThreads(__tstate);
44516 if (PyErr_Occurred()) SWIG_fail;
44517 }
44518 {
44519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44520 }
44521 return resultobj;
44522 fail:
44523 return NULL;
44524 }
44525
44526
44527 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44528 int argc;
44529 PyObject *argv[4];
44530 int ii;
44531
44532 argc = PyObject_Length(args);
44533 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44534 argv[ii] = PyTuple_GetItem(args,ii);
44535 }
44536 if (argc == 3) {
44537 int _v;
44538 {
44539 void *ptr;
44540 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44541 _v = 0;
44542 PyErr_Clear();
44543 } else {
44544 _v = 1;
44545 }
44546 }
44547 if (_v) {
44548 {
44549 void *ptr;
44550 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44551 _v = 0;
44552 PyErr_Clear();
44553 } else {
44554 _v = 1;
44555 }
44556 }
44557 if (_v) {
44558 {
44559 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44560 }
44561 if (_v) {
44562 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44563 }
44564 }
44565 }
44566 }
44567 if (argc == 3) {
44568 int _v;
44569 {
44570 void *ptr;
44571 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44572 _v = 0;
44573 PyErr_Clear();
44574 } else {
44575 _v = 1;
44576 }
44577 }
44578 if (_v) {
44579 {
44580 void *ptr;
44581 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44582 _v = 0;
44583 PyErr_Clear();
44584 } else {
44585 _v = 1;
44586 }
44587 }
44588 if (_v) {
44589 {
44590 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44591 }
44592 if (_v) {
44593 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44594 }
44595 }
44596 }
44597 }
44598 if (argc == 3) {
44599 int _v;
44600 {
44601 void *ptr;
44602 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44603 _v = 0;
44604 PyErr_Clear();
44605 } else {
44606 _v = 1;
44607 }
44608 }
44609 if (_v) {
44610 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44611 if (_v) {
44612 {
44613 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44614 }
44615 if (_v) {
44616 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44617 }
44618 }
44619 }
44620 }
44621
44622 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44623 return NULL;
44624 }
44625
44626
44627 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44628 PyObject *resultobj = NULL;
44629 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44630 wxWindow *arg2 = (wxWindow *) 0 ;
44631 wxGBSpan result;
44632 PyObject * obj0 = 0 ;
44633 PyObject * obj1 = 0 ;
44634
44635 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44637 if (SWIG_arg_fail(1)) SWIG_fail;
44638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44639 if (SWIG_arg_fail(2)) SWIG_fail;
44640 {
44641 PyThreadState* __tstate = wxPyBeginAllowThreads();
44642 result = (arg1)->GetItemSpan(arg2);
44643
44644 wxPyEndAllowThreads(__tstate);
44645 if (PyErr_Occurred()) SWIG_fail;
44646 }
44647 {
44648 wxGBSpan * resultptr;
44649 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44651 }
44652 return resultobj;
44653 fail:
44654 return NULL;
44655 }
44656
44657
44658 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44659 PyObject *resultobj = NULL;
44660 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44661 wxSizer *arg2 = (wxSizer *) 0 ;
44662 wxGBSpan result;
44663 PyObject * obj0 = 0 ;
44664 PyObject * obj1 = 0 ;
44665
44666 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44668 if (SWIG_arg_fail(1)) SWIG_fail;
44669 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44670 if (SWIG_arg_fail(2)) SWIG_fail;
44671 {
44672 PyThreadState* __tstate = wxPyBeginAllowThreads();
44673 result = (arg1)->GetItemSpan(arg2);
44674
44675 wxPyEndAllowThreads(__tstate);
44676 if (PyErr_Occurred()) SWIG_fail;
44677 }
44678 {
44679 wxGBSpan * resultptr;
44680 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44682 }
44683 return resultobj;
44684 fail:
44685 return NULL;
44686 }
44687
44688
44689 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44690 PyObject *resultobj = NULL;
44691 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44692 size_t arg2 ;
44693 wxGBSpan result;
44694 PyObject * obj0 = 0 ;
44695 PyObject * obj1 = 0 ;
44696
44697 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44699 if (SWIG_arg_fail(1)) SWIG_fail;
44700 {
44701 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44702 if (SWIG_arg_fail(2)) SWIG_fail;
44703 }
44704 {
44705 PyThreadState* __tstate = wxPyBeginAllowThreads();
44706 result = (arg1)->GetItemSpan(arg2);
44707
44708 wxPyEndAllowThreads(__tstate);
44709 if (PyErr_Occurred()) SWIG_fail;
44710 }
44711 {
44712 wxGBSpan * resultptr;
44713 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44714 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44715 }
44716 return resultobj;
44717 fail:
44718 return NULL;
44719 }
44720
44721
44722 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44723 int argc;
44724 PyObject *argv[3];
44725 int ii;
44726
44727 argc = PyObject_Length(args);
44728 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44729 argv[ii] = PyTuple_GetItem(args,ii);
44730 }
44731 if (argc == 2) {
44732 int _v;
44733 {
44734 void *ptr;
44735 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44736 _v = 0;
44737 PyErr_Clear();
44738 } else {
44739 _v = 1;
44740 }
44741 }
44742 if (_v) {
44743 {
44744 void *ptr;
44745 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44746 _v = 0;
44747 PyErr_Clear();
44748 } else {
44749 _v = 1;
44750 }
44751 }
44752 if (_v) {
44753 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44754 }
44755 }
44756 }
44757 if (argc == 2) {
44758 int _v;
44759 {
44760 void *ptr;
44761 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44762 _v = 0;
44763 PyErr_Clear();
44764 } else {
44765 _v = 1;
44766 }
44767 }
44768 if (_v) {
44769 {
44770 void *ptr;
44771 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44772 _v = 0;
44773 PyErr_Clear();
44774 } else {
44775 _v = 1;
44776 }
44777 }
44778 if (_v) {
44779 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44780 }
44781 }
44782 }
44783 if (argc == 2) {
44784 int _v;
44785 {
44786 void *ptr;
44787 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44788 _v = 0;
44789 PyErr_Clear();
44790 } else {
44791 _v = 1;
44792 }
44793 }
44794 if (_v) {
44795 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44796 if (_v) {
44797 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44798 }
44799 }
44800 }
44801
44802 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44803 return NULL;
44804 }
44805
44806
44807 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44808 PyObject *resultobj = NULL;
44809 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44810 wxWindow *arg2 = (wxWindow *) 0 ;
44811 wxGBSpan *arg3 = 0 ;
44812 bool result;
44813 wxGBSpan temp3 ;
44814 PyObject * obj0 = 0 ;
44815 PyObject * obj1 = 0 ;
44816 PyObject * obj2 = 0 ;
44817
44818 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44820 if (SWIG_arg_fail(1)) SWIG_fail;
44821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44822 if (SWIG_arg_fail(2)) SWIG_fail;
44823 {
44824 arg3 = &temp3;
44825 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44826 }
44827 {
44828 PyThreadState* __tstate = wxPyBeginAllowThreads();
44829 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44830
44831 wxPyEndAllowThreads(__tstate);
44832 if (PyErr_Occurred()) SWIG_fail;
44833 }
44834 {
44835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44836 }
44837 return resultobj;
44838 fail:
44839 return NULL;
44840 }
44841
44842
44843 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44844 PyObject *resultobj = NULL;
44845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44846 wxSizer *arg2 = (wxSizer *) 0 ;
44847 wxGBSpan *arg3 = 0 ;
44848 bool result;
44849 wxGBSpan temp3 ;
44850 PyObject * obj0 = 0 ;
44851 PyObject * obj1 = 0 ;
44852 PyObject * obj2 = 0 ;
44853
44854 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44856 if (SWIG_arg_fail(1)) SWIG_fail;
44857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44858 if (SWIG_arg_fail(2)) SWIG_fail;
44859 {
44860 arg3 = &temp3;
44861 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44862 }
44863 {
44864 PyThreadState* __tstate = wxPyBeginAllowThreads();
44865 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44866
44867 wxPyEndAllowThreads(__tstate);
44868 if (PyErr_Occurred()) SWIG_fail;
44869 }
44870 {
44871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44872 }
44873 return resultobj;
44874 fail:
44875 return NULL;
44876 }
44877
44878
44879 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44880 PyObject *resultobj = NULL;
44881 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44882 size_t arg2 ;
44883 wxGBSpan *arg3 = 0 ;
44884 bool result;
44885 wxGBSpan temp3 ;
44886 PyObject * obj0 = 0 ;
44887 PyObject * obj1 = 0 ;
44888 PyObject * obj2 = 0 ;
44889
44890 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44892 if (SWIG_arg_fail(1)) SWIG_fail;
44893 {
44894 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44895 if (SWIG_arg_fail(2)) SWIG_fail;
44896 }
44897 {
44898 arg3 = &temp3;
44899 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44900 }
44901 {
44902 PyThreadState* __tstate = wxPyBeginAllowThreads();
44903 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44904
44905 wxPyEndAllowThreads(__tstate);
44906 if (PyErr_Occurred()) SWIG_fail;
44907 }
44908 {
44909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44910 }
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44918 int argc;
44919 PyObject *argv[4];
44920 int ii;
44921
44922 argc = PyObject_Length(args);
44923 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44924 argv[ii] = PyTuple_GetItem(args,ii);
44925 }
44926 if (argc == 3) {
44927 int _v;
44928 {
44929 void *ptr;
44930 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44931 _v = 0;
44932 PyErr_Clear();
44933 } else {
44934 _v = 1;
44935 }
44936 }
44937 if (_v) {
44938 {
44939 void *ptr;
44940 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44941 _v = 0;
44942 PyErr_Clear();
44943 } else {
44944 _v = 1;
44945 }
44946 }
44947 if (_v) {
44948 {
44949 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44950 }
44951 if (_v) {
44952 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44953 }
44954 }
44955 }
44956 }
44957 if (argc == 3) {
44958 int _v;
44959 {
44960 void *ptr;
44961 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44962 _v = 0;
44963 PyErr_Clear();
44964 } else {
44965 _v = 1;
44966 }
44967 }
44968 if (_v) {
44969 {
44970 void *ptr;
44971 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44972 _v = 0;
44973 PyErr_Clear();
44974 } else {
44975 _v = 1;
44976 }
44977 }
44978 if (_v) {
44979 {
44980 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44981 }
44982 if (_v) {
44983 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44984 }
44985 }
44986 }
44987 }
44988 if (argc == 3) {
44989 int _v;
44990 {
44991 void *ptr;
44992 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44993 _v = 0;
44994 PyErr_Clear();
44995 } else {
44996 _v = 1;
44997 }
44998 }
44999 if (_v) {
45000 _v = SWIG_Check_unsigned_SS_long(argv[1]);
45001 if (_v) {
45002 {
45003 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
45004 }
45005 if (_v) {
45006 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
45007 }
45008 }
45009 }
45010 }
45011
45012 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
45013 return NULL;
45014 }
45015
45016
45017 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
45018 PyObject *resultobj = NULL;
45019 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45020 wxWindow *arg2 = (wxWindow *) 0 ;
45021 wxGBSizerItem *result;
45022 PyObject * obj0 = 0 ;
45023 PyObject * obj1 = 0 ;
45024
45025 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
45026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45027 if (SWIG_arg_fail(1)) SWIG_fail;
45028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45029 if (SWIG_arg_fail(2)) SWIG_fail;
45030 {
45031 PyThreadState* __tstate = wxPyBeginAllowThreads();
45032 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
45033
45034 wxPyEndAllowThreads(__tstate);
45035 if (PyErr_Occurred()) SWIG_fail;
45036 }
45037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45038 return resultobj;
45039 fail:
45040 return NULL;
45041 }
45042
45043
45044 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
45045 PyObject *resultobj = NULL;
45046 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45047 wxSizer *arg2 = (wxSizer *) 0 ;
45048 wxGBSizerItem *result;
45049 PyObject * obj0 = 0 ;
45050 PyObject * obj1 = 0 ;
45051
45052 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
45053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45054 if (SWIG_arg_fail(1)) SWIG_fail;
45055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
45056 if (SWIG_arg_fail(2)) SWIG_fail;
45057 {
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
45060
45061 wxPyEndAllowThreads(__tstate);
45062 if (PyErr_Occurred()) SWIG_fail;
45063 }
45064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45065 return resultobj;
45066 fail:
45067 return NULL;
45068 }
45069
45070
45071 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
45072 int argc;
45073 PyObject *argv[3];
45074 int ii;
45075
45076 argc = PyObject_Length(args);
45077 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
45078 argv[ii] = PyTuple_GetItem(args,ii);
45079 }
45080 if (argc == 2) {
45081 int _v;
45082 {
45083 void *ptr;
45084 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
45085 _v = 0;
45086 PyErr_Clear();
45087 } else {
45088 _v = 1;
45089 }
45090 }
45091 if (_v) {
45092 {
45093 void *ptr;
45094 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
45095 _v = 0;
45096 PyErr_Clear();
45097 } else {
45098 _v = 1;
45099 }
45100 }
45101 if (_v) {
45102 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
45103 }
45104 }
45105 }
45106 if (argc == 2) {
45107 int _v;
45108 {
45109 void *ptr;
45110 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
45111 _v = 0;
45112 PyErr_Clear();
45113 } else {
45114 _v = 1;
45115 }
45116 }
45117 if (_v) {
45118 {
45119 void *ptr;
45120 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
45121 _v = 0;
45122 PyErr_Clear();
45123 } else {
45124 _v = 1;
45125 }
45126 }
45127 if (_v) {
45128 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
45129 }
45130 }
45131 }
45132
45133 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
45134 return NULL;
45135 }
45136
45137
45138 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
45139 PyObject *resultobj = NULL;
45140 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45141 wxGBPosition *arg2 = 0 ;
45142 wxGBSizerItem *result;
45143 wxGBPosition temp2 ;
45144 PyObject * obj0 = 0 ;
45145 PyObject * obj1 = 0 ;
45146 char *kwnames[] = {
45147 (char *) "self",(char *) "pos", NULL
45148 };
45149
45150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
45151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45152 if (SWIG_arg_fail(1)) SWIG_fail;
45153 {
45154 arg2 = &temp2;
45155 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45156 }
45157 {
45158 PyThreadState* __tstate = wxPyBeginAllowThreads();
45159 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
45160
45161 wxPyEndAllowThreads(__tstate);
45162 if (PyErr_Occurred()) SWIG_fail;
45163 }
45164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
45172 PyObject *resultobj = NULL;
45173 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45174 wxPoint *arg2 = 0 ;
45175 wxGBSizerItem *result;
45176 wxPoint temp2 ;
45177 PyObject * obj0 = 0 ;
45178 PyObject * obj1 = 0 ;
45179 char *kwnames[] = {
45180 (char *) "self",(char *) "pt", NULL
45181 };
45182
45183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
45184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45185 if (SWIG_arg_fail(1)) SWIG_fail;
45186 {
45187 arg2 = &temp2;
45188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45189 }
45190 {
45191 PyThreadState* __tstate = wxPyBeginAllowThreads();
45192 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
45193
45194 wxPyEndAllowThreads(__tstate);
45195 if (PyErr_Occurred()) SWIG_fail;
45196 }
45197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45198 return resultobj;
45199 fail:
45200 return NULL;
45201 }
45202
45203
45204 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
45205 PyObject *resultobj = NULL;
45206 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45207 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
45208 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
45209 bool result;
45210 PyObject * obj0 = 0 ;
45211 PyObject * obj1 = 0 ;
45212 PyObject * obj2 = 0 ;
45213 char *kwnames[] = {
45214 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
45215 };
45216
45217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
45218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45219 if (SWIG_arg_fail(1)) SWIG_fail;
45220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45221 if (SWIG_arg_fail(2)) SWIG_fail;
45222 if (obj2) {
45223 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45224 if (SWIG_arg_fail(3)) SWIG_fail;
45225 }
45226 {
45227 PyThreadState* __tstate = wxPyBeginAllowThreads();
45228 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
45229
45230 wxPyEndAllowThreads(__tstate);
45231 if (PyErr_Occurred()) SWIG_fail;
45232 }
45233 {
45234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45235 }
45236 return resultobj;
45237 fail:
45238 return NULL;
45239 }
45240
45241
45242 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
45243 PyObject *resultobj = NULL;
45244 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45245 wxGBPosition *arg2 = 0 ;
45246 wxGBSpan *arg3 = 0 ;
45247 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45248 bool result;
45249 wxGBPosition temp2 ;
45250 wxGBSpan temp3 ;
45251 PyObject * obj0 = 0 ;
45252 PyObject * obj1 = 0 ;
45253 PyObject * obj2 = 0 ;
45254 PyObject * obj3 = 0 ;
45255 char *kwnames[] = {
45256 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45257 };
45258
45259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45261 if (SWIG_arg_fail(1)) SWIG_fail;
45262 {
45263 arg2 = &temp2;
45264 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45265 }
45266 {
45267 arg3 = &temp3;
45268 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45269 }
45270 if (obj3) {
45271 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45272 if (SWIG_arg_fail(4)) SWIG_fail;
45273 }
45274 {
45275 PyThreadState* __tstate = wxPyBeginAllowThreads();
45276 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45277
45278 wxPyEndAllowThreads(__tstate);
45279 if (PyErr_Occurred()) SWIG_fail;
45280 }
45281 {
45282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45283 }
45284 return resultobj;
45285 fail:
45286 return NULL;
45287 }
45288
45289
45290 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45291 PyObject *obj;
45292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45293 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45294 Py_INCREF(obj);
45295 return Py_BuildValue((char *)"");
45296 }
45297 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45298 PyObject *resultobj = NULL;
45299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45300 wxRelationship arg2 ;
45301 wxWindow *arg3 = (wxWindow *) 0 ;
45302 wxEdge arg4 ;
45303 int arg5 = (int) 0 ;
45304 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45305 PyObject * obj0 = 0 ;
45306 PyObject * obj1 = 0 ;
45307 PyObject * obj2 = 0 ;
45308 PyObject * obj3 = 0 ;
45309 PyObject * obj4 = 0 ;
45310 PyObject * obj5 = 0 ;
45311 char *kwnames[] = {
45312 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45313 };
45314
45315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45317 if (SWIG_arg_fail(1)) SWIG_fail;
45318 {
45319 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45320 if (SWIG_arg_fail(2)) SWIG_fail;
45321 }
45322 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45323 if (SWIG_arg_fail(3)) SWIG_fail;
45324 {
45325 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45326 if (SWIG_arg_fail(4)) SWIG_fail;
45327 }
45328 if (obj4) {
45329 {
45330 arg5 = static_cast<int >(SWIG_As_int(obj4));
45331 if (SWIG_arg_fail(5)) SWIG_fail;
45332 }
45333 }
45334 if (obj5) {
45335 {
45336 arg6 = static_cast<int >(SWIG_As_int(obj5));
45337 if (SWIG_arg_fail(6)) SWIG_fail;
45338 }
45339 }
45340 {
45341 PyThreadState* __tstate = wxPyBeginAllowThreads();
45342 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45343
45344 wxPyEndAllowThreads(__tstate);
45345 if (PyErr_Occurred()) SWIG_fail;
45346 }
45347 Py_INCREF(Py_None); resultobj = Py_None;
45348 return resultobj;
45349 fail:
45350 return NULL;
45351 }
45352
45353
45354 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45355 PyObject *resultobj = NULL;
45356 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45357 wxWindow *arg2 = (wxWindow *) 0 ;
45358 int arg3 = (int) 0 ;
45359 PyObject * obj0 = 0 ;
45360 PyObject * obj1 = 0 ;
45361 PyObject * obj2 = 0 ;
45362 char *kwnames[] = {
45363 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45364 };
45365
45366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45368 if (SWIG_arg_fail(1)) SWIG_fail;
45369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45370 if (SWIG_arg_fail(2)) SWIG_fail;
45371 if (obj2) {
45372 {
45373 arg3 = static_cast<int >(SWIG_As_int(obj2));
45374 if (SWIG_arg_fail(3)) SWIG_fail;
45375 }
45376 }
45377 {
45378 PyThreadState* __tstate = wxPyBeginAllowThreads();
45379 (arg1)->LeftOf(arg2,arg3);
45380
45381 wxPyEndAllowThreads(__tstate);
45382 if (PyErr_Occurred()) SWIG_fail;
45383 }
45384 Py_INCREF(Py_None); resultobj = Py_None;
45385 return resultobj;
45386 fail:
45387 return NULL;
45388 }
45389
45390
45391 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45392 PyObject *resultobj = NULL;
45393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45394 wxWindow *arg2 = (wxWindow *) 0 ;
45395 int arg3 = (int) 0 ;
45396 PyObject * obj0 = 0 ;
45397 PyObject * obj1 = 0 ;
45398 PyObject * obj2 = 0 ;
45399 char *kwnames[] = {
45400 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45401 };
45402
45403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45405 if (SWIG_arg_fail(1)) SWIG_fail;
45406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45407 if (SWIG_arg_fail(2)) SWIG_fail;
45408 if (obj2) {
45409 {
45410 arg3 = static_cast<int >(SWIG_As_int(obj2));
45411 if (SWIG_arg_fail(3)) SWIG_fail;
45412 }
45413 }
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 (arg1)->RightOf(arg2,arg3);
45417
45418 wxPyEndAllowThreads(__tstate);
45419 if (PyErr_Occurred()) SWIG_fail;
45420 }
45421 Py_INCREF(Py_None); resultobj = Py_None;
45422 return resultobj;
45423 fail:
45424 return NULL;
45425 }
45426
45427
45428 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45429 PyObject *resultobj = NULL;
45430 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45431 wxWindow *arg2 = (wxWindow *) 0 ;
45432 int arg3 = (int) 0 ;
45433 PyObject * obj0 = 0 ;
45434 PyObject * obj1 = 0 ;
45435 PyObject * obj2 = 0 ;
45436 char *kwnames[] = {
45437 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45438 };
45439
45440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45442 if (SWIG_arg_fail(1)) SWIG_fail;
45443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45444 if (SWIG_arg_fail(2)) SWIG_fail;
45445 if (obj2) {
45446 {
45447 arg3 = static_cast<int >(SWIG_As_int(obj2));
45448 if (SWIG_arg_fail(3)) SWIG_fail;
45449 }
45450 }
45451 {
45452 PyThreadState* __tstate = wxPyBeginAllowThreads();
45453 (arg1)->Above(arg2,arg3);
45454
45455 wxPyEndAllowThreads(__tstate);
45456 if (PyErr_Occurred()) SWIG_fail;
45457 }
45458 Py_INCREF(Py_None); resultobj = Py_None;
45459 return resultobj;
45460 fail:
45461 return NULL;
45462 }
45463
45464
45465 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45466 PyObject *resultobj = NULL;
45467 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45468 wxWindow *arg2 = (wxWindow *) 0 ;
45469 int arg3 = (int) 0 ;
45470 PyObject * obj0 = 0 ;
45471 PyObject * obj1 = 0 ;
45472 PyObject * obj2 = 0 ;
45473 char *kwnames[] = {
45474 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45475 };
45476
45477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45479 if (SWIG_arg_fail(1)) SWIG_fail;
45480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45481 if (SWIG_arg_fail(2)) SWIG_fail;
45482 if (obj2) {
45483 {
45484 arg3 = static_cast<int >(SWIG_As_int(obj2));
45485 if (SWIG_arg_fail(3)) SWIG_fail;
45486 }
45487 }
45488 {
45489 PyThreadState* __tstate = wxPyBeginAllowThreads();
45490 (arg1)->Below(arg2,arg3);
45491
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 Py_INCREF(Py_None); resultobj = Py_None;
45496 return resultobj;
45497 fail:
45498 return NULL;
45499 }
45500
45501
45502 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45503 PyObject *resultobj = NULL;
45504 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45505 wxWindow *arg2 = (wxWindow *) 0 ;
45506 wxEdge arg3 ;
45507 int arg4 = (int) 0 ;
45508 PyObject * obj0 = 0 ;
45509 PyObject * obj1 = 0 ;
45510 PyObject * obj2 = 0 ;
45511 PyObject * obj3 = 0 ;
45512 char *kwnames[] = {
45513 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45514 };
45515
45516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45518 if (SWIG_arg_fail(1)) SWIG_fail;
45519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45520 if (SWIG_arg_fail(2)) SWIG_fail;
45521 {
45522 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45523 if (SWIG_arg_fail(3)) SWIG_fail;
45524 }
45525 if (obj3) {
45526 {
45527 arg4 = static_cast<int >(SWIG_As_int(obj3));
45528 if (SWIG_arg_fail(4)) SWIG_fail;
45529 }
45530 }
45531 {
45532 PyThreadState* __tstate = wxPyBeginAllowThreads();
45533 (arg1)->SameAs(arg2,arg3,arg4);
45534
45535 wxPyEndAllowThreads(__tstate);
45536 if (PyErr_Occurred()) SWIG_fail;
45537 }
45538 Py_INCREF(Py_None); resultobj = Py_None;
45539 return resultobj;
45540 fail:
45541 return NULL;
45542 }
45543
45544
45545 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45546 PyObject *resultobj = NULL;
45547 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45548 wxWindow *arg2 = (wxWindow *) 0 ;
45549 wxEdge arg3 ;
45550 int arg4 ;
45551 PyObject * obj0 = 0 ;
45552 PyObject * obj1 = 0 ;
45553 PyObject * obj2 = 0 ;
45554 PyObject * obj3 = 0 ;
45555 char *kwnames[] = {
45556 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45557 };
45558
45559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45561 if (SWIG_arg_fail(1)) SWIG_fail;
45562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45563 if (SWIG_arg_fail(2)) SWIG_fail;
45564 {
45565 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45566 if (SWIG_arg_fail(3)) SWIG_fail;
45567 }
45568 {
45569 arg4 = static_cast<int >(SWIG_As_int(obj3));
45570 if (SWIG_arg_fail(4)) SWIG_fail;
45571 }
45572 {
45573 PyThreadState* __tstate = wxPyBeginAllowThreads();
45574 (arg1)->PercentOf(arg2,arg3,arg4);
45575
45576 wxPyEndAllowThreads(__tstate);
45577 if (PyErr_Occurred()) SWIG_fail;
45578 }
45579 Py_INCREF(Py_None); resultobj = Py_None;
45580 return resultobj;
45581 fail:
45582 return NULL;
45583 }
45584
45585
45586 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45587 PyObject *resultobj = NULL;
45588 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45589 int arg2 ;
45590 PyObject * obj0 = 0 ;
45591 PyObject * obj1 = 0 ;
45592 char *kwnames[] = {
45593 (char *) "self",(char *) "val", NULL
45594 };
45595
45596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45598 if (SWIG_arg_fail(1)) SWIG_fail;
45599 {
45600 arg2 = static_cast<int >(SWIG_As_int(obj1));
45601 if (SWIG_arg_fail(2)) SWIG_fail;
45602 }
45603 {
45604 PyThreadState* __tstate = wxPyBeginAllowThreads();
45605 (arg1)->Absolute(arg2);
45606
45607 wxPyEndAllowThreads(__tstate);
45608 if (PyErr_Occurred()) SWIG_fail;
45609 }
45610 Py_INCREF(Py_None); resultobj = Py_None;
45611 return resultobj;
45612 fail:
45613 return NULL;
45614 }
45615
45616
45617 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45618 PyObject *resultobj = NULL;
45619 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45620 PyObject * obj0 = 0 ;
45621 char *kwnames[] = {
45622 (char *) "self", NULL
45623 };
45624
45625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45627 if (SWIG_arg_fail(1)) SWIG_fail;
45628 {
45629 PyThreadState* __tstate = wxPyBeginAllowThreads();
45630 (arg1)->Unconstrained();
45631
45632 wxPyEndAllowThreads(__tstate);
45633 if (PyErr_Occurred()) SWIG_fail;
45634 }
45635 Py_INCREF(Py_None); resultobj = Py_None;
45636 return resultobj;
45637 fail:
45638 return NULL;
45639 }
45640
45641
45642 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45643 PyObject *resultobj = NULL;
45644 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45645 PyObject * obj0 = 0 ;
45646 char *kwnames[] = {
45647 (char *) "self", NULL
45648 };
45649
45650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45652 if (SWIG_arg_fail(1)) SWIG_fail;
45653 {
45654 PyThreadState* __tstate = wxPyBeginAllowThreads();
45655 (arg1)->AsIs();
45656
45657 wxPyEndAllowThreads(__tstate);
45658 if (PyErr_Occurred()) SWIG_fail;
45659 }
45660 Py_INCREF(Py_None); resultobj = Py_None;
45661 return resultobj;
45662 fail:
45663 return NULL;
45664 }
45665
45666
45667 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45668 PyObject *resultobj = NULL;
45669 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45670 wxWindow *result;
45671 PyObject * obj0 = 0 ;
45672 char *kwnames[] = {
45673 (char *) "self", NULL
45674 };
45675
45676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45678 if (SWIG_arg_fail(1)) SWIG_fail;
45679 {
45680 PyThreadState* __tstate = wxPyBeginAllowThreads();
45681 result = (wxWindow *)(arg1)->GetOtherWindow();
45682
45683 wxPyEndAllowThreads(__tstate);
45684 if (PyErr_Occurred()) SWIG_fail;
45685 }
45686 {
45687 resultobj = wxPyMake_wxObject(result, 0);
45688 }
45689 return resultobj;
45690 fail:
45691 return NULL;
45692 }
45693
45694
45695 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45696 PyObject *resultobj = NULL;
45697 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45698 wxEdge result;
45699 PyObject * obj0 = 0 ;
45700 char *kwnames[] = {
45701 (char *) "self", NULL
45702 };
45703
45704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45706 if (SWIG_arg_fail(1)) SWIG_fail;
45707 {
45708 PyThreadState* __tstate = wxPyBeginAllowThreads();
45709 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45710
45711 wxPyEndAllowThreads(__tstate);
45712 if (PyErr_Occurred()) SWIG_fail;
45713 }
45714 resultobj = SWIG_From_int((result));
45715 return resultobj;
45716 fail:
45717 return NULL;
45718 }
45719
45720
45721 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45722 PyObject *resultobj = NULL;
45723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45724 wxEdge arg2 ;
45725 PyObject * obj0 = 0 ;
45726 PyObject * obj1 = 0 ;
45727 char *kwnames[] = {
45728 (char *) "self",(char *) "which", NULL
45729 };
45730
45731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45733 if (SWIG_arg_fail(1)) SWIG_fail;
45734 {
45735 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45736 if (SWIG_arg_fail(2)) SWIG_fail;
45737 }
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 (arg1)->SetEdge(arg2);
45741
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 Py_INCREF(Py_None); resultobj = Py_None;
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = NULL;
45754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45755 int arg2 ;
45756 PyObject * obj0 = 0 ;
45757 PyObject * obj1 = 0 ;
45758 char *kwnames[] = {
45759 (char *) "self",(char *) "v", NULL
45760 };
45761
45762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45764 if (SWIG_arg_fail(1)) SWIG_fail;
45765 {
45766 arg2 = static_cast<int >(SWIG_As_int(obj1));
45767 if (SWIG_arg_fail(2)) SWIG_fail;
45768 }
45769 {
45770 PyThreadState* __tstate = wxPyBeginAllowThreads();
45771 (arg1)->SetValue(arg2);
45772
45773 wxPyEndAllowThreads(__tstate);
45774 if (PyErr_Occurred()) SWIG_fail;
45775 }
45776 Py_INCREF(Py_None); resultobj = Py_None;
45777 return resultobj;
45778 fail:
45779 return NULL;
45780 }
45781
45782
45783 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45784 PyObject *resultobj = NULL;
45785 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45786 int result;
45787 PyObject * obj0 = 0 ;
45788 char *kwnames[] = {
45789 (char *) "self", NULL
45790 };
45791
45792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45794 if (SWIG_arg_fail(1)) SWIG_fail;
45795 {
45796 PyThreadState* __tstate = wxPyBeginAllowThreads();
45797 result = (int)(arg1)->GetMargin();
45798
45799 wxPyEndAllowThreads(__tstate);
45800 if (PyErr_Occurred()) SWIG_fail;
45801 }
45802 {
45803 resultobj = SWIG_From_int(static_cast<int >(result));
45804 }
45805 return resultobj;
45806 fail:
45807 return NULL;
45808 }
45809
45810
45811 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45812 PyObject *resultobj = NULL;
45813 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45814 int arg2 ;
45815 PyObject * obj0 = 0 ;
45816 PyObject * obj1 = 0 ;
45817 char *kwnames[] = {
45818 (char *) "self",(char *) "m", NULL
45819 };
45820
45821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45823 if (SWIG_arg_fail(1)) SWIG_fail;
45824 {
45825 arg2 = static_cast<int >(SWIG_As_int(obj1));
45826 if (SWIG_arg_fail(2)) SWIG_fail;
45827 }
45828 {
45829 PyThreadState* __tstate = wxPyBeginAllowThreads();
45830 (arg1)->SetMargin(arg2);
45831
45832 wxPyEndAllowThreads(__tstate);
45833 if (PyErr_Occurred()) SWIG_fail;
45834 }
45835 Py_INCREF(Py_None); resultobj = Py_None;
45836 return resultobj;
45837 fail:
45838 return NULL;
45839 }
45840
45841
45842 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45843 PyObject *resultobj = NULL;
45844 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45845 int result;
45846 PyObject * obj0 = 0 ;
45847 char *kwnames[] = {
45848 (char *) "self", NULL
45849 };
45850
45851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45853 if (SWIG_arg_fail(1)) SWIG_fail;
45854 {
45855 PyThreadState* __tstate = wxPyBeginAllowThreads();
45856 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45857
45858 wxPyEndAllowThreads(__tstate);
45859 if (PyErr_Occurred()) SWIG_fail;
45860 }
45861 {
45862 resultobj = SWIG_From_int(static_cast<int >(result));
45863 }
45864 return resultobj;
45865 fail:
45866 return NULL;
45867 }
45868
45869
45870 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45871 PyObject *resultobj = NULL;
45872 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45873 int result;
45874 PyObject * obj0 = 0 ;
45875 char *kwnames[] = {
45876 (char *) "self", NULL
45877 };
45878
45879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45881 if (SWIG_arg_fail(1)) SWIG_fail;
45882 {
45883 PyThreadState* __tstate = wxPyBeginAllowThreads();
45884 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45885
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 {
45890 resultobj = SWIG_From_int(static_cast<int >(result));
45891 }
45892 return resultobj;
45893 fail:
45894 return NULL;
45895 }
45896
45897
45898 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45899 PyObject *resultobj = NULL;
45900 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45901 int result;
45902 PyObject * obj0 = 0 ;
45903 char *kwnames[] = {
45904 (char *) "self", NULL
45905 };
45906
45907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45909 if (SWIG_arg_fail(1)) SWIG_fail;
45910 {
45911 PyThreadState* __tstate = wxPyBeginAllowThreads();
45912 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45913
45914 wxPyEndAllowThreads(__tstate);
45915 if (PyErr_Occurred()) SWIG_fail;
45916 }
45917 {
45918 resultobj = SWIG_From_int(static_cast<int >(result));
45919 }
45920 return resultobj;
45921 fail:
45922 return NULL;
45923 }
45924
45925
45926 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45927 PyObject *resultobj = NULL;
45928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45929 bool result;
45930 PyObject * obj0 = 0 ;
45931 char *kwnames[] = {
45932 (char *) "self", NULL
45933 };
45934
45935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45937 if (SWIG_arg_fail(1)) SWIG_fail;
45938 {
45939 PyThreadState* __tstate = wxPyBeginAllowThreads();
45940 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45941
45942 wxPyEndAllowThreads(__tstate);
45943 if (PyErr_Occurred()) SWIG_fail;
45944 }
45945 {
45946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45947 }
45948 return resultobj;
45949 fail:
45950 return NULL;
45951 }
45952
45953
45954 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45955 PyObject *resultobj = NULL;
45956 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45957 bool arg2 ;
45958 PyObject * obj0 = 0 ;
45959 PyObject * obj1 = 0 ;
45960 char *kwnames[] = {
45961 (char *) "self",(char *) "d", NULL
45962 };
45963
45964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45966 if (SWIG_arg_fail(1)) SWIG_fail;
45967 {
45968 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45969 if (SWIG_arg_fail(2)) SWIG_fail;
45970 }
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 (arg1)->SetDone(arg2);
45974
45975 wxPyEndAllowThreads(__tstate);
45976 if (PyErr_Occurred()) SWIG_fail;
45977 }
45978 Py_INCREF(Py_None); resultobj = Py_None;
45979 return resultobj;
45980 fail:
45981 return NULL;
45982 }
45983
45984
45985 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45986 PyObject *resultobj = NULL;
45987 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45988 wxRelationship result;
45989 PyObject * obj0 = 0 ;
45990 char *kwnames[] = {
45991 (char *) "self", NULL
45992 };
45993
45994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45996 if (SWIG_arg_fail(1)) SWIG_fail;
45997 {
45998 PyThreadState* __tstate = wxPyBeginAllowThreads();
45999 result = (wxRelationship)(arg1)->GetRelationship();
46000
46001 wxPyEndAllowThreads(__tstate);
46002 if (PyErr_Occurred()) SWIG_fail;
46003 }
46004 resultobj = SWIG_From_int((result));
46005 return resultobj;
46006 fail:
46007 return NULL;
46008 }
46009
46010
46011 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
46012 PyObject *resultobj = NULL;
46013 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46014 wxRelationship arg2 ;
46015 PyObject * obj0 = 0 ;
46016 PyObject * obj1 = 0 ;
46017 char *kwnames[] = {
46018 (char *) "self",(char *) "r", NULL
46019 };
46020
46021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
46022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46023 if (SWIG_arg_fail(1)) SWIG_fail;
46024 {
46025 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
46026 if (SWIG_arg_fail(2)) SWIG_fail;
46027 }
46028 {
46029 PyThreadState* __tstate = wxPyBeginAllowThreads();
46030 (arg1)->SetRelationship(arg2);
46031
46032 wxPyEndAllowThreads(__tstate);
46033 if (PyErr_Occurred()) SWIG_fail;
46034 }
46035 Py_INCREF(Py_None); resultobj = Py_None;
46036 return resultobj;
46037 fail:
46038 return NULL;
46039 }
46040
46041
46042 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
46043 PyObject *resultobj = NULL;
46044 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46045 wxWindow *arg2 = (wxWindow *) 0 ;
46046 bool result;
46047 PyObject * obj0 = 0 ;
46048 PyObject * obj1 = 0 ;
46049 char *kwnames[] = {
46050 (char *) "self",(char *) "otherW", NULL
46051 };
46052
46053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
46054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46055 if (SWIG_arg_fail(1)) SWIG_fail;
46056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46057 if (SWIG_arg_fail(2)) SWIG_fail;
46058 {
46059 PyThreadState* __tstate = wxPyBeginAllowThreads();
46060 result = (bool)(arg1)->ResetIfWin(arg2);
46061
46062 wxPyEndAllowThreads(__tstate);
46063 if (PyErr_Occurred()) SWIG_fail;
46064 }
46065 {
46066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46067 }
46068 return resultobj;
46069 fail:
46070 return NULL;
46071 }
46072
46073
46074 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
46075 PyObject *resultobj = NULL;
46076 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46077 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
46078 wxWindow *arg3 = (wxWindow *) 0 ;
46079 bool result;
46080 PyObject * obj0 = 0 ;
46081 PyObject * obj1 = 0 ;
46082 PyObject * obj2 = 0 ;
46083 char *kwnames[] = {
46084 (char *) "self",(char *) "constraints",(char *) "win", NULL
46085 };
46086
46087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
46088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46089 if (SWIG_arg_fail(1)) SWIG_fail;
46090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46091 if (SWIG_arg_fail(2)) SWIG_fail;
46092 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46093 if (SWIG_arg_fail(3)) SWIG_fail;
46094 {
46095 PyThreadState* __tstate = wxPyBeginAllowThreads();
46096 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
46097
46098 wxPyEndAllowThreads(__tstate);
46099 if (PyErr_Occurred()) SWIG_fail;
46100 }
46101 {
46102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46103 }
46104 return resultobj;
46105 fail:
46106 return NULL;
46107 }
46108
46109
46110 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
46111 PyObject *resultobj = NULL;
46112 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46113 wxEdge arg2 ;
46114 wxWindow *arg3 = (wxWindow *) 0 ;
46115 wxWindow *arg4 = (wxWindow *) 0 ;
46116 int result;
46117 PyObject * obj0 = 0 ;
46118 PyObject * obj1 = 0 ;
46119 PyObject * obj2 = 0 ;
46120 PyObject * obj3 = 0 ;
46121 char *kwnames[] = {
46122 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
46123 };
46124
46125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
46126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46127 if (SWIG_arg_fail(1)) SWIG_fail;
46128 {
46129 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
46130 if (SWIG_arg_fail(2)) SWIG_fail;
46131 }
46132 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46133 if (SWIG_arg_fail(3)) SWIG_fail;
46134 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46135 if (SWIG_arg_fail(4)) SWIG_fail;
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
46139
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 {
46144 resultobj = SWIG_From_int(static_cast<int >(result));
46145 }
46146 return resultobj;
46147 fail:
46148 return NULL;
46149 }
46150
46151
46152 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
46153 PyObject *obj;
46154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46155 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
46156 Py_INCREF(obj);
46157 return Py_BuildValue((char *)"");
46158 }
46159 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
46160 PyObject *resultobj = NULL;
46161 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46162 wxIndividualLayoutConstraint *result;
46163 PyObject * obj0 = 0 ;
46164 char *kwnames[] = {
46165 (char *) "self", NULL
46166 };
46167
46168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
46169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46170 if (SWIG_arg_fail(1)) SWIG_fail;
46171 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
46172
46173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46174 return resultobj;
46175 fail:
46176 return NULL;
46177 }
46178
46179
46180 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
46181 PyObject *resultobj = NULL;
46182 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46183 wxIndividualLayoutConstraint *result;
46184 PyObject * obj0 = 0 ;
46185 char *kwnames[] = {
46186 (char *) "self", NULL
46187 };
46188
46189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
46190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46191 if (SWIG_arg_fail(1)) SWIG_fail;
46192 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
46193
46194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46195 return resultobj;
46196 fail:
46197 return NULL;
46198 }
46199
46200
46201 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
46202 PyObject *resultobj = NULL;
46203 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46204 wxIndividualLayoutConstraint *result;
46205 PyObject * obj0 = 0 ;
46206 char *kwnames[] = {
46207 (char *) "self", NULL
46208 };
46209
46210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
46211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46212 if (SWIG_arg_fail(1)) SWIG_fail;
46213 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
46214
46215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46216 return resultobj;
46217 fail:
46218 return NULL;
46219 }
46220
46221
46222 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
46223 PyObject *resultobj = NULL;
46224 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46225 wxIndividualLayoutConstraint *result;
46226 PyObject * obj0 = 0 ;
46227 char *kwnames[] = {
46228 (char *) "self", NULL
46229 };
46230
46231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
46232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46233 if (SWIG_arg_fail(1)) SWIG_fail;
46234 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
46235
46236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46237 return resultobj;
46238 fail:
46239 return NULL;
46240 }
46241
46242
46243 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
46244 PyObject *resultobj = NULL;
46245 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46246 wxIndividualLayoutConstraint *result;
46247 PyObject * obj0 = 0 ;
46248 char *kwnames[] = {
46249 (char *) "self", NULL
46250 };
46251
46252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46254 if (SWIG_arg_fail(1)) SWIG_fail;
46255 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46256
46257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46258 return resultobj;
46259 fail:
46260 return NULL;
46261 }
46262
46263
46264 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46265 PyObject *resultobj = NULL;
46266 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46267 wxIndividualLayoutConstraint *result;
46268 PyObject * obj0 = 0 ;
46269 char *kwnames[] = {
46270 (char *) "self", NULL
46271 };
46272
46273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46275 if (SWIG_arg_fail(1)) SWIG_fail;
46276 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46277
46278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46279 return resultobj;
46280 fail:
46281 return NULL;
46282 }
46283
46284
46285 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
46286 PyObject *resultobj = NULL;
46287 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46288 wxIndividualLayoutConstraint *result;
46289 PyObject * obj0 = 0 ;
46290 char *kwnames[] = {
46291 (char *) "self", NULL
46292 };
46293
46294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
46295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46296 if (SWIG_arg_fail(1)) SWIG_fail;
46297 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
46298
46299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46300 return resultobj;
46301 fail:
46302 return NULL;
46303 }
46304
46305
46306 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
46307 PyObject *resultobj = NULL;
46308 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46309 wxIndividualLayoutConstraint *result;
46310 PyObject * obj0 = 0 ;
46311 char *kwnames[] = {
46312 (char *) "self", NULL
46313 };
46314
46315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
46316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46317 if (SWIG_arg_fail(1)) SWIG_fail;
46318 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
46319
46320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46321 return resultobj;
46322 fail:
46323 return NULL;
46324 }
46325
46326
46327 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46328 PyObject *resultobj = NULL;
46329 wxLayoutConstraints *result;
46330 char *kwnames[] = {
46331 NULL
46332 };
46333
46334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46335 {
46336 PyThreadState* __tstate = wxPyBeginAllowThreads();
46337 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46338
46339 wxPyEndAllowThreads(__tstate);
46340 if (PyErr_Occurred()) SWIG_fail;
46341 }
46342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46343 return resultobj;
46344 fail:
46345 return NULL;
46346 }
46347
46348
46349 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46350 PyObject *resultobj = NULL;
46351 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46352 wxWindow *arg2 = (wxWindow *) 0 ;
46353 int *arg3 = (int *) 0 ;
46354 bool result;
46355 int temp3 ;
46356 int res3 = 0 ;
46357 PyObject * obj0 = 0 ;
46358 PyObject * obj1 = 0 ;
46359 char *kwnames[] = {
46360 (char *) "self",(char *) "win", NULL
46361 };
46362
46363 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46366 if (SWIG_arg_fail(1)) SWIG_fail;
46367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46368 if (SWIG_arg_fail(2)) SWIG_fail;
46369 {
46370 PyThreadState* __tstate = wxPyBeginAllowThreads();
46371 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46372
46373 wxPyEndAllowThreads(__tstate);
46374 if (PyErr_Occurred()) SWIG_fail;
46375 }
46376 {
46377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46378 }
46379 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46380 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46381 return resultobj;
46382 fail:
46383 return NULL;
46384 }
46385
46386
46387 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46388 PyObject *resultobj = NULL;
46389 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46390 bool result;
46391 PyObject * obj0 = 0 ;
46392 char *kwnames[] = {
46393 (char *) "self", NULL
46394 };
46395
46396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46398 if (SWIG_arg_fail(1)) SWIG_fail;
46399 {
46400 PyThreadState* __tstate = wxPyBeginAllowThreads();
46401 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46402
46403 wxPyEndAllowThreads(__tstate);
46404 if (PyErr_Occurred()) SWIG_fail;
46405 }
46406 {
46407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46408 }
46409 return resultobj;
46410 fail:
46411 return NULL;
46412 }
46413
46414
46415 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46416 PyObject *obj;
46417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46418 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46419 Py_INCREF(obj);
46420 return Py_BuildValue((char *)"");
46421 }
46422 static PyMethodDef SwigMethods[] = {
46423 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46424 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46425 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46428 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46449 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46462 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46477 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46532 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46560 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46579 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46581 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46589 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46590 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46602 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46614 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46618 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46624 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46634 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46644 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46647 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46654 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46662 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46670 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46754 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46756 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46758 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46760 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46762 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46764 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46766 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46768 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46770 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46772 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46774 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46776 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46778 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46792 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46810 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46813 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46816 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46828 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46833 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46839 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46845 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46908 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46915 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"KeyEvent_GetModifiers", (PyCFunction) _wrap_KeyEvent_GetModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46952 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46962 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46968 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46970 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46972 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46975 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46979 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46982 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46985 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46987 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46992 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
47000 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
47004 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
47007 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
47009 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
47013 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"UpdateUIEvent_GetShown", (PyCFunction) _wrap_UpdateUIEvent_GetShown, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction) _wrap_UpdateUIEvent_GetSetShown, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
47033 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
47035 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
47038 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
47040 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
47044 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
47048 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
47059 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
47062 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
47065 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
47069 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
47076 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
47081 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
47086 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
47090 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
47135 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
47155 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
47158 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
47165 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
47169 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
47179 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47287 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47349 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47388 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47390 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47402 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47405 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47408 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47413 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47440 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47459 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47463 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47466 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47468 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47469 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47470 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47475 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47480 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47492 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47502 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47514 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47516 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47517 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47518 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47519 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47520 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47521 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47522 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47523 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47524 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47525 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47526 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47527 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47528 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47529 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47530 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47531 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47532 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47533 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47534 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47535 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47536 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47537 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47538 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47539 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47540 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47541 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47542 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47543 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47544 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47545 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47546 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47547 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47548 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47549 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47550 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47551 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47552 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47553 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47554 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47555 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47556 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47557 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47558 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47559 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47560 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47561 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47562 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47563 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47564 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47565 { (char *)"delete_SizerItem", (PyCFunction) _wrap_delete_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47566 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47567 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47568 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47569 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47570 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47571 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47572 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47573 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47574 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47575 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47576 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47577 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47578 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47579 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47580 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47581 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47582 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47583 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47584 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47585 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47586 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47587 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47588 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47589 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47590 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47591 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47592 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47593 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47594 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47595 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47596 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47597 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47598 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47599 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47600 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47601 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47602 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47603 { (char *)"delete_Sizer", (PyCFunction) _wrap_delete_Sizer, METH_VARARGS | METH_KEYWORDS, NULL},
47604 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47605 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47606 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47607 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47608 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47609 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47610 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47611 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47612 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47613 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47614 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47615 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47616 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47617 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47618 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47619 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47620 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47621 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47622 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47623 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47624 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47625 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47626 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47627 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47628 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47629 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47630 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47631 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47632 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47633 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47634 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47635 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47636 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47637 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47638 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47639 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47640 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47641 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47642 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47643 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47644 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47645 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47646 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47647 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47648 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47649 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47650 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47651 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47652 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47653 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47654 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47655 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47656 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47657 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47658 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47659 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47660 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47661 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47662 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47663 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47664 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47665 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47666 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47667 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47668 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47669 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47670 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47671 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47672 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47673 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47674 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47675 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47676 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47677 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47678 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47679 { (char *)"delete_GBPosition", (PyCFunction) _wrap_delete_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47680 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47681 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47682 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47683 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47684 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47685 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47686 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47687 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47688 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47689 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47690 { (char *)"delete_GBSpan", (PyCFunction) _wrap_delete_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47691 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47692 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47693 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47694 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47695 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47696 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47697 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47698 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47699 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47700 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47701 { (char *)"delete_GBSizerItem", (PyCFunction) _wrap_delete_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47702 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47703 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47704 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47705 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47706 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47707 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47708 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47709 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47710 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47711 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47712 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47713 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47714 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47715 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47716 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47717 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47718 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47719 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47720 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47721 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47722 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47723 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47724 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47725 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47726 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47727 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47728 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47729 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47730 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47731 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47732 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47733 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47734 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47735 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47736 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47737 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47738 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47739 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47740 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47741 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47742 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47743 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47744 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47745 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47746 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47747 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47748 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47749 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47750 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47751 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47752 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47753 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47754 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47755 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47756 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47757 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47758 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47759 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47760 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47761 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47762 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47763 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47764 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47765 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47766 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47767 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47768 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47769 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47770 { NULL, NULL, 0, NULL }
47771 };
47772
47773
47774 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47775
47776 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47777 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47778 }
47779 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47780 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47781 }
47782 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47783 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47784 }
47785 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47786 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47787 }
47788 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47789 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47790 }
47791 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47792 return (void *)((wxSizer *) ((wxGridSizer *) x));
47793 }
47794 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47795 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47796 }
47797 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47798 return (void *)((wxSizer *) ((wxPySizer *) x));
47799 }
47800 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47801 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47802 }
47803 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47804 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47805 }
47806 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47807 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47808 }
47809 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47810 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47811 }
47812 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47813 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47814 }
47815 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47816 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47817 }
47818 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47819 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47820 }
47821 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47822 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47823 }
47824 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47825 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47826 }
47827 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47828 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47829 }
47830 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47831 return (void *)((wxEvent *) ((wxPyEvent *) x));
47832 }
47833 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47834 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47835 }
47836 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47837 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47838 }
47839 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47840 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47841 }
47842 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47843 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47844 }
47845 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47846 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47847 }
47848 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47849 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47850 }
47851 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47852 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47853 }
47854 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47855 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47856 }
47857 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47858 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47859 }
47860 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47861 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47862 }
47863 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47864 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47865 }
47866 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47867 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47868 }
47869 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47870 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47871 }
47872 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47873 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47874 }
47875 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47876 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47877 }
47878 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47879 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47880 }
47881 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47882 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47883 }
47884 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47885 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47886 }
47887 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47888 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47889 }
47890 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47891 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47892 }
47893 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47894 return (void *)((wxEvent *) ((wxShowEvent *) x));
47895 }
47896 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47897 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47898 }
47899 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47900 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47901 }
47902 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47903 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47904 }
47905 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47906 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47907 }
47908 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47909 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47910 }
47911 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47912 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47913 }
47914 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47915 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47916 }
47917 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47918 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47919 }
47920 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47921 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47922 }
47923 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47924 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47925 }
47926 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47927 return (void *)((wxControl *) ((wxControlWithItems *) x));
47928 }
47929 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47930 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47931 }
47932 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47933 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47934 }
47935 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47936 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47937 }
47938 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47939 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47940 }
47941 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47942 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47943 }
47944 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47945 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47946 }
47947 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47948 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47949 }
47950 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47951 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47952 }
47953 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47954 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47955 }
47956 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47957 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47958 }
47959 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47960 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47961 }
47962 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47963 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47964 }
47965 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47966 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47967 }
47968 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47969 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47970 }
47971 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47972 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47973 }
47974 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47975 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47976 }
47977 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47978 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47979 }
47980 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47981 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47982 }
47983 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47984 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47985 }
47986 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47987 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47988 }
47989 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47990 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47991 }
47992 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47993 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47994 }
47995 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47996 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47997 }
47998 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47999 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
48000 }
48001 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
48002 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
48003 }
48004 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
48005 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
48006 }
48007 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
48008 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
48009 }
48010 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
48011 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
48012 }
48013 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
48014 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
48015 }
48016 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
48017 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
48018 }
48019 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
48020 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
48021 }
48022 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
48023 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
48024 }
48025 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
48026 return (void *)((wxObject *) ((wxSizerItem *) x));
48027 }
48028 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
48029 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
48030 }
48031 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
48032 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
48033 }
48034 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
48035 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
48036 }
48037 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
48038 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
48039 }
48040 static void *_p_wxSizerTo_p_wxObject(void *x) {
48041 return (void *)((wxObject *) ((wxSizer *) x));
48042 }
48043 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
48044 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
48045 }
48046 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
48047 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
48048 }
48049 static void *_p_wxEventTo_p_wxObject(void *x) {
48050 return (void *)((wxObject *) ((wxEvent *) x));
48051 }
48052 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
48053 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
48054 }
48055 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
48056 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
48057 }
48058 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
48059 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
48060 }
48061 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
48062 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
48063 }
48064 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
48065 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
48066 }
48067 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
48068 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
48069 }
48070 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
48071 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
48072 }
48073 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
48074 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
48075 }
48076 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
48077 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
48078 }
48079 static void *_p_wxControlTo_p_wxObject(void *x) {
48080 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
48081 }
48082 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
48083 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
48084 }
48085 static void *_p_wxFSFileTo_p_wxObject(void *x) {
48086 return (void *)((wxObject *) ((wxFSFile *) x));
48087 }
48088 static void *_p_wxPySizerTo_p_wxObject(void *x) {
48089 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
48090 }
48091 static void *_p_wxPyEventTo_p_wxObject(void *x) {
48092 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
48093 }
48094 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
48095 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
48096 }
48097 static void *_p_wxShowEventTo_p_wxObject(void *x) {
48098 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
48099 }
48100 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
48101 return (void *)((wxObject *) ((wxMenuItem *) x));
48102 }
48103 static void *_p_wxDateEventTo_p_wxObject(void *x) {
48104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
48105 }
48106 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
48107 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
48108 }
48109 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
48110 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
48111 }
48112 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
48113 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
48114 }
48115 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
48116 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
48117 }
48118 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
48119 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
48120 }
48121 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
48122 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
48123 }
48124 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
48125 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
48126 }
48127 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
48128 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
48129 }
48130 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
48131 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
48132 }
48133 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
48134 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
48135 }
48136 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
48137 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
48138 }
48139 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
48140 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
48141 }
48142 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
48143 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
48144 }
48145 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
48146 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
48147 }
48148 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
48149 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
48150 }
48151 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
48152 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
48153 }
48154 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
48155 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
48156 }
48157 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
48158 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
48159 }
48160 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
48161 return (void *)((wxObject *) ((wxImageHandler *) x));
48162 }
48163 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
48164 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
48165 }
48166 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
48167 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
48168 }
48169 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
48170 return (void *)((wxObject *) ((wxEvtHandler *) x));
48171 }
48172 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
48173 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
48174 }
48175 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
48176 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
48177 }
48178 static void *_p_wxImageTo_p_wxObject(void *x) {
48179 return (void *)((wxObject *) ((wxImage *) x));
48180 }
48181 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
48182 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
48183 }
48184 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
48185 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48186 }
48187 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
48188 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
48189 }
48190 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
48191 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
48192 }
48193 static void *_p_wxWindowTo_p_wxObject(void *x) {
48194 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
48195 }
48196 static void *_p_wxMenuTo_p_wxObject(void *x) {
48197 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
48198 }
48199 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
48200 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
48201 }
48202 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
48203 return (void *)((wxObject *) ((wxFileSystem *) x));
48204 }
48205 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
48206 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
48207 }
48208 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
48209 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
48210 }
48211 static void *_p_wxPyAppTo_p_wxObject(void *x) {
48212 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
48213 }
48214 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
48215 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
48216 }
48217 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
48218 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
48219 }
48220 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
48221 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
48222 }
48223 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
48224 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
48225 }
48226 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
48227 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
48228 }
48229 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
48230 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
48231 }
48232 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
48233 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
48234 }
48235 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
48236 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
48237 }
48238 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
48239 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
48240 }
48241 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
48242 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
48243 }
48244 static void *_p_wxValidatorTo_p_wxObject(void *x) {
48245 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
48246 }
48247 static void *_p_wxControlTo_p_wxWindow(void *x) {
48248 return (void *)((wxWindow *) ((wxControl *) x));
48249 }
48250 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
48251 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
48252 }
48253 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48254 return (void *)((wxWindow *) ((wxMenuBar *) x));
48255 }
48256 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48257 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48258 }
48259 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48260 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48261 }
48262 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48263 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48264 }
48265 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48266 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48267 }
48268 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48269 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48270 }
48271 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48272 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48273 }
48274 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48275 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48276 }
48277 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48278 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48279 }
48280 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48281 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48282 }
48283 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48284 return (void *)((wxValidator *) ((wxPyValidator *) x));
48285 }
48286 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48287 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48288 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48289 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48290 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48291 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48292 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48293 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48294 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48295 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48296 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48297 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48298 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48299 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48300 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48301 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48302 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48303 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48304 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48305 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48306 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48307 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48308 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48309 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48310 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48311 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48312 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48313 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48314 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48315 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48316 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48317 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48318 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48319 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48320 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48321 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48322 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48323 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48324 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48325 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48326 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48327 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48328 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48329 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48330 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48331 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48332 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48333 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48334 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48335 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48336 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48337 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48338 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48339 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48340 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48341 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48342 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48343 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48344 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48345 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48346 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48347 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48348 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48349 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48350 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48351 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48352 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48353 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48354 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48355 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48356 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48357 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48358 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48359 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48360 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48361 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48362 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48363 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48364 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48365 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48366 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48367 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48368 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48369 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48370 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48371 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48372 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48373 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48374 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48375 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48376 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48377 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48378 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48379 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48380 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48381 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48382 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48383 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48384 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48385 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48386 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48387 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48388 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48389 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48390 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48391 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48392 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48393 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48394 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48395 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48396 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48397 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48398 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48399 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48400 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48401 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48402 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48403 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48404 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48405 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48406 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48407 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48408 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48409 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48410 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48411 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48412 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48413 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48414 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48415 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48416 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48417 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48418
48419 static swig_type_info *swig_type_initial[] = {
48420 &_swigt__p_buffer,
48421 &_swigt__p_char,
48422 &_swigt__p_form_ops_t,
48423 &_swigt__p_int,
48424 &_swigt__p_long,
48425 &_swigt__p_unsigned_char,
48426 &_swigt__p_unsigned_int,
48427 &_swigt__p_unsigned_long,
48428 &_swigt__p_wxANIHandler,
48429 &_swigt__p_wxAcceleratorEntry,
48430 &_swigt__p_wxAcceleratorTable,
48431 &_swigt__p_wxActivateEvent,
48432 &_swigt__p_wxAppTraits,
48433 &_swigt__p_wxArrayString,
48434 &_swigt__p_wxBMPHandler,
48435 &_swigt__p_wxBitmap,
48436 &_swigt__p_wxBoxSizer,
48437 &_swigt__p_wxButton,
48438 &_swigt__p_wxCURHandler,
48439 &_swigt__p_wxCaret,
48440 &_swigt__p_wxChildFocusEvent,
48441 &_swigt__p_wxCloseEvent,
48442 &_swigt__p_wxColour,
48443 &_swigt__p_wxCommandEvent,
48444 &_swigt__p_wxContextMenuEvent,
48445 &_swigt__p_wxControl,
48446 &_swigt__p_wxControlWithItems,
48447 &_swigt__p_wxCursor,
48448 &_swigt__p_wxDC,
48449 &_swigt__p_wxDateEvent,
48450 &_swigt__p_wxDateTime,
48451 &_swigt__p_wxDisplayChangedEvent,
48452 &_swigt__p_wxDropFilesEvent,
48453 &_swigt__p_wxDuplexMode,
48454 &_swigt__p_wxEraseEvent,
48455 &_swigt__p_wxEvent,
48456 &_swigt__p_wxEventLoop,
48457 &_swigt__p_wxEventLoopActivator,
48458 &_swigt__p_wxEvtHandler,
48459 &_swigt__p_wxFSFile,
48460 &_swigt__p_wxFileSystem,
48461 &_swigt__p_wxFileSystemHandler,
48462 &_swigt__p_wxFlexGridSizer,
48463 &_swigt__p_wxFocusEvent,
48464 &_swigt__p_wxFont,
48465 &_swigt__p_wxFrame,
48466 &_swigt__p_wxGBPosition,
48467 &_swigt__p_wxGBSizerItem,
48468 &_swigt__p_wxGBSpan,
48469 &_swigt__p_wxGIFHandler,
48470 &_swigt__p_wxGridBagSizer,
48471 &_swigt__p_wxGridSizer,
48472 &_swigt__p_wxICOHandler,
48473 &_swigt__p_wxIconizeEvent,
48474 &_swigt__p_wxIdleEvent,
48475 &_swigt__p_wxImage,
48476 &_swigt__p_wxImageHandler,
48477 &_swigt__p_wxImageHistogram,
48478 &_swigt__p_wxImage_HSVValue,
48479 &_swigt__p_wxImage_RGBValue,
48480 &_swigt__p_wxIndividualLayoutConstraint,
48481 &_swigt__p_wxInitDialogEvent,
48482 &_swigt__p_wxInputStream,
48483 &_swigt__p_wxInternetFSHandler,
48484 &_swigt__p_wxItemContainer,
48485 &_swigt__p_wxJPEGHandler,
48486 &_swigt__p_wxKeyEvent,
48487 &_swigt__p_wxLayoutConstraints,
48488 &_swigt__p_wxMaximizeEvent,
48489 &_swigt__p_wxMemoryFSHandler,
48490 &_swigt__p_wxMenu,
48491 &_swigt__p_wxMenuBar,
48492 &_swigt__p_wxMenuBarBase,
48493 &_swigt__p_wxMenuEvent,
48494 &_swigt__p_wxMenuItem,
48495 &_swigt__p_wxMouseCaptureChangedEvent,
48496 &_swigt__p_wxMouseEvent,
48497 &_swigt__p_wxMoveEvent,
48498 &_swigt__p_wxNavigationKeyEvent,
48499 &_swigt__p_wxNcPaintEvent,
48500 &_swigt__p_wxNotifyEvent,
48501 &_swigt__p_wxObject,
48502 &_swigt__p_wxOutputStream,
48503 &_swigt__p_wxPCXHandler,
48504 &_swigt__p_wxPNGHandler,
48505 &_swigt__p_wxPNMHandler,
48506 &_swigt__p_wxPaintEvent,
48507 &_swigt__p_wxPaletteChangedEvent,
48508 &_swigt__p_wxPaperSize,
48509 &_swigt__p_wxPoint,
48510 &_swigt__p_wxPoint2D,
48511 &_swigt__p_wxPropagateOnce,
48512 &_swigt__p_wxPropagationDisabler,
48513 &_swigt__p_wxPyApp,
48514 &_swigt__p_wxPyCommandEvent,
48515 &_swigt__p_wxPyDropTarget,
48516 &_swigt__p_wxPyEvent,
48517 &_swigt__p_wxPyFileSystemHandler,
48518 &_swigt__p_wxPyImageHandler,
48519 &_swigt__p_wxPyInputStream,
48520 &_swigt__p_wxPySizer,
48521 &_swigt__p_wxPyValidator,
48522 &_swigt__p_wxQuantize,
48523 &_swigt__p_wxQueryNewPaletteEvent,
48524 &_swigt__p_wxRealPoint,
48525 &_swigt__p_wxRect,
48526 &_swigt__p_wxRegion,
48527 &_swigt__p_wxScrollEvent,
48528 &_swigt__p_wxScrollWinEvent,
48529 &_swigt__p_wxSetCursorEvent,
48530 &_swigt__p_wxShowEvent,
48531 &_swigt__p_wxSize,
48532 &_swigt__p_wxSizeEvent,
48533 &_swigt__p_wxSizer,
48534 &_swigt__p_wxSizerItem,
48535 &_swigt__p_wxStaticBox,
48536 &_swigt__p_wxStaticBoxSizer,
48537 &_swigt__p_wxStdDialogButtonSizer,
48538 &_swigt__p_wxSysColourChangedEvent,
48539 &_swigt__p_wxTIFFHandler,
48540 &_swigt__p_wxToolTip,
48541 &_swigt__p_wxUpdateUIEvent,
48542 &_swigt__p_wxValidator,
48543 &_swigt__p_wxVisualAttributes,
48544 &_swigt__p_wxWindow,
48545 &_swigt__p_wxWindowCreateEvent,
48546 &_swigt__p_wxWindowDestroyEvent,
48547 &_swigt__p_wxXPMHandler,
48548 &_swigt__p_wxZipFSHandler,
48549 &_swigt__ptrdiff_t,
48550 &_swigt__std__ptrdiff_t,
48551 &_swigt__unsigned_int,
48552 };
48553
48554 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48555 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48556 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48557 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48558 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48559 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48560 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48561 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48562 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48563 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48564 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48565 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48566 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48567 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48568 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}};
48569 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48570 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}};
48571 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48572 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}};
48573 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48574 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48575 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48576 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48577 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_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}};
48578 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48579 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}};
48580 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48581 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48582 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48583 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48584 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48585 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48586 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48587 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48588 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48589 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_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
48590 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48591 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48592 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}};
48593 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48594 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48595 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}};
48596 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}};
48597 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48598 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48599 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48600 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48601 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48602 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48603 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48604 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48605 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}};
48606 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}};
48607 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48608 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48609 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48610 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}};
48611 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48612 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48613 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48614 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48615 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48616 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48617 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48618 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}};
48619 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48620 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48621 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48622 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48623 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48624 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48625 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48626 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48627 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48628 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48629 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48630 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48631 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48632 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48633 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48634 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48635 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_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_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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}};
48636 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48637 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48638 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48639 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48640 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48641 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48642 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48643 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48644 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48645 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48646 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48647 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48648 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48649 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48650 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48651 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48652 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48653 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48654 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48655 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48656 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48657 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48658 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48659 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48660 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48661 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48662 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48663 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48664 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48665 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48666 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48667 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}};
48668 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}};
48669 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48670 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48671 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48672 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48673 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48674 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48675 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48676 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}};
48677 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48678 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}};
48679 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48680 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48681 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48682 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48683 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48684 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48685 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48686
48687 static swig_cast_info *swig_cast_initial[] = {
48688 _swigc__p_buffer,
48689 _swigc__p_char,
48690 _swigc__p_form_ops_t,
48691 _swigc__p_int,
48692 _swigc__p_long,
48693 _swigc__p_unsigned_char,
48694 _swigc__p_unsigned_int,
48695 _swigc__p_unsigned_long,
48696 _swigc__p_wxANIHandler,
48697 _swigc__p_wxAcceleratorEntry,
48698 _swigc__p_wxAcceleratorTable,
48699 _swigc__p_wxActivateEvent,
48700 _swigc__p_wxAppTraits,
48701 _swigc__p_wxArrayString,
48702 _swigc__p_wxBMPHandler,
48703 _swigc__p_wxBitmap,
48704 _swigc__p_wxBoxSizer,
48705 _swigc__p_wxButton,
48706 _swigc__p_wxCURHandler,
48707 _swigc__p_wxCaret,
48708 _swigc__p_wxChildFocusEvent,
48709 _swigc__p_wxCloseEvent,
48710 _swigc__p_wxColour,
48711 _swigc__p_wxCommandEvent,
48712 _swigc__p_wxContextMenuEvent,
48713 _swigc__p_wxControl,
48714 _swigc__p_wxControlWithItems,
48715 _swigc__p_wxCursor,
48716 _swigc__p_wxDC,
48717 _swigc__p_wxDateEvent,
48718 _swigc__p_wxDateTime,
48719 _swigc__p_wxDisplayChangedEvent,
48720 _swigc__p_wxDropFilesEvent,
48721 _swigc__p_wxDuplexMode,
48722 _swigc__p_wxEraseEvent,
48723 _swigc__p_wxEvent,
48724 _swigc__p_wxEventLoop,
48725 _swigc__p_wxEventLoopActivator,
48726 _swigc__p_wxEvtHandler,
48727 _swigc__p_wxFSFile,
48728 _swigc__p_wxFileSystem,
48729 _swigc__p_wxFileSystemHandler,
48730 _swigc__p_wxFlexGridSizer,
48731 _swigc__p_wxFocusEvent,
48732 _swigc__p_wxFont,
48733 _swigc__p_wxFrame,
48734 _swigc__p_wxGBPosition,
48735 _swigc__p_wxGBSizerItem,
48736 _swigc__p_wxGBSpan,
48737 _swigc__p_wxGIFHandler,
48738 _swigc__p_wxGridBagSizer,
48739 _swigc__p_wxGridSizer,
48740 _swigc__p_wxICOHandler,
48741 _swigc__p_wxIconizeEvent,
48742 _swigc__p_wxIdleEvent,
48743 _swigc__p_wxImage,
48744 _swigc__p_wxImageHandler,
48745 _swigc__p_wxImageHistogram,
48746 _swigc__p_wxImage_HSVValue,
48747 _swigc__p_wxImage_RGBValue,
48748 _swigc__p_wxIndividualLayoutConstraint,
48749 _swigc__p_wxInitDialogEvent,
48750 _swigc__p_wxInputStream,
48751 _swigc__p_wxInternetFSHandler,
48752 _swigc__p_wxItemContainer,
48753 _swigc__p_wxJPEGHandler,
48754 _swigc__p_wxKeyEvent,
48755 _swigc__p_wxLayoutConstraints,
48756 _swigc__p_wxMaximizeEvent,
48757 _swigc__p_wxMemoryFSHandler,
48758 _swigc__p_wxMenu,
48759 _swigc__p_wxMenuBar,
48760 _swigc__p_wxMenuBarBase,
48761 _swigc__p_wxMenuEvent,
48762 _swigc__p_wxMenuItem,
48763 _swigc__p_wxMouseCaptureChangedEvent,
48764 _swigc__p_wxMouseEvent,
48765 _swigc__p_wxMoveEvent,
48766 _swigc__p_wxNavigationKeyEvent,
48767 _swigc__p_wxNcPaintEvent,
48768 _swigc__p_wxNotifyEvent,
48769 _swigc__p_wxObject,
48770 _swigc__p_wxOutputStream,
48771 _swigc__p_wxPCXHandler,
48772 _swigc__p_wxPNGHandler,
48773 _swigc__p_wxPNMHandler,
48774 _swigc__p_wxPaintEvent,
48775 _swigc__p_wxPaletteChangedEvent,
48776 _swigc__p_wxPaperSize,
48777 _swigc__p_wxPoint,
48778 _swigc__p_wxPoint2D,
48779 _swigc__p_wxPropagateOnce,
48780 _swigc__p_wxPropagationDisabler,
48781 _swigc__p_wxPyApp,
48782 _swigc__p_wxPyCommandEvent,
48783 _swigc__p_wxPyDropTarget,
48784 _swigc__p_wxPyEvent,
48785 _swigc__p_wxPyFileSystemHandler,
48786 _swigc__p_wxPyImageHandler,
48787 _swigc__p_wxPyInputStream,
48788 _swigc__p_wxPySizer,
48789 _swigc__p_wxPyValidator,
48790 _swigc__p_wxQuantize,
48791 _swigc__p_wxQueryNewPaletteEvent,
48792 _swigc__p_wxRealPoint,
48793 _swigc__p_wxRect,
48794 _swigc__p_wxRegion,
48795 _swigc__p_wxScrollEvent,
48796 _swigc__p_wxScrollWinEvent,
48797 _swigc__p_wxSetCursorEvent,
48798 _swigc__p_wxShowEvent,
48799 _swigc__p_wxSize,
48800 _swigc__p_wxSizeEvent,
48801 _swigc__p_wxSizer,
48802 _swigc__p_wxSizerItem,
48803 _swigc__p_wxStaticBox,
48804 _swigc__p_wxStaticBoxSizer,
48805 _swigc__p_wxStdDialogButtonSizer,
48806 _swigc__p_wxSysColourChangedEvent,
48807 _swigc__p_wxTIFFHandler,
48808 _swigc__p_wxToolTip,
48809 _swigc__p_wxUpdateUIEvent,
48810 _swigc__p_wxValidator,
48811 _swigc__p_wxVisualAttributes,
48812 _swigc__p_wxWindow,
48813 _swigc__p_wxWindowCreateEvent,
48814 _swigc__p_wxWindowDestroyEvent,
48815 _swigc__p_wxXPMHandler,
48816 _swigc__p_wxZipFSHandler,
48817 _swigc__ptrdiff_t,
48818 _swigc__std__ptrdiff_t,
48819 _swigc__unsigned_int,
48820 };
48821
48822
48823 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48824
48825 static swig_const_info swig_const_table[] = {
48826 {0, 0, 0, 0.0, 0, 0}};
48827
48828 #ifdef __cplusplus
48829 }
48830 #endif
48831 /*************************************************************************
48832 * Type initialization:
48833 * This problem is tough by the requirement that no dynamic
48834 * memory is used. Also, since swig_type_info structures store pointers to
48835 * swig_cast_info structures and swig_cast_info structures store pointers back
48836 * to swig_type_info structures, we need some lookup code at initialization.
48837 * The idea is that swig generates all the structures that are needed.
48838 * The runtime then collects these partially filled structures.
48839 * The SWIG_InitializeModule function takes these initial arrays out of
48840 * swig_module, and does all the lookup, filling in the swig_module.types
48841 * array with the correct data and linking the correct swig_cast_info
48842 * structures together.
48843
48844 * The generated swig_type_info structures are assigned staticly to an initial
48845 * array. We just loop though that array, and handle each type individually.
48846 * First we lookup if this type has been already loaded, and if so, use the
48847 * loaded structure instead of the generated one. Then we have to fill in the
48848 * cast linked list. The cast data is initially stored in something like a
48849 * two-dimensional array. Each row corresponds to a type (there are the same
48850 * number of rows as there are in the swig_type_initial array). Each entry in
48851 * a column is one of the swig_cast_info structures for that type.
48852 * The cast_initial array is actually an array of arrays, because each row has
48853 * a variable number of columns. So to actually build the cast linked list,
48854 * we find the array of casts associated with the type, and loop through it
48855 * adding the casts to the list. The one last trick we need to do is making
48856 * sure the type pointer in the swig_cast_info struct is correct.
48857
48858 * First off, we lookup the cast->type name to see if it is already loaded.
48859 * There are three cases to handle:
48860 * 1) If the cast->type has already been loaded AND the type we are adding
48861 * casting info to has not been loaded (it is in this module), THEN we
48862 * replace the cast->type pointer with the type pointer that has already
48863 * been loaded.
48864 * 2) If BOTH types (the one we are adding casting info to, and the
48865 * cast->type) are loaded, THEN the cast info has already been loaded by
48866 * the previous module so we just ignore it.
48867 * 3) Finally, if cast->type has not already been loaded, then we add that
48868 * swig_cast_info to the linked list (because the cast->type) pointer will
48869 * be correct.
48870 **/
48871
48872 #ifdef __cplusplus
48873 extern "C" {
48874 #if 0
48875 } /* c-mode */
48876 #endif
48877 #endif
48878
48879 #if 0
48880 #define SWIGRUNTIME_DEBUG
48881 #endif
48882
48883 SWIGRUNTIME void
48884 SWIG_InitializeModule(void *clientdata) {
48885 size_t i;
48886 swig_module_info *module_head;
48887 static int init_run = 0;
48888
48889 clientdata = clientdata;
48890
48891 if (init_run) return;
48892 init_run = 1;
48893
48894 /* Initialize the swig_module */
48895 swig_module.type_initial = swig_type_initial;
48896 swig_module.cast_initial = swig_cast_initial;
48897
48898 /* Try and load any already created modules */
48899 module_head = SWIG_GetModule(clientdata);
48900 if (module_head) {
48901 swig_module.next = module_head->next;
48902 module_head->next = &swig_module;
48903 } else {
48904 /* This is the first module loaded */
48905 swig_module.next = &swig_module;
48906 SWIG_SetModule(clientdata, &swig_module);
48907 }
48908
48909 /* Now work on filling in swig_module.types */
48910 #ifdef SWIGRUNTIME_DEBUG
48911 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48912 #endif
48913 for (i = 0; i < swig_module.size; ++i) {
48914 swig_type_info *type = 0;
48915 swig_type_info *ret;
48916 swig_cast_info *cast;
48917
48918 #ifdef SWIGRUNTIME_DEBUG
48919 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48920 #endif
48921
48922 /* if there is another module already loaded */
48923 if (swig_module.next != &swig_module) {
48924 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48925 }
48926 if (type) {
48927 /* Overwrite clientdata field */
48928 #ifdef SWIGRUNTIME_DEBUG
48929 printf("SWIG_InitializeModule: found type %s\n", type->name);
48930 #endif
48931 if (swig_module.type_initial[i]->clientdata) {
48932 type->clientdata = swig_module.type_initial[i]->clientdata;
48933 #ifdef SWIGRUNTIME_DEBUG
48934 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48935 #endif
48936 }
48937 } else {
48938 type = swig_module.type_initial[i];
48939 }
48940
48941 /* Insert casting types */
48942 cast = swig_module.cast_initial[i];
48943 while (cast->type) {
48944 /* Don't need to add information already in the list */
48945 ret = 0;
48946 #ifdef SWIGRUNTIME_DEBUG
48947 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48948 #endif
48949 if (swig_module.next != &swig_module) {
48950 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48951 #ifdef SWIGRUNTIME_DEBUG
48952 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48953 #endif
48954 }
48955 if (ret) {
48956 if (type == swig_module.type_initial[i]) {
48957 #ifdef SWIGRUNTIME_DEBUG
48958 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48959 #endif
48960 cast->type = ret;
48961 ret = 0;
48962 } else {
48963 /* Check for casting already in the list */
48964 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48965 #ifdef SWIGRUNTIME_DEBUG
48966 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48967 #endif
48968 if (!ocast) ret = 0;
48969 }
48970 }
48971
48972 if (!ret) {
48973 #ifdef SWIGRUNTIME_DEBUG
48974 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48975 #endif
48976 if (type->cast) {
48977 type->cast->prev = cast;
48978 cast->next = type->cast;
48979 }
48980 type->cast = cast;
48981 }
48982 cast++;
48983 }
48984 /* Set entry in modules->types array equal to the type */
48985 swig_module.types[i] = type;
48986 }
48987 swig_module.types[i] = 0;
48988
48989 #ifdef SWIGRUNTIME_DEBUG
48990 printf("**** SWIG_InitializeModule: Cast List ******\n");
48991 for (i = 0; i < swig_module.size; ++i) {
48992 int j = 0;
48993 swig_cast_info *cast = swig_module.cast_initial[i];
48994 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48995 while (cast->type) {
48996 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48997 cast++;
48998 ++j;
48999 }
49000 printf("---- Total casts: %d\n",j);
49001 }
49002 printf("**** SWIG_InitializeModule: Cast List ******\n");
49003 #endif
49004 }
49005
49006 /* This function will propagate the clientdata field of type to
49007 * any new swig_type_info structures that have been added into the list
49008 * of equivalent types. It is like calling
49009 * SWIG_TypeClientData(type, clientdata) a second time.
49010 */
49011 SWIGRUNTIME void
49012 SWIG_PropagateClientData(void) {
49013 size_t i;
49014 swig_cast_info *equiv;
49015 static int init_run = 0;
49016
49017 if (init_run) return;
49018 init_run = 1;
49019
49020 for (i = 0; i < swig_module.size; i++) {
49021 if (swig_module.types[i]->clientdata) {
49022 equiv = swig_module.types[i]->cast;
49023 while (equiv) {
49024 if (!equiv->converter) {
49025 if (equiv->type && !equiv->type->clientdata)
49026 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
49027 }
49028 equiv = equiv->next;
49029 }
49030 }
49031 }
49032 }
49033
49034 #ifdef __cplusplus
49035 #if 0
49036 {
49037 /* c-mode */
49038 #endif
49039 }
49040 #endif
49041
49042
49043
49044 #ifdef __cplusplus
49045 extern "C" {
49046 #endif
49047
49048 /* Python-specific SWIG API */
49049 #define SWIG_newvarlink() SWIG_Python_newvarlink()
49050 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
49051 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
49052
49053 /* -----------------------------------------------------------------------------
49054 * global variable support code.
49055 * ----------------------------------------------------------------------------- */
49056
49057 typedef struct swig_globalvar {
49058 char *name; /* Name of global variable */
49059 PyObject *(*get_attr)(void); /* Return the current value */
49060 int (*set_attr)(PyObject *); /* Set the value */
49061 struct swig_globalvar *next;
49062 } swig_globalvar;
49063
49064 typedef struct swig_varlinkobject {
49065 PyObject_HEAD
49066 swig_globalvar *vars;
49067 } swig_varlinkobject;
49068
49069 SWIGINTERN PyObject *
49070 swig_varlink_repr(swig_varlinkobject *v) {
49071 v = v;
49072 return PyString_FromString("<Swig global variables>");
49073 }
49074
49075 SWIGINTERN int
49076 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
49077 swig_globalvar *var;
49078 flags = flags;
49079 fprintf(fp,"Swig global variables { ");
49080 for (var = v->vars; var; var=var->next) {
49081 fprintf(fp,"%s", var->name);
49082 if (var->next) fprintf(fp,", ");
49083 }
49084 fprintf(fp," }\n");
49085 return 0;
49086 }
49087
49088 SWIGINTERN PyObject *
49089 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
49090 swig_globalvar *var = v->vars;
49091 while (var) {
49092 if (strcmp(var->name,n) == 0) {
49093 return (*var->get_attr)();
49094 }
49095 var = var->next;
49096 }
49097 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
49098 return NULL;
49099 }
49100
49101 SWIGINTERN int
49102 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
49103 swig_globalvar *var = v->vars;
49104 while (var) {
49105 if (strcmp(var->name,n) == 0) {
49106 return (*var->set_attr)(p);
49107 }
49108 var = var->next;
49109 }
49110 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
49111 return 1;
49112 }
49113
49114 SWIGINTERN PyTypeObject*
49115 swig_varlink_type(void) {
49116 static char varlink__doc__[] = "Swig var link object";
49117 static PyTypeObject varlink_type
49118 #if !defined(__cplusplus)
49119 ;
49120 static int type_init = 0;
49121 if (!type_init) {
49122 PyTypeObject tmp
49123 #endif
49124 = {
49125 PyObject_HEAD_INIT(&PyType_Type)
49126 0, /* Number of items in variable part (ob_size) */
49127 (char *)"swigvarlink", /* Type name (tp_name) */
49128 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
49129 0, /* Itemsize (tp_itemsize) */
49130 0, /* Deallocator (tp_dealloc) */
49131 (printfunc) swig_varlink_print, /* Print (tp_print) */
49132 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
49133 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
49134 0, /* tp_compare */
49135 (reprfunc) swig_varlink_repr, /* tp_repr */
49136 0, /* tp_as_number */
49137 0, /* tp_as_sequence */
49138 0, /* tp_as_mapping */
49139 0, /* tp_hash */
49140 0, /* tp_call */
49141 0, /* tp_str */
49142 0, /* tp_getattro */
49143 0, /* tp_setattro */
49144 0, /* tp_as_buffer */
49145 0, /* tp_flags */
49146 varlink__doc__, /* tp_doc */
49147 #if PY_VERSION_HEX >= 0x02000000
49148 0, /* tp_traverse */
49149 0, /* tp_clear */
49150 #endif
49151 #if PY_VERSION_HEX >= 0x02010000
49152 0, /* tp_richcompare */
49153 0, /* tp_weaklistoffset */
49154 #endif
49155 #if PY_VERSION_HEX >= 0x02020000
49156 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
49157 #endif
49158 #if PY_VERSION_HEX >= 0x02030000
49159 0, /* tp_del */
49160 #endif
49161 #ifdef COUNT_ALLOCS
49162 0,0,0,0 /* tp_alloc -> tp_next */
49163 #endif
49164 };
49165 #if !defined(__cplusplus)
49166 varlink_type = tmp;
49167 type_init = 1;
49168 }
49169 #endif
49170 return &varlink_type;
49171 }
49172
49173 /* Create a variable linking object for use later */
49174 SWIGINTERN PyObject *
49175 SWIG_Python_newvarlink(void) {
49176 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
49177 if (result) {
49178 result->vars = 0;
49179 }
49180 return ((PyObject*) result);
49181 }
49182
49183 SWIGINTERN void
49184 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
49185 swig_varlinkobject *v = (swig_varlinkobject *) p;
49186 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
49187 if (gv) {
49188 size_t size = strlen(name)+1;
49189 gv->name = (char *)malloc(size);
49190 if (gv->name) {
49191 strncpy(gv->name,name,size);
49192 gv->get_attr = get_attr;
49193 gv->set_attr = set_attr;
49194 gv->next = v->vars;
49195 }
49196 }
49197 v->vars = gv;
49198 }
49199
49200 /* -----------------------------------------------------------------------------
49201 * constants/methods manipulation
49202 * ----------------------------------------------------------------------------- */
49203
49204 /* Install Constants */
49205 SWIGINTERN void
49206 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
49207 PyObject *obj = 0;
49208 size_t i;
49209 for (i = 0; constants[i].type; ++i) {
49210 switch(constants[i].type) {
49211 case SWIG_PY_INT:
49212 obj = PyInt_FromLong(constants[i].lvalue);
49213 break;
49214 case SWIG_PY_FLOAT:
49215 obj = PyFloat_FromDouble(constants[i].dvalue);
49216 break;
49217 case SWIG_PY_STRING:
49218 if (constants[i].pvalue) {
49219 obj = PyString_FromString((char *) constants[i].pvalue);
49220 } else {
49221 Py_INCREF(Py_None);
49222 obj = Py_None;
49223 }
49224 break;
49225 case SWIG_PY_POINTER:
49226 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
49227 break;
49228 case SWIG_PY_BINARY:
49229 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
49230 break;
49231 default:
49232 obj = 0;
49233 break;
49234 }
49235 if (obj) {
49236 PyDict_SetItemString(d,constants[i].name,obj);
49237 Py_DECREF(obj);
49238 }
49239 }
49240 }
49241
49242 /* -----------------------------------------------------------------------------*/
49243 /* Fix SwigMethods to carry the callback ptrs when needed */
49244 /* -----------------------------------------------------------------------------*/
49245
49246 SWIGINTERN void
49247 SWIG_Python_FixMethods(PyMethodDef *methods,
49248 swig_const_info *const_table,
49249 swig_type_info **types,
49250 swig_type_info **types_initial) {
49251 size_t i;
49252 for (i = 0; methods[i].ml_name; ++i) {
49253 char *c = methods[i].ml_doc;
49254 if (c && (c = strstr(c, "swig_ptr: "))) {
49255 int j;
49256 swig_const_info *ci = 0;
49257 char *name = c + 10;
49258 for (j = 0; const_table[j].type; ++j) {
49259 if (strncmp(const_table[j].name, name,
49260 strlen(const_table[j].name)) == 0) {
49261 ci = &(const_table[j]);
49262 break;
49263 }
49264 }
49265 if (ci) {
49266 size_t shift = (ci->ptype) - types;
49267 swig_type_info *ty = types_initial[shift];
49268 size_t ldoc = (c - methods[i].ml_doc);
49269 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49270 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49271 if (ndoc) {
49272 char *buff = ndoc;
49273 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49274 if (ptr) {
49275 strncpy(buff, methods[i].ml_doc, ldoc);
49276 buff += ldoc;
49277 strncpy(buff, "swig_ptr: ", 10);
49278 buff += 10;
49279 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49280 methods[i].ml_doc = ndoc;
49281 }
49282 }
49283 }
49284 }
49285 }
49286 }
49287
49288 /* -----------------------------------------------------------------------------*
49289 * Initialize type list
49290 * -----------------------------------------------------------------------------*/
49291
49292 #ifdef __cplusplus
49293 }
49294 #endif
49295
49296 /* -----------------------------------------------------------------------------*
49297 * Partial Init method
49298 * -----------------------------------------------------------------------------*/
49299
49300 #ifdef __cplusplus
49301 extern "C"
49302 #endif
49303 SWIGEXPORT void SWIG_init(void) {
49304 static PyObject *SWIG_globals = 0;
49305 PyObject *m, *d;
49306 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49307
49308 /* Fix SwigMethods to carry the callback ptrs when needed */
49309 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49310
49311 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49312 d = PyModule_GetDict(m);
49313
49314 SWIG_InitializeModule(0);
49315 SWIG_InstallConstants(d,swig_const_table);
49316
49317
49318 #ifndef wxPyUSE_EXPORT
49319 // Make our API structure a CObject so other modules can import it
49320 // from this module.
49321 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49322 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49323 Py_XDECREF(cobj);
49324 #endif
49325
49326 {
49327 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49568 }
49569 {
49570 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49574 }
49575 {
49576 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49637 }
49638 {
49639 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49649 }
49650 {
49651 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49652 }
49653 {
49654 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49655 }
49656 {
49657 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49658 }
49659 {
49660 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49661 }
49662 {
49663 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49664 }
49665 {
49666 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49667 }
49668 {
49669 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49670 }
49671 {
49672 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49673 }
49674 {
49675 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49679 }
49680 {
49681 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49682 }
49683 {
49684 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49685 }
49686 {
49687 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49688 }
49689 {
49690 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49691 }
49692 {
49693 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49706 }
49707 {
49708 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49709 }
49710 {
49711 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49712 }
49713 {
49714 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49715 }
49716 {
49717 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49718 }
49719 {
49720 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49745 }
49746 {
49747 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49748 }
49749 {
49750 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49751 }
49752 {
49753 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49754 }
49755 {
49756 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49757 }
49758 {
49759 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49760 }
49761 {
49762 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49763 }
49764 {
49765 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49766 }
49767 {
49768 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49769 }
49770 {
49771 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49772 }
49773 {
49774 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49775 }
49776 {
49777 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49778 }
49779 {
49780 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49781 }
49782 {
49783 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49784 }
49785 {
49786 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49787 }
49788 {
49789 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49790 }
49791 {
49792 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49793 }
49794 {
49795 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49796 }
49797 {
49798 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49799 }
49800 {
49801 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49835 }
49836 {
49837 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49850 }
49851 {
49852 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49853 }
49854 {
49855 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49856 }
49857 {
49858 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49859 }
49860 {
49861 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49862 }
49863 {
49864 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49865 }
49866 {
49867 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49868 }
49869 {
49870 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49871 }
49872 {
49873 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49874 }
49875 {
49876 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49877 }
49878 {
49879 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49880 }
49881 {
49882 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49883 }
49884 {
49885 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49886 }
49887 {
49888 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49889 }
49890 {
49891 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49904 }
49905 {
49906 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49907 }
49908 {
49909 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49910 }
49911 {
49912 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49913 }
49914 {
49915 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49916 }
49917 {
49918 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49919 }
49920 {
49921 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49922 }
49923 {
49924 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49925 }
49926 {
49927 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49934 }
49935 {
49936 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49937 }
49938 {
49939 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49940 }
49941 {
49942 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49943 }
49944 {
49945 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49946 }
49947 {
49948 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49949 }
49950 {
49951 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49952 }
49953 {
49954 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49955 }
49956 {
49957 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49958 }
49959 {
49960 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49961 }
49962 {
49963 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49964 }
49965 {
49966 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49967 }
49968 {
49969 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49970 }
49971 {
49972 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49973 }
49974 {
49975 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49976 }
49977 {
49978 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49979 }
49980 {
49981 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49982 }
49983 {
49984 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49985 }
49986 {
49987 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49988 }
49989 {
49990 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49991 }
49992 {
49993 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49994 }
49995 {
49996 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49997 }
49998 {
49999 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
50000 }
50001 {
50002 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
50003 }
50004 {
50005 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
50006 }
50007 {
50008 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
50009 }
50010 {
50011 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
50012 }
50013 {
50014 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
50015 }
50016 {
50017 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
50018 }
50019 {
50020 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
50021 }
50022 {
50023 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
50024 }
50025 {
50026 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
50027 }
50028 {
50029 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
50030 }
50031 {
50032 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
50033 }
50034 {
50035 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
50036 }
50037 {
50038 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
50039 }
50040 {
50041 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
50042 }
50043 {
50044 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
50045 }
50046 {
50047 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
50048 }
50049 {
50050 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
50051 }
50052 {
50053 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
50054 }
50055 {
50056 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
50057 }
50058 {
50059 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
50060 }
50061 {
50062 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
50063 }
50064 {
50065 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
50066 }
50067 {
50068 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
50069 }
50070 {
50071 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
50072 }
50073 {
50074 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
50075 }
50076 {
50077 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
50078 }
50079 {
50080 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
50081 }
50082 {
50083 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
50084 }
50085 {
50086 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
50087 }
50088 {
50089 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
50090 }
50091 {
50092 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
50093 }
50094 {
50095 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
50096 }
50097 {
50098 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
50099 }
50100 {
50101 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
50102 }
50103 {
50104 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
50105 }
50106 {
50107 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
50108 }
50109 {
50110 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
50111 }
50112 {
50113 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
50114 }
50115 {
50116 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
50117 }
50118 {
50119 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
50120 }
50121 {
50122 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
50123 }
50124 {
50125 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
50126 }
50127 {
50128 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
50129 }
50130 {
50131 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
50132 }
50133 {
50134 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
50135 }
50136 {
50137 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
50138 }
50139 {
50140 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
50141 }
50142 {
50143 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
50144 }
50145 {
50146 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
50147 }
50148 {
50149 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
50150 }
50151 {
50152 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
50153 }
50154 {
50155 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
50156 }
50157 {
50158 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
50159 }
50160 {
50161 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
50162 }
50163 {
50164 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
50165 }
50166 {
50167 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
50168 }
50169 {
50170 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
50171 }
50172 {
50173 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
50174 }
50175 {
50176 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
50177 }
50178 {
50179 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
50180 }
50181 {
50182 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
50183 }
50184 {
50185 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
50186 }
50187 {
50188 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
50189 }
50190 {
50191 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
50192 }
50193 {
50194 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
50195 }
50196 {
50197 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
50198 }
50199 {
50200 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
50201 }
50202 {
50203 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
50204 }
50205 {
50206 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
50207 }
50208 {
50209 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
50210 }
50211 {
50212 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
50213 }
50214 {
50215 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
50216 }
50217 {
50218 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
50219 }
50220 {
50221 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
50222 }
50223 {
50224 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
50225 }
50226 {
50227 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
50228 }
50229 {
50230 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
50231 }
50232 {
50233 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
50234 }
50235 {
50236 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
50237 }
50238 {
50239 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
50240 }
50241 {
50242 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
50243 }
50244 {
50245 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
50246 }
50247 {
50248 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
50249 }
50250 {
50251 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
50252 }
50253 {
50254 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50255 }
50256 {
50257 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50258 }
50259 {
50260 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50261 }
50262 {
50263 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50264 }
50265 {
50266 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50267 }
50268 {
50269 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50270 }
50271 {
50272 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50273 }
50274 {
50275 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50276 }
50277 {
50278 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50279 }
50280 {
50281 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50282 }
50283 {
50284 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50285 }
50286 {
50287 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50288 }
50289 {
50290 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50291 }
50292 {
50293 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50294 }
50295 {
50296 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50297 }
50298 {
50299 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50300 }
50301 {
50302 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50303 }
50304 {
50305 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50306 }
50307 {
50308 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50309 }
50310 {
50311 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50312 }
50313 {
50314 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50315 }
50316 {
50317 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50318 }
50319 {
50320 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50321 }
50322 {
50323 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50324 }
50325 {
50326 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50327 }
50328 {
50329 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50330 }
50331 {
50332 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50333 }
50334 {
50335 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50336 }
50337 {
50338 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50339 }
50340 {
50341 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50342 }
50343 {
50344 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50345 }
50346 {
50347 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50348 }
50349 {
50350 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50351 }
50352 {
50353 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50354 }
50355 {
50356 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50357 }
50358 {
50359 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50360 }
50361 {
50362 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50363 }
50364 {
50365 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50366 }
50367 {
50368 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50369 }
50370 {
50371 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50372 }
50373 {
50374 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50375 }
50376 {
50377 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50378 }
50379 {
50380 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50381 }
50382 {
50383 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50384 }
50385 {
50386 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50387 }
50388 {
50389 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50390 }
50391 {
50392 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50393 }
50394 {
50395 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50396 }
50397 {
50398 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50399 }
50400 {
50401 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50402 }
50403 {
50404 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50405 }
50406 {
50407 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50408 }
50409 {
50410 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50411 }
50412 {
50413 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50414 }
50415 {
50416 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50417 }
50418 {
50419 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50420 }
50421 {
50422 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50423 }
50424 {
50425 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50426 }
50427 {
50428 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50429 }
50430 {
50431 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50432 }
50433 {
50434 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50435 }
50436 {
50437 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50438 }
50439 {
50440 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50441 }
50442 {
50443 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50444 }
50445 {
50446 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50447 }
50448 {
50449 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50450 }
50451 {
50452 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50453 }
50454 {
50455 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50456 }
50457 {
50458 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50459 }
50460 {
50461 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50462 }
50463 {
50464 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50465 }
50466 {
50467 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50468 }
50469 {
50470 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50471 }
50472 {
50473 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50474 }
50475 {
50476 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50477 }
50478 {
50479 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50480 }
50481 {
50482 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50483 }
50484 {
50485 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50486 }
50487 {
50488 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50489 }
50490 {
50491 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50492 }
50493 {
50494 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50495 }
50496 {
50497 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50498 }
50499 {
50500 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50501 }
50502 {
50503 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50504 }
50505 {
50506 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50507 }
50508 {
50509 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50510 }
50511 {
50512 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50513 }
50514 {
50515 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50516 }
50517 {
50518 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50519 }
50520 {
50521 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50522 }
50523 {
50524 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50525 }
50526 {
50527 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50528 }
50529 {
50530 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50531 }
50532 {
50533 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50534 }
50535 {
50536 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50537 }
50538 {
50539 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50540 }
50541 {
50542 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50543 }
50544 {
50545 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50546 }
50547 {
50548 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50549 }
50550 {
50551 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50552 }
50553 {
50554 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50555 }
50556 {
50557 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50558 }
50559 {
50560 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50561 }
50562 {
50563 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50564 }
50565 {
50566 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50567 }
50568 {
50569 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50570 }
50571 {
50572 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50573 }
50574 {
50575 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50576 }
50577 {
50578 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50579 }
50580 {
50581 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50582 }
50583 {
50584 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50585 }
50586 {
50587 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50588 }
50589 {
50590 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50591 }
50592 {
50593 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50594 }
50595 {
50596 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50597 }
50598 {
50599 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50600 }
50601 {
50602 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50603 }
50604 {
50605 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50606 }
50607 {
50608 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50609 }
50610 {
50611 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50612 }
50613 {
50614 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50615 }
50616 {
50617 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50618 }
50619 {
50620 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50621 }
50622 {
50623 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50624 }
50625 {
50626 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50627 }
50628 {
50629 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50630 }
50631 {
50632 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50633 }
50634 {
50635 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50636 }
50637 {
50638 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50639 }
50640 {
50641 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50642 }
50643 {
50644 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50645 }
50646 {
50647 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50648 }
50649 {
50650 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50651 }
50652 {
50653 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50654 }
50655 {
50656 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50657 }
50658 {
50659 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50660 }
50661 {
50662 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50663 }
50664 {
50665 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50666 }
50667 {
50668 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50669 }
50670 {
50671 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50672 }
50673 {
50674 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50675 }
50676 {
50677 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50678 }
50679 {
50680 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50681 }
50682 {
50683 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50684 }
50685 {
50686 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50687 }
50688 {
50689 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50690 }
50691 {
50692 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50693 }
50694 {
50695 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50696 }
50697 {
50698 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50699 }
50700 {
50701 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50702 }
50703 {
50704 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50705 }
50706 {
50707 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50708 }
50709 {
50710 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50711 }
50712 {
50713 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50714 }
50715 {
50716 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50717 }
50718 {
50719 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50720 }
50721 {
50722 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50723 }
50724 {
50725 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50726 }
50727 {
50728 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50729 }
50730 {
50731 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50732 }
50733 {
50734 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50735 }
50736 {
50737 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50738 }
50739 {
50740 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50741 }
50742 {
50743 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50744 }
50745 {
50746 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50747 }
50748 {
50749 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50750 }
50751 {
50752 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50753 }
50754 {
50755 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50756 }
50757 {
50758 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50759 }
50760 {
50761 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50762 }
50763 {
50764 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50765 }
50766 {
50767 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50768 }
50769 {
50770 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50771 }
50772 {
50773 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50774 }
50775 {
50776 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50777 }
50778 {
50779 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50780 }
50781 {
50782 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50783 }
50784 {
50785 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50786 }
50787 {
50788 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50789 }
50790 {
50791 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50792 }
50793 {
50794 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50795 }
50796 {
50797 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50798 }
50799 {
50800 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50801 }
50802 {
50803 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50804 }
50805 {
50806 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50807 }
50808 {
50809 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50810 }
50811 {
50812 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50813 }
50814 {
50815 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50816 }
50817 {
50818 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50819 }
50820 {
50821 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50822 }
50823 {
50824 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50825 }
50826 {
50827 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50828 }
50829 {
50830 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50831 }
50832 {
50833 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50834 }
50835 {
50836 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50837 }
50838 {
50839 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50840 }
50841 {
50842 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50843 }
50844 {
50845 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50846 }
50847 {
50848 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50849 }
50850 {
50851 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50852 }
50853 {
50854 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50855 }
50856 {
50857 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50858 }
50859 {
50860 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50861 }
50862 {
50863 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50864 }
50865 {
50866 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50867 }
50868 {
50869 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50870 }
50871 {
50872 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50873 }
50874 {
50875 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50876 }
50877 {
50878 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50879 }
50880 {
50881 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50882 }
50883 {
50884 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50885 }
50886 {
50887 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50888 }
50889 {
50890 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50891 }
50892 {
50893 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50894 }
50895 {
50896 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50897 }
50898 {
50899 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50900 }
50901 {
50902 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50903 }
50904 {
50905 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50906 }
50907 {
50908 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50909 }
50910 {
50911 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50912 }
50913 {
50914 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50915 }
50916 {
50917 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50918 }
50919 {
50920 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50921 }
50922 {
50923 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50924 }
50925 {
50926 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50927 }
50928 {
50929 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50930 }
50931 {
50932 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50933 }
50934 {
50935 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50936 }
50937 {
50938 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50939 }
50940 {
50941 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50942 }
50943 {
50944 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50945 }
50946 {
50947 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50948 }
50949 {
50950 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50951 }
50952 {
50953 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50954 }
50955 {
50956 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50957 }
50958 {
50959 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50960 }
50961 {
50962 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50963 }
50964 {
50965 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50966 }
50967 {
50968 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50969 }
50970 {
50971 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50972 }
50973 {
50974 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50975 }
50976 {
50977 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50978 }
50979 {
50980 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50981 }
50982 {
50983 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50984 }
50985 {
50986 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50987 }
50988 {
50989 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50990 }
50991 {
50992 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50993 }
50994 {
50995 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50996 }
50997 {
50998 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50999 }
51000 {
51001 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
51002 }
51003 {
51004 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
51005 }
51006 {
51007 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
51008 }
51009 {
51010 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
51011 }
51012 {
51013 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
51014 }
51015 {
51016 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
51017 }
51018 {
51019 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
51020 }
51021 {
51022 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
51023 }
51024 {
51025 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
51026 }
51027 {
51028 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
51029 }
51030 {
51031 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
51032 }
51033 {
51034 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
51035 }
51036 {
51037 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
51038 }
51039 {
51040 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
51041 }
51042 {
51043 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
51044 }
51045 {
51046 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
51047 }
51048 {
51049 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
51050 }
51051 {
51052 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
51053 }
51054 {
51055 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
51056 }
51057 {
51058 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
51059 }
51060 {
51061 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
51062 }
51063 {
51064 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
51065 }
51066 {
51067 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
51068 }
51069 {
51070 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
51071 }
51072 {
51073 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
51074 }
51075 {
51076 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
51077 }
51078 {
51079 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
51080 }
51081 {
51082 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
51083 }
51084 {
51085 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
51086 }
51087 {
51088 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
51089 }
51090 {
51091 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
51092 }
51093 {
51094 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
51095 }
51096 {
51097 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
51098 }
51099 {
51100 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
51101 }
51102 {
51103 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
51104 }
51105 {
51106 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
51107 }
51108 {
51109 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
51110 }
51111 {
51112 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
51113 }
51114 {
51115 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
51116 }
51117 {
51118 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
51119 }
51120 {
51121 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
51122 }
51123 {
51124 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
51125 }
51126 {
51127 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
51128 }
51129 {
51130 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
51131 }
51132 {
51133 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
51134 }
51135 {
51136 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
51137 }
51138 {
51139 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
51140 }
51141 {
51142 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
51143 }
51144 {
51145 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
51146 }
51147 {
51148 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
51149 }
51150 {
51151 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
51152 }
51153 {
51154 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
51155 }
51156 {
51157 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
51158 }
51159 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
51160 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
51161 {
51162 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
51163 }
51164 {
51165 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
51166 }
51167 {
51168 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
51169 }
51170 {
51171 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
51172 }
51173 {
51174 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
51175 }
51176 {
51177 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
51178 }
51179 {
51180 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
51181 }
51182 {
51183 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
51184 }
51185 {
51186 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
51187 }
51188 {
51189 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
51190 }
51191 {
51192 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
51193 }
51194 {
51195 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
51196 }
51197 {
51198 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
51199 }
51200 {
51201 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
51202 }
51203 {
51204 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
51205 }
51206 {
51207 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
51208 }
51209 {
51210 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
51211 }
51212 {
51213 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
51214 }
51215 {
51216 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
51217 }
51218 {
51219 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
51220 }
51221 {
51222 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
51223 }
51224 {
51225 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
51226 }
51227 {
51228 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
51229 }
51230 {
51231 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
51232 }
51233 {
51234 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
51235 }
51236 {
51237 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
51238 }
51239 {
51240 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
51241 }
51242 {
51243 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
51244 }
51245 {
51246 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
51247 }
51248 {
51249 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
51250 }
51251 {
51252 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
51253 }
51254 {
51255 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51256 }
51257 {
51258 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51259 }
51260 {
51261 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51262 }
51263 {
51264 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51265 }
51266 {
51267 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51268 }
51269 {
51270 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51271 }
51272 {
51273 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51274 }
51275 {
51276 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51277 }
51278 {
51279 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51280 }
51281 {
51282 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51283 }
51284 {
51285 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51286 }
51287 {
51288 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51289 }
51290 {
51291 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51292 }
51293 {
51294 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51295 }
51296 {
51297 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51298 }
51299 {
51300 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51301 }
51302 {
51303 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51304 }
51305 {
51306 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51307 }
51308 {
51309 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51310 }
51311 {
51312 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51313 }
51314 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51315 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51316 {
51317 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51318 }
51319 {
51320 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51321 }
51322 {
51323 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51324 }
51325
51326 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51327
51328
51329 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51330
51331 {
51332 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51333 }
51334 {
51335 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51336 }
51337 {
51338 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51339 }
51340 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51341 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51342 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51343 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51344 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51345 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51346 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51347 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51348 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51349 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51350 {
51351 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51352 }
51353 {
51354 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51355 }
51356 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51357 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51358 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51359 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51360 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51361 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51362 {
51363 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51364 }
51365 {
51366 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51367 }
51368 {
51369 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51370 }
51371 {
51372 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51373 }
51374 {
51375 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51376 }
51377 {
51378 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51379 }
51380 {
51381 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51382 }
51383 {
51384 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51385 }
51386 {
51387 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51388 }
51389 {
51390 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51391 }
51392 {
51393 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51394 }
51395 {
51396 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51397 }
51398 {
51399 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51400 }
51401 {
51402 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51403 }
51404 {
51405 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51406 }
51407 {
51408 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51409 }
51410 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51411 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51412 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51413 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51414 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51415 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51416 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51417 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51418 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51419 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51420 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51421 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51422 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51423 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51424 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51425 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51426 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51427 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51428 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51429 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51430 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51431 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51432 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51433 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51434 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51435 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51436 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51437 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51438 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51439 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51440 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51441 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51442 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51443 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51444 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51445 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51446 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51447 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51448 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51449 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51450 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51451 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51452 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51453 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51454 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51455 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51456 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51457 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51458 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51459 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51460 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51461 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51462 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51463 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51464 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51465 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51466 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51467 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51468 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51469 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51470 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51471 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51472 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51473 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51474 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51475 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51476 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51477 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51478 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51479 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51480 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51481 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51482 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51483 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51484 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51485 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51486 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51487 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51488 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51489 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51490 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51491 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51492 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51493 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51494 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51495 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51496 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51497 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51498 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51499 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51500 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51501 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51502 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51503 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51504 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51505 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51506 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51507 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51508 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51509 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51510 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51511 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51512 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51513 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51514 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51515 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51516 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51517 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51518 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51519 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51520 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51521 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51522 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51523 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51524 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51525 {
51526 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51527 }
51528 {
51529 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51530 }
51531 {
51532 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51533 }
51534 {
51535 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51536 }
51537 {
51538 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51539 }
51540 {
51541 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51542 }
51543 {
51544 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51545 }
51546 {
51547 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51548 }
51549 {
51550 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51551 }
51552 {
51553 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51554 }
51555 {
51556 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51557 }
51558 {
51559 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51560 }
51561 {
51562 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51563 }
51564 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51565 {
51566 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51567 }
51568 {
51569 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51570 }
51571 {
51572 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51573 }
51574 {
51575 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51576 }
51577 {
51578 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51579 }
51580 {
51581 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51582 }
51583 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51584 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51585 {
51586 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51587 }
51588 {
51589 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51590 }
51591 {
51592 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51593 }
51594 {
51595 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51596 }
51597 {
51598 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51599 }
51600 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51601 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51602 {
51603 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51604 }
51605 {
51606 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51607 }
51608 {
51609 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51610 }
51611 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51612 {
51613 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51614 }
51615 {
51616 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51617 }
51618 {
51619 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51620 }
51621 {
51622 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51623 }
51624 {
51625 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51626 }
51627 {
51628 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51629 }
51630 {
51631 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51632 }
51633 {
51634 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51635 }
51636 {
51637 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51638 }
51639 {
51640 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51641 }
51642 {
51643 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51644 }
51645 {
51646 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51647 }
51648 {
51649 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51650 }
51651 {
51652 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51653 }
51654 {
51655 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51656 }
51657 {
51658 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51659 }
51660 {
51661 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51662 }
51663 {
51664 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51665 }
51666 {
51667 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51668 }
51669
51670 // Initialize threading, some globals and such
51671 __wxPyPreStart(d);
51672
51673
51674 // Although these are defined in __version__ they need to be here too so
51675 // that an assert can be done to ensure that the wxPython and the wxWindows
51676 // versions match.
51677 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51678 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51679 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51680
51681 }
51682
wxWidgets (Impactor)