projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixed WX_DEFINE_SORTED_ARRAY_INT example
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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 // Make a SWIGified pointer object suitable for a .this attribute
1671 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1672
1673 PyObject* robj = NULL;
1674
1675 swig_type_info* swigType = wxPyFindSwigType(className);
1676 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1677
1678 #ifdef SWIG_COBJECT_TYPES
1679 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1680 #else
1681 {
1682 char result[1024];
1683 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1684 PyString_FromString(result) : 0;
1685 }
1686 #endif
1687
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
1701 // This one checks if the object is an instance of a SWIG proxy class (it has
1702 // a .this attribute, and the .this attribute is a PySwigObject.)
1703 bool wxPySwigInstance_Check(PyObject* obj) {
1704 static PyObject* this_str = NULL;
1705 if (this_str == NULL)
1706 this_str = PyString_FromString("this");
1707
1708 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1709 if (this_attr) {
1710 bool retval = (PySwigObject_Check(this_attr) != 0);
1711 Py_DECREF(this_attr);
1712 return retval;
1713 }
1714
1715 PyErr_Clear();
1716 return false;
1717 }
1718
1719
1720
1721 // Export a C API in a struct. Other modules will be able to load this from
1722 // the wx._core_ module and will then have safe access to these functions,
1723 // even if they are located in another shared library.
1724 static wxPyCoreAPI API = {
1725
1726 wxPyCheckSwigType,
1727 wxPyConstructObject,
1728 wxPyConvertSwigPtr,
1729 wxPyMakeSwigPtr,
1730
1731 wxPyBeginAllowThreads,
1732 wxPyEndAllowThreads,
1733 wxPyBeginBlockThreads,
1734 wxPyEndBlockThreads,
1735
1736 wxPy_ConvertList,
1737
1738 wxString_in_helper,
1739 Py2wxString,
1740 wx2PyString,
1741
1742 byte_LIST_helper,
1743 int_LIST_helper,
1744 long_LIST_helper,
1745 string_LIST_helper,
1746 wxPoint_LIST_helper,
1747 wxBitmap_LIST_helper,
1748 wxString_LIST_helper,
1749 wxAcceleratorEntry_LIST_helper,
1750
1751 wxSize_helper,
1752 wxPoint_helper,
1753 wxRealPoint_helper,
1754 wxRect_helper,
1755 wxColour_helper,
1756 wxPoint2D_helper,
1757
1758 wxPySimple_typecheck,
1759 wxColour_typecheck,
1760
1761 wxPyCBH_setCallbackInfo,
1762 wxPyCBH_findCallback,
1763 wxPyCBH_callCallback,
1764 wxPyCBH_callCallbackObj,
1765 wxPyCBH_delete,
1766
1767 wxPyMake_wxObject,
1768 wxPyMake_wxSizer,
1769 wxPyPtrTypeMap_Add,
1770 wxPy2int_seq_helper,
1771 wxPy4int_seq_helper,
1772 wxArrayString2PyList_helper,
1773 wxArrayInt2PyList_helper,
1774
1775 wxPyClientData_dtor,
1776 wxPyUserData_dtor,
1777 wxPyOORClientData_dtor,
1778
1779 wxPyCBInputStream_create,
1780 wxPyCBInputStream_copy,
1781
1782 wxPyInstance_Check,
1783 wxPySwigInstance_Check,
1784
1785 wxPyCheckForApp
1786
1787 };
1788
1789 #endif
1790
1791
1792 #if !WXWIN_COMPATIBILITY_2_4
1793 #define wxHIDE_READONLY 0
1794 #endif
1795
1796
1797 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1798 #define SWIG_From_int PyInt_FromLong
1799 /*@@*/
1800
1801 static const wxString wxPyEmptyString(wxEmptyString);
1802 static wxString wxObject_GetClassName(wxObject *self){
1803 return self->GetClassInfo()->GetClassName();
1804 }
1805 static void wxObject_Destroy(wxObject *self){
1806 delete self;
1807 }
1808
1809 #ifndef __WXMAC__
1810 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1811 #endif
1812
1813
1814 #include <limits.h>
1815
1816
1817 SWIGINTERN int
1818 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1819 const char *errmsg)
1820 {
1821 if (value < min_value) {
1822 if (errmsg) {
1823 PyErr_Format(PyExc_OverflowError,
1824 "value %ld is less than '%s' minimum %ld",
1825 value, errmsg, min_value);
1826 }
1827 return 0;
1828 } else if (value > max_value) {
1829 if (errmsg) {
1830 PyErr_Format(PyExc_OverflowError,
1831 "value %ld is greater than '%s' maximum %ld",
1832 value, errmsg, max_value);
1833 }
1834 return 0;
1835 }
1836 return 1;
1837 }
1838
1839
1840 SWIGINTERN int
1841 SWIG_AsVal_long(PyObject* obj, long* val)
1842 {
1843 if (PyNumber_Check(obj)) {
1844 if (val) *val = PyInt_AsLong(obj);
1845 return 1;
1846 }
1847 else {
1848 SWIG_type_error("number", obj);
1849 }
1850 return 0;
1851 }
1852
1853
1854 #if INT_MAX != LONG_MAX
1855 SWIGINTERN int
1856 SWIG_AsVal_int(PyObject *obj, int *val)
1857 {
1858 const char* errmsg = val ? "int" : (char*)0;
1859 long v;
1860 if (SWIG_AsVal_long(obj, &v)) {
1861 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1862 if (val) *val = static_cast<int >(v);
1863 return 1;
1864 } else {
1865 return 0;
1866 }
1867 } else {
1868 PyErr_Clear();
1869 }
1870 if (val) {
1871 SWIG_type_error(errmsg, obj);
1872 }
1873 return 0;
1874 }
1875 #else
1876 SWIGINTERNINLINE int
1877 SWIG_AsVal_int(PyObject *obj, int *val)
1878 {
1879 return SWIG_AsVal_long(obj,(long*)val);
1880 }
1881 #endif
1882
1883
1884 SWIGINTERNINLINE int
1885 SWIG_As_int(PyObject* obj)
1886 {
1887 int v;
1888 if (!SWIG_AsVal_int(obj, &v)) {
1889 /*
1890 this is needed to make valgrind/purify happier.
1891 */
1892 memset((void*)&v, 0, sizeof(int));
1893 }
1894 return v;
1895 }
1896
1897
1898 SWIGINTERNINLINE int
1899 SWIG_Check_int(PyObject* obj)
1900 {
1901 return SWIG_AsVal_int(obj, (int*)0);
1902 }
1903
1904 static PyObject *wxSize_Get(wxSize *self){
1905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1906 PyObject* tup = PyTuple_New(2);
1907 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1908 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1909 wxPyEndBlockThreads(blocked);
1910 return tup;
1911 }
1912
1913 SWIGINTERN int
1914 SWIG_AsVal_double(PyObject *obj, double* val)
1915 {
1916 if (PyNumber_Check(obj)) {
1917 if (val) *val = PyFloat_AsDouble(obj);
1918 return 1;
1919 }
1920 else {
1921 SWIG_type_error("number", obj);
1922 }
1923 return 0;
1924 }
1925
1926
1927 SWIGINTERNINLINE double
1928 SWIG_As_double(PyObject* obj)
1929 {
1930 double v;
1931 if (!SWIG_AsVal_double(obj, &v)) {
1932 /*
1933 this is needed to make valgrind/purify happier.
1934 */
1935 memset((void*)&v, 0, sizeof(double));
1936 }
1937 return v;
1938 }
1939
1940
1941 SWIGINTERNINLINE int
1942 SWIG_Check_double(PyObject* obj)
1943 {
1944 return SWIG_AsVal_double(obj, (double*)0);
1945 }
1946
1947
1948 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1949 #define SWIG_From_double PyFloat_FromDouble
1950 /*@@*/
1951
1952 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1953 self->x = x;
1954 self->y = y;
1955 }
1956 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1958 PyObject* tup = PyTuple_New(2);
1959 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1960 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1961 wxPyEndBlockThreads(blocked);
1962 return tup;
1963 }
1964
1965 SWIGINTERNINLINE long
1966 SWIG_As_long(PyObject* obj)
1967 {
1968 long v;
1969 if (!SWIG_AsVal_long(obj, &v)) {
1970 /*
1971 this is needed to make valgrind/purify happier.
1972 */
1973 memset((void*)&v, 0, sizeof(long));
1974 }
1975 return v;
1976 }
1977
1978
1979 SWIGINTERNINLINE int
1980 SWIG_Check_long(PyObject* obj)
1981 {
1982 return SWIG_AsVal_long(obj, (long*)0);
1983 }
1984
1985 static void wxPoint_Set(wxPoint *self,long x,long y){
1986 self->x = x;
1987 self->y = y;
1988 }
1989 static PyObject *wxPoint_Get(wxPoint *self){
1990 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1991 PyObject* tup = PyTuple_New(2);
1992 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1993 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1994 wxPyEndBlockThreads(blocked);
1995 return tup;
1996 }
1997 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1998 self->x = x;
1999 self->y = y;
2000 self->width = width;
2001 self->height = height;
2002 }
2003 static PyObject *wxRect_Get(wxRect *self){
2004 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2005 PyObject* tup = PyTuple_New(4);
2006 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2007 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2008 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2009 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2010 wxPyEndBlockThreads(blocked);
2011 return tup;
2012 }
2013
2014 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2015 wxRegion reg1(*r1);
2016 wxRegion reg2(*r2);
2017 wxRect dest(0,0,0,0);
2018 PyObject* obj;
2019
2020 reg1.Intersect(reg2);
2021 dest = reg1.GetBox();
2022
2023 if (dest != wxRect(0,0,0,0)) {
2024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2025 wxRect* newRect = new wxRect(dest);
2026 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2027 wxPyEndBlockThreads(blocked);
2028 return obj;
2029 }
2030 Py_INCREF(Py_None);
2031 return Py_None;
2032 }
2033
2034
2035 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
2036 PyObject* o2;
2037 PyObject* o3;
2038
2039 if (!target) {
2040 target = o;
2041 } else if (target == Py_None) {
2042 Py_DECREF(Py_None);
2043 target = o;
2044 } else {
2045 if (!PyTuple_Check(target)) {
2046 o2 = target;
2047 target = PyTuple_New(1);
2048 PyTuple_SetItem(target, 0, o2);
2049 }
2050 o3 = PyTuple_New(1);
2051 PyTuple_SetItem(o3, 0, o);
2052
2053 o2 = target;
2054 target = PySequence_Concat(o2, o3);
2055 Py_DECREF(o2);
2056 Py_DECREF(o3);
2057 }
2058 return target;
2059 }
2060
2061
2062 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2063 self->m_x = x;
2064 self->m_y = y;
2065 }
2066 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2067 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2068 PyObject* tup = PyTuple_New(2);
2069 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2070 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2071 wxPyEndBlockThreads(blocked);
2072 return tup;
2073 }
2074
2075 #include "wx/wxPython/pyistream.h"
2076
2077 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2078 wxInputStream* wxis = wxPyCBInputStream::create(p);
2079 if (wxis)
2080 return new wxPyInputStream(wxis);
2081 else
2082 return NULL;
2083 }
2084
2085 SWIGINTERNINLINE PyObject*
2086 SWIG_From_char(char c)
2087 {
2088 return PyString_FromStringAndSize(&c,1);
2089 }
2090
2091
2092 SWIGINTERNINLINE PyObject*
2093 SWIG_From_unsigned_SS_long(unsigned long value)
2094 {
2095 return (value > LONG_MAX) ?
2096 PyLong_FromUnsignedLong(value)
2097 : PyInt_FromLong(static_cast<long >(value));
2098 }
2099
2100
2101 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2102 SWIGINTERN int
2103 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2104 {
2105 static swig_type_info* pchar_info = 0;
2106 char* vptr = 0;
2107 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2108 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2109 if (cptr) *cptr = vptr;
2110 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2111 return SWIG_OLDOBJ;
2112 } else {
2113 PyErr_Clear();
2114 if (PyString_Check(obj)) {
2115 if (cptr) {
2116 *cptr = PyString_AS_STRING(obj);
2117 if (psize) {
2118 *psize = PyString_GET_SIZE(obj) + 1;
2119 }
2120 }
2121 return SWIG_PYSTR;
2122 }
2123 }
2124 if (cptr) {
2125 SWIG_type_error("char *", obj);
2126 }
2127 return 0;
2128 }
2129
2130
2131 SWIGINTERN int
2132 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2133 {
2134 char* cptr; size_t csize;
2135 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2136 /* in C you can do:
2137
2138 char x[5] = "hello";
2139
2140 ie, assing the array using an extra '0' char.
2141 */
2142 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2143 if (csize <= size) {
2144 if (val) {
2145 if (csize) memcpy(val, cptr, csize);
2146 if (csize < size) memset(val + csize, 0, size - csize);
2147 }
2148 return 1;
2149 }
2150 }
2151 if (val) {
2152 PyErr_Format(PyExc_TypeError,
2153 "a char array of maximum size %lu is expected",
2154 (unsigned long) size);
2155 }
2156 return 0;
2157 }
2158
2159
2160 SWIGINTERN int
2161 SWIG_AsVal_char(PyObject *obj, char *val)
2162 {
2163 const char* errmsg = val ? "char" : (char*)0;
2164 long v;
2165 if (SWIG_AsVal_long(obj, &v)) {
2166 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2167 if (val) *val = static_cast<char >(v);
2168 return 1;
2169 } else {
2170 return 0;
2171 }
2172 } else {
2173 PyErr_Clear();
2174 return SWIG_AsCharArray(obj, val, 1);
2175 }
2176 }
2177
2178
2179 SWIGINTERNINLINE char
2180 SWIG_As_char(PyObject* obj)
2181 {
2182 char v;
2183 if (!SWIG_AsVal_char(obj, &v)) {
2184 /*
2185 this is needed to make valgrind/purify happier.
2186 */
2187 memset((void*)&v, 0, sizeof(char));
2188 }
2189 return v;
2190 }
2191
2192
2193 SWIGINTERNINLINE int
2194 SWIG_Check_char(PyObject* obj)
2195 {
2196 return SWIG_AsVal_char(obj, (char*)0);
2197 }
2198
2199
2200 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2201 #define SWIG_From_long PyInt_FromLong
2202 /*@@*/
2203
2204 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2205 // We use only strings for the streams, not unicode
2206 PyObject* str = PyObject_Str(obj);
2207 if (! str) {
2208 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2209 return;
2210 }
2211 self->Write(PyString_AS_STRING(str),
2212 PyString_GET_SIZE(str));
2213 Py_DECREF(str);
2214 }
2215
2216 #include "wx/wxPython/pyistream.h"
2217
2218
2219 class wxPyFileSystemHandler : public wxFileSystemHandler
2220 {
2221 public:
2222 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2223
2224 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2225 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2226 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2227 DEC_PYCALLBACK_STRING__pure(FindNext);
2228
2229 wxString GetProtocol(const wxString& location) {
2230 return wxFileSystemHandler::GetProtocol(location);
2231 }
2232
2233 wxString GetLeftLocation(const wxString& location) {
2234 return wxFileSystemHandler::GetLeftLocation(location);
2235 }
2236
2237 wxString GetAnchor(const wxString& location) {
2238 return wxFileSystemHandler::GetAnchor(location);
2239 }
2240
2241 wxString GetRightLocation(const wxString& location) {
2242 return wxFileSystemHandler::GetRightLocation(location);
2243 }
2244
2245 wxString GetMimeTypeFromExt(const wxString& location) {
2246 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2247 }
2248
2249 PYPRIVATE;
2250 };
2251
2252
2253 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2254 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2255 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2256 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2257
2258
2259 SWIGINTERN int
2260 SWIG_AsVal_bool(PyObject *obj, bool *val)
2261 {
2262 if (obj == Py_True) {
2263 if (val) *val = true;
2264 return 1;
2265 }
2266 if (obj == Py_False) {
2267 if (val) *val = false;
2268 return 1;
2269 }
2270 int res = 0;
2271 if (SWIG_AsVal_int(obj, &res)) {
2272 if (val) *val = res ? true : false;
2273 return 1;
2274 } else {
2275 PyErr_Clear();
2276 }
2277 if (val) {
2278 SWIG_type_error("bool", obj);
2279 }
2280 return 0;
2281 }
2282
2283
2284 SWIGINTERNINLINE bool
2285 SWIG_As_bool(PyObject* obj)
2286 {
2287 bool v;
2288 if (!SWIG_AsVal_bool(obj, &v)) {
2289 /*
2290 this is needed to make valgrind/purify happier.
2291 */
2292 memset((void*)&v, 0, sizeof(bool));
2293 }
2294 return v;
2295 }
2296
2297
2298 SWIGINTERNINLINE int
2299 SWIG_Check_bool(PyObject* obj)
2300 {
2301 return SWIG_AsVal_bool(obj, (bool*)0);
2302 }
2303
2304 static wxString wxFileSystem_URLToFileName(wxString const &url){
2305 wxFileName fname = wxFileSystem::URLToFileName(url);
2306 return fname.GetFullPath();
2307 }
2308
2309 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2310 wxImage& image,
2311 long type) {
2312 wxMemoryFSHandler::AddFile(filename, image, type);
2313 }
2314
2315 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2316 const wxBitmap& bitmap,
2317 long type) {
2318 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2319 }
2320
2321 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2322 PyObject* data) {
2323 if (! PyString_Check(data)) {
2324 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2325 "Expected string object"));
2326 return;
2327 }
2328
2329 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2330 void* ptr = (void*)PyString_AsString(data);
2331 size_t size = PyString_Size(data);
2332 wxPyEndBlockThreads(blocked);
2333
2334 wxMemoryFSHandler::AddFile(filename, ptr, size);
2335 }
2336
2337
2338 #include "wx/wxPython/pyistream.h"
2339
2340
2341 SWIGINTERN int
2342 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2343 {
2344 long v = 0;
2345 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2346 SWIG_type_error("unsigned number", obj);
2347 }
2348 else if (val)
2349 *val = (unsigned long)v;
2350 return 1;
2351 }
2352
2353
2354 SWIGINTERNINLINE int
2355 SWIG_CheckUnsignedLongInRange(unsigned long value,
2356 unsigned long max_value,
2357 const char *errmsg)
2358 {
2359 if (value > max_value) {
2360 if (errmsg) {
2361 PyErr_Format(PyExc_OverflowError,
2362 "value %lu is greater than '%s' minimum %lu",
2363 value, errmsg, max_value);
2364 }
2365 return 0;
2366 }
2367 return 1;
2368 }
2369
2370
2371 SWIGINTERN int
2372 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2373 {
2374 const char* errmsg = val ? "unsigned char" : (char*)0;
2375 unsigned long v;
2376 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2377 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2378 if (val) *val = static_cast<unsigned char >(v);
2379 return 1;
2380 } else {
2381 return 0;
2382 }
2383 } else {
2384 PyErr_Clear();
2385 }
2386 if (val) {
2387 SWIG_type_error(errmsg, obj);
2388 }
2389 return 0;
2390 }
2391
2392
2393 SWIGINTERNINLINE unsigned char
2394 SWIG_As_unsigned_SS_char(PyObject* obj)
2395 {
2396 unsigned char v;
2397 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2398 /*
2399 this is needed to make valgrind/purify happier.
2400 */
2401 memset((void*)&v, 0, sizeof(unsigned char));
2402 }
2403 return v;
2404 }
2405
2406
2407 SWIGINTERNINLINE int
2408 SWIG_Check_unsigned_SS_char(PyObject* obj)
2409 {
2410 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2411 }
2412
2413
2414 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2415 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2416 /*@@*/
2417
2418
2419
2420 SWIGINTERNINLINE unsigned long
2421 SWIG_As_unsigned_SS_long(PyObject* obj)
2422 {
2423 unsigned long v;
2424 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2425 /*
2426 this is needed to make valgrind/purify happier.
2427 */
2428 memset((void*)&v, 0, sizeof(unsigned long));
2429 }
2430 return v;
2431 }
2432
2433
2434 SWIGINTERNINLINE int
2435 SWIG_Check_unsigned_SS_long(PyObject* obj)
2436 {
2437 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2438 }
2439
2440 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2441 wxImageHistogramEntry e = (*self)[key];
2442 return e.value;
2443 }
2444 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2445 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2446 wxImageHistogramEntry e = (*self)[key];
2447 return e.value;
2448 }
2449 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2450 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2451 colour.Green(),
2452 colour.Blue());
2453 wxImageHistogramEntry e = (*self)[key];
2454 return e.value;
2455 }
2456
2457 typedef unsigned char* buffer;
2458
2459
2460 // Pull the nested class out to the top level for SWIG's sake
2461 #define wxImage_RGBValue wxImage::RGBValue
2462 #define wxImage_HSVValue wxImage::HSVValue
2463
2464 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2465 if (width > 0 && height > 0)
2466 return new wxImage(width, height, clear);
2467 else
2468 return new wxImage;
2469 }
2470 static wxImage *new_wxImage(wxBitmap const &bitmap){
2471 return new wxImage(bitmap.ConvertToImage());
2472 }
2473 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2474 if (DATASIZE != width*height*3) {
2475 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2476 return NULL;
2477 }
2478
2479 // Copy the source data so the wxImage can clean it up later
2480 buffer copy = (buffer)malloc(DATASIZE);
2481 if (copy == NULL) {
2482 wxPyBLOCK_THREADS(PyErr_NoMemory());
2483 return NULL;
2484 }
2485 memcpy(copy, data, DATASIZE);
2486 return new wxImage(width, height, copy, false);
2487 }
2488 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2489 if (DATASIZE != width*height*3) {
2490 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2491 return NULL;
2492 }
2493 if (ALPHASIZE != width*height) {
2494 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2495 return NULL;
2496 }
2497
2498 // Copy the source data so the wxImage can clean it up later
2499 buffer dcopy = (buffer)malloc(DATASIZE);
2500 if (dcopy == NULL) {
2501 wxPyBLOCK_THREADS(PyErr_NoMemory());
2502 return NULL;
2503 }
2504 memcpy(dcopy, data, DATASIZE);
2505
2506 buffer acopy = (buffer)malloc(ALPHASIZE);
2507 if (acopy == NULL) {
2508 wxPyBLOCK_THREADS(PyErr_NoMemory());
2509 return NULL;
2510 }
2511 memcpy(acopy, alpha, ALPHASIZE);
2512
2513 return new wxImage(width, height, dcopy, acopy, false);
2514 }
2515 static wxSize wxImage_GetSize(wxImage *self){
2516 wxSize size(self->GetWidth(), self->GetHeight());
2517 return size;
2518 }
2519 static PyObject *wxImage_GetData(wxImage *self){
2520 buffer data = self->GetData();
2521 int len = self->GetWidth() * self->GetHeight() * 3;
2522 PyObject* rv;
2523 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2524 return rv;
2525 }
2526 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2527 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2528 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2529 return;
2530 }
2531 buffer copy = (buffer)malloc(DATASIZE);
2532 if (copy == NULL) {
2533 wxPyBLOCK_THREADS(PyErr_NoMemory());
2534 return;
2535 }
2536 memcpy(copy, data, DATASIZE);
2537 self->SetData(copy, false);
2538 // wxImage takes ownership of copy...
2539 }
2540 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2541 buffer data = self->GetData();
2542 int len = self->GetWidth() * self->GetHeight() * 3;
2543 PyObject* rv;
2544 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2545 return rv;
2546 }
2547 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2548 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2549 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2550 return;
2551 }
2552 self->SetData(data, true);
2553 }
2554 static PyObject *wxImage_GetAlphaData(wxImage *self){
2555 buffer data = self->GetAlpha();
2556 if (! data) {
2557 RETURN_NONE();
2558 } else {
2559 int len = self->GetWidth() * self->GetHeight();
2560 PyObject* rv;
2561 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2562 return rv;
2563 }
2564 }
2565 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2566 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2567 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2568 return;
2569 }
2570 buffer acopy = (buffer)malloc(ALPHASIZE);
2571 if (acopy == NULL) {
2572 wxPyBLOCK_THREADS(PyErr_NoMemory());
2573 return;
2574 }
2575 memcpy(acopy, alpha, ALPHASIZE);
2576 self->SetAlpha(acopy, false);
2577 // wxImage takes ownership of acopy...
2578 }
2579 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2580 buffer data = self->GetAlpha();
2581 int len = self->GetWidth() * self->GetHeight();
2582 PyObject* rv;
2583 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2584 return rv;
2585 }
2586 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2587 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2588 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2589 return;
2590 }
2591 self->SetAlpha(alpha, true);
2592 }
2593 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2594 wxBitmap bitmap(*self, depth);
2595 return bitmap;
2596 }
2597 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2598 wxImage mono = self->ConvertToMono( red, green, blue );
2599 wxBitmap bitmap( mono, 1 );
2600 return bitmap;
2601 }
2602 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2603 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2604 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2605 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2606 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2607 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2608 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2609 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2610 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2611 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2612 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2613 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2614 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2615 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2616 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2617
2618 #include <wx/quantize.h>
2619
2620 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2621 return wxQuantize::Quantize(src, dest,
2622 //NULL, // palette
2623 desiredNoColours,
2624 NULL, // eightBitData
2625 flags);
2626 }
2627 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2628 if (PyCallable_Check(func)) {
2629 self->Connect(id, lastId, eventType,
2630 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2631 new wxPyCallback(func));
2632 }
2633 else if (func == Py_None) {
2634 self->Disconnect(id, lastId, eventType,
2635 (wxObjectEventFunction)
2636 &wxPyCallback::EventThunker);
2637 }
2638 else {
2639 wxPyBLOCK_THREADS(
2640 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2641 }
2642 }
2643 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2644 return self->Disconnect(id, lastId, eventType,
2645 (wxObjectEventFunction)
2646 &wxPyCallback::EventThunker);
2647 }
2648 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2649 if (_self && _self != Py_None) {
2650 self->SetClientObject(new wxPyOORClientData(_self, incref));
2651 }
2652 else {
2653 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2654 if (data) {
2655 self->SetClientObject(NULL); // This will delete it too
2656 }
2657 }
2658 }
2659
2660 #if ! wxUSE_HOTKEY
2661 #define wxEVT_HOTKEY -9999
2662 #endif
2663
2664
2665 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2666 #if wxUSE_UNICODE
2667 return self->GetUnicodeKey();
2668 #else
2669 return 0;
2670 #endif
2671 }
2672
2673 #if UINT_MAX < LONG_MAX
2674 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2675 #define SWIG_From_unsigned_SS_int SWIG_From_long
2676 /*@@*/
2677 #else
2678 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2679 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2680 /*@@*/
2681 #endif
2682
2683
2684 #if UINT_MAX != ULONG_MAX
2685 SWIGINTERN int
2686 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2687 {
2688 const char* errmsg = val ? "unsigned int" : (char*)0;
2689 unsigned long v;
2690 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2691 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2692 if (val) *val = static_cast<unsigned int >(v);
2693 return 1;
2694 }
2695 } else {
2696 PyErr_Clear();
2697 }
2698 if (val) {
2699 SWIG_type_error(errmsg, obj);
2700 }
2701 return 0;
2702 }
2703 #else
2704 SWIGINTERNINLINE unsigned int
2705 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2706 {
2707 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2708 }
2709 #endif
2710
2711
2712 SWIGINTERNINLINE unsigned int
2713 SWIG_As_unsigned_SS_int(PyObject* obj)
2714 {
2715 unsigned int v;
2716 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2717 /*
2718 this is needed to make valgrind/purify happier.
2719 */
2720 memset((void*)&v, 0, sizeof(unsigned int));
2721 }
2722 return v;
2723 }
2724
2725
2726 SWIGINTERNINLINE int
2727 SWIG_Check_unsigned_SS_int(PyObject* obj)
2728 {
2729 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2730 }
2731
2732 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2733 self->m_size = size;
2734 }
2735 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2736 int count = self->GetNumberOfFiles();
2737 wxString* files = self->GetFiles();
2738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2739 PyObject* list = PyList_New(count);
2740
2741 if (!list) {
2742 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2743 wxPyEndBlockThreads(blocked);
2744 return NULL;
2745 }
2746
2747 for (int i=0; i<count; i++) {
2748 PyList_SetItem(list, i, wx2PyString(files[i]));
2749 }
2750 wxPyEndBlockThreads(blocked);
2751 return list;
2752 }
2753
2754
2755 static wxPyApp *new_wxPyApp(){
2756 wxPythonApp = new wxPyApp();
2757 return wxPythonApp;
2758 }
2759 static int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2760
2761 void wxApp_CleanUp() {
2762 __wxPyCleanup();
2763 }
2764
2765
2766 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2767
2768
2769 SWIGINTERNINLINE int
2770 SWIG_AsCharPtr(PyObject *obj, char **val)
2771 {
2772 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2773 return 1;
2774 }
2775 if (val) {
2776 PyErr_Clear();
2777 SWIG_type_error("char *", obj);
2778 }
2779 return 0;
2780 }
2781
2782
2783 SWIGINTERN PyObject *
2784 SWIG_FromCharPtr(const char* cptr)
2785 {
2786 if (cptr) {
2787 size_t size = strlen(cptr);
2788 if (size > INT_MAX) {
2789 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2790 SWIG_TypeQuery("char *"), 0);
2791 } else {
2792 if (size != 0) {
2793 return PyString_FromStringAndSize(cptr, size);
2794 } else {
2795 return PyString_FromString(cptr);
2796 }
2797 }
2798 }
2799 Py_INCREF(Py_None);
2800 return Py_None;
2801 }
2802
2803
2804 #if 0 // #ifdef __WXMAC__
2805
2806 // A dummy class that raises an exception if used...
2807 class wxEventLoop
2808 {
2809 public:
2810 wxEventLoop() { wxPyRaiseNotImplemented(); }
2811 int Run() { return 0; }
2812 void Exit(int rc = 0) {}
2813 bool Pending() const { return false; }
2814 bool Dispatch() { return false; }
2815 bool IsRunning() const { return false; }
2816 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2817 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2818 };
2819
2820 #else
2821
2822 #include <wx/evtloop.h>
2823
2824 #endif
2825
2826
2827
2828 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2829 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2830 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2831 static PyObject *wxWindow_GetChildren(wxWindow *self){
2832 wxWindowList& list = self->GetChildren();
2833 return wxPy_ConvertList(&list);
2834 }
2835 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2836 #if wxUSE_HOTKEY
2837 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2838 #else
2839 return false;
2840 #endif
2841 }
2842 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2843
2844
2845
2846 return false;
2847
2848 }
2849 static long wxWindow_GetHandle(wxWindow *self){
2850 return wxPyGetWinHandle(self);
2851 }
2852 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2853 self->AssociateHandle((WXWidget)handle);
2854 }
2855 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2856
2857 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2858 return wxWindow::FindWindowById(id, parent);
2859 }
2860
2861 wxWindow* wxFindWindowByName( const wxString& name,
2862 const wxWindow *parent = NULL ) {
2863 return wxWindow::FindWindowByName(name, parent);
2864 }
2865
2866 wxWindow* wxFindWindowByLabel( const wxString& label,
2867 const wxWindow *parent = NULL ) {
2868 return wxWindow::FindWindowByLabel(label, parent);
2869 }
2870
2871
2872 #ifdef __WXMSW__
2873 #include <wx/msw/private.h> // to get wxGetWindowId
2874 #endif
2875
2876
2877 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2878 #ifdef __WXMSW__
2879 WXHWND hWnd = (WXHWND)_hWnd;
2880 long id = wxGetWindowId(hWnd);
2881 wxWindow* win = new wxWindow;
2882 if (parent)
2883 parent->AddChild(win);
2884 win->SetEventHandler(win);
2885 win->SetHWND(hWnd);
2886 win->SetId(id);
2887 win->SubclassWin(hWnd);
2888 win->AdoptAttributesFromHWND();
2889 win->SetupColours();
2890 return win;
2891 #else
2892 wxPyRaiseNotImplemented();
2893 return NULL;
2894 #endif
2895 }
2896
2897
2898 PyObject* GetTopLevelWindows() {
2899 return wxPy_ConvertList(&wxTopLevelWindows);
2900 }
2901
2902
2903 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2904 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2905 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2906
2907 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2908
2909 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2910 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2911 wxMenuItemList& list = self->GetMenuItems();
2912 return wxPy_ConvertList(&list);
2913 }
2914 static void wxMenuBar_SetAutoWindowMenu(bool enable){}
2915 static bool wxMenuBar_GetAutoWindowMenu(){ return false; }
2916 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2917 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2918 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2919 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2920 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2921 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2922 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
2923 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2924 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2925 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2926 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2927 static int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
2928 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2929 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2930 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2931 static const wxString wxPyControlNameStr(wxControlNameStr);
2932 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2933 if (clientData) {
2934 wxPyClientData* data = new wxPyClientData(clientData);
2935 return self->Append(item, data);
2936 } else
2937 return self->Append(item);
2938 }
2939 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2940 if (clientData) {
2941 wxPyClientData* data = new wxPyClientData(clientData);
2942 return self->Insert(item, pos, data);
2943 } else
2944 return self->Insert(item, pos);
2945 }
2946 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2947 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2948 if (data) {
2949 Py_INCREF(data->m_obj);
2950 return data->m_obj;
2951 } else {
2952 Py_INCREF(Py_None);
2953 return Py_None;
2954 }
2955 }
2956 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2957 wxPyClientData* data = new wxPyClientData(clientData);
2958 self->SetClientObject(n, data);
2959 }
2960
2961
2962 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2963 wxPyUserData* data = NULL;
2964 if ( userData ) {
2965 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2966 data = new wxPyUserData(userData);
2967 wxPyEndBlockThreads(blocked);
2968 }
2969 return new wxSizerItem(window, proportion, flag, border, data);
2970 }
2971 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2972 wxPyUserData* data = NULL;
2973 if ( userData ) {
2974 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2975 data = new wxPyUserData(userData);
2976 wxPyEndBlockThreads(blocked);
2977 }
2978 return new wxSizerItem(width, height, proportion, flag, border, data);
2979 }
2980 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2981 wxPyUserData* data = NULL;
2982 if ( userData ) {
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 data = new wxPyUserData(userData);
2985 wxPyEndBlockThreads(blocked);
2986 }
2987 return new wxSizerItem(sizer, proportion, flag, border, data);
2988 }
2989
2990 #include <float.h>
2991 SWIGINTERN int
2992 SWIG_CheckDoubleInRange(double value, double min_value,
2993 double max_value, const char* errmsg)
2994 {
2995 if (value < min_value) {
2996 if (errmsg) {
2997 PyErr_Format(PyExc_OverflowError,
2998 "value %g is less than %s minimum %g",
2999 value, errmsg, min_value);
3000 }
3001 return 0;
3002 } else if (value > max_value) {
3003 if (errmsg) {
3004 PyErr_Format(PyExc_OverflowError,
3005 "value %g is greater than %s maximum %g",
3006 value, errmsg, max_value);
3007 }
3008 return 0;
3009 }
3010 return 1;
3011 }
3012
3013
3014 SWIGINTERN int
3015 SWIG_AsVal_float(PyObject *obj, float *val)
3016 {
3017 const char* errmsg = val ? "float" : (char*)0;
3018 double v;
3019 if (SWIG_AsVal_double(obj, &v)) {
3020 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3021 if (val) *val = static_cast<float >(v);
3022 return 1;
3023 } else {
3024 return 0;
3025 }
3026 } else {
3027 PyErr_Clear();
3028 }
3029 if (val) {
3030 SWIG_type_error(errmsg, obj);
3031 }
3032 return 0;
3033 }
3034
3035
3036 SWIGINTERNINLINE float
3037 SWIG_As_float(PyObject* obj)
3038 {
3039 float v;
3040 if (!SWIG_AsVal_float(obj, &v)) {
3041 /*
3042 this is needed to make valgrind/purify happier.
3043 */
3044 memset((void*)&v, 0, sizeof(float));
3045 }
3046 return v;
3047 }
3048
3049
3050 SWIGINTERNINLINE int
3051 SWIG_Check_float(PyObject* obj)
3052 {
3053 return SWIG_AsVal_float(obj, (float*)0);
3054 }
3055
3056
3057 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
3058 #define SWIG_From_float PyFloat_FromDouble
3059 /*@@*/
3060
3061 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3062 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3063 if (data) {
3064 Py_INCREF(data->m_obj);
3065 return data->m_obj;
3066 } else {
3067 Py_INCREF(Py_None);
3068 return Py_None;
3069 }
3070 }
3071 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3072 wxPyUserData* data = NULL;
3073 if ( userData ) {
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3075 data = new wxPyUserData(userData);
3076 wxPyEndBlockThreads(blocked);
3077 }
3078 self->SetUserData(data);
3079 }
3080
3081 // Figure out the type of the sizer item
3082
3083 struct wxPySizerItemInfo {
3084 wxPySizerItemInfo()
3085 : window(NULL), sizer(NULL), gotSize(false),
3086 size(wxDefaultSize), gotPos(false), pos(-1)
3087 {}
3088
3089 wxWindow* window;
3090 wxSizer* sizer;
3091 bool gotSize;
3092 wxSize size;
3093 bool gotPos;
3094 int pos;
3095 };
3096
3097 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3098
3099 wxPySizerItemInfo info;
3100 wxSize size;
3101 wxSize* sizePtr = &size;
3102
3103 // Find out what the type of the item is
3104 // try wxWindow
3105 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3106 PyErr_Clear();
3107 info.window = NULL;
3108
3109 // try wxSizer
3110 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3111 PyErr_Clear();
3112 info.sizer = NULL;
3113
3114 // try wxSize or (w,h)
3115 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3116 info.size = *sizePtr;
3117 info.gotSize = true;
3118 }
3119
3120 // or a single int
3121 if (checkIdx && PyInt_Check(item)) {
3122 info.pos = PyInt_AsLong(item);
3123 info.gotPos = true;
3124 }
3125 }
3126 }
3127
3128 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3129 // no expected type, figure out what kind of error message to generate
3130 if ( !checkSize && !checkIdx )
3131 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3132 else if ( checkSize && !checkIdx )
3133 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3134 else if ( !checkSize && checkIdx)
3135 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3136 else
3137 // can this one happen?
3138 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3139 }
3140
3141 return info;
3142 }
3143
3144 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3145 if (!self->GetClientObject())
3146 self->SetClientObject(new wxPyOORClientData(_self));
3147 }
3148 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3149
3150 wxPyUserData* data = NULL;
3151 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3152 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3153 if ( userData && (info.window || info.sizer || info.gotSize) )
3154 data = new wxPyUserData(userData);
3155 wxPyEndBlockThreads(blocked);
3156
3157 // Now call the real Add method if a valid item type was found
3158 if ( info.window )
3159 return self->Add(info.window, proportion, flag, border, data);
3160 else if ( info.sizer )
3161 return self->Add(info.sizer, proportion, flag, border, data);
3162 else if (info.gotSize)
3163 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3164 proportion, flag, border, data);
3165 else
3166 return NULL;
3167 }
3168 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3169
3170 wxPyUserData* data = NULL;
3171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3172 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3173 if ( userData && (info.window || info.sizer || info.gotSize) )
3174 data = new wxPyUserData(userData);
3175 wxPyEndBlockThreads(blocked);
3176
3177 // Now call the real Insert method if a valid item type was found
3178 if ( info.window )
3179 return self->Insert(before, info.window, proportion, flag, border, data);
3180 else if ( info.sizer )
3181 return self->Insert(before, info.sizer, proportion, flag, border, data);
3182 else if (info.gotSize)
3183 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3184 proportion, flag, border, data);
3185 else
3186 return NULL;
3187 }
3188 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3189
3190 wxPyUserData* data = NULL;
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3193 if ( userData && (info.window || info.sizer || info.gotSize) )
3194 data = new wxPyUserData(userData);
3195 wxPyEndBlockThreads(blocked);
3196
3197 // Now call the real Prepend method if a valid item type was found
3198 if ( info.window )
3199 return self->Prepend(info.window, proportion, flag, border, data);
3200 else if ( info.sizer )
3201 return self->Prepend(info.sizer, proportion, flag, border, data);
3202 else if (info.gotSize)
3203 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3204 proportion, flag, border, data);
3205 else
3206 return NULL;
3207 }
3208 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3211 wxPyEndBlockThreads(blocked);
3212 if ( info.window )
3213 return self->Remove(info.window);
3214 else if ( info.sizer )
3215 return self->Remove(info.sizer);
3216 else if ( info.gotPos )
3217 return self->Remove(info.pos);
3218 else
3219 return false;
3220 }
3221 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3224 wxPyEndBlockThreads(blocked);
3225 if ( info.window )
3226 return self->Detach(info.window);
3227 else if ( info.sizer )
3228 return self->Detach(info.sizer);
3229 else if ( info.gotPos )
3230 return self->Detach(info.pos);
3231 else
3232 return false;
3233 }
3234 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3237 wxPyEndBlockThreads(blocked);
3238 if ( info.window )
3239 return self->GetItem(info.window);
3240 else if ( info.sizer )
3241 return self->GetItem(info.sizer);
3242 else if ( info.gotPos )
3243 return self->GetItem(info.pos);
3244 else
3245 return NULL;
3246 }
3247 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3248 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3249 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3250 wxPyEndBlockThreads(blocked);
3251 if ( info.window )
3252 self->SetItemMinSize(info.window, size);
3253 else if ( info.sizer )
3254 self->SetItemMinSize(info.sizer, size);
3255 else if ( info.gotPos )
3256 self->SetItemMinSize(info.pos, size);
3257 }
3258 static PyObject *wxSizer_GetChildren(wxSizer *self){
3259 wxSizerItemList& list = self->GetChildren();
3260 return wxPy_ConvertList(&list);
3261 }
3262 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3264 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3265 wxPyEndBlockThreads(blocked);
3266 if ( info.window )
3267 return self->Show(info.window, show, recursive);
3268 else if ( info.sizer )
3269 return self->Show(info.sizer, show, recursive);
3270 else if ( info.gotPos )
3271 return self->Show(info.pos, show);
3272 else
3273 return false;
3274 }
3275 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3276 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3277 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3278 wxPyEndBlockThreads(blocked);
3279 if ( info.window )
3280 return self->IsShown(info.window);
3281 else if ( info.sizer )
3282 return self->IsShown(info.sizer);
3283 else if ( info.gotPos )
3284 return self->IsShown(info.pos);
3285 else
3286 return false;
3287 }
3288
3289 // See pyclasses.h
3290 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3291 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3292 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3293
3294
3295
3296
3297 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3298 {
3299 if (source == Py_None) {
3300 **obj = wxGBPosition(-1,-1);
3301 return true;
3302 }
3303 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3304 }
3305
3306 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3307 {
3308 if (source == Py_None) {
3309 **obj = wxGBSpan(-1,-1);
3310 return true;
3311 }
3312 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3313 }
3314
3315
3316 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3317 self->SetRow(row);
3318 self->SetCol(col);
3319 }
3320 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3321 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3322 PyObject* tup = PyTuple_New(2);
3323 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3324 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3325 wxPyEndBlockThreads(blocked);
3326 return tup;
3327 }
3328 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3329 self->SetRowspan(rowspan);
3330 self->SetColspan(colspan);
3331 }
3332 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 PyObject* tup = PyTuple_New(2);
3335 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3336 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3337 wxPyEndBlockThreads(blocked);
3338 return tup;
3339 }
3340 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3341 wxPyUserData* data = NULL;
3342 if ( userData ) {
3343 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3344 data = new wxPyUserData(userData);
3345 wxPyEndBlockThreads(blocked);
3346 }
3347 return new wxGBSizerItem(window, pos, span, flag, border, data);
3348 }
3349 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3350 wxPyUserData* data = NULL;
3351 if ( userData ) {
3352 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3353 data = new wxPyUserData(userData);
3354 wxPyEndBlockThreads(blocked);
3355 }
3356 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3357 }
3358 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3359 wxPyUserData* data = NULL;
3360 if ( userData ) {
3361 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3362 data = new wxPyUserData(userData);
3363 wxPyEndBlockThreads(blocked);
3364 }
3365 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3366 }
3367 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3368 int row, col;
3369 self->GetEndPos(row, col);
3370 return wxGBPosition(row, col);
3371 }
3372 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3373
3374 wxPyUserData* data = NULL;
3375 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3376 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3377 if ( userData && (info.window || info.sizer || info.gotSize) )
3378 data = new wxPyUserData(userData);
3379 wxPyEndBlockThreads(blocked);
3380
3381 // Now call the real Add method if a valid item type was found
3382 if ( info.window )
3383 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3384 else if ( info.sizer )
3385 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3386 else if (info.gotSize)
3387 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3388 pos, span, flag, border, data);
3389 return NULL;
3390 }
3391
3392
3393 #ifdef __cplusplus
3394 extern "C" {
3395 #endif
3396 static int _wrap_EmptyString_set(PyObject *) {
3397 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3398 return 1;
3399 }
3400
3401
3402 static PyObject *_wrap_EmptyString_get(void) {
3403 PyObject *pyobj = NULL;
3404
3405 {
3406 #if wxUSE_UNICODE
3407 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3408 #else
3409 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3410 #endif
3411 }
3412 return pyobj;
3413 }
3414
3415
3416 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3417 PyObject *resultobj = NULL;
3418 wxObject *arg1 = (wxObject *) 0 ;
3419 wxString result;
3420 PyObject * obj0 = 0 ;
3421 char *kwnames[] = {
3422 (char *) "self", NULL
3423 };
3424
3425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3427 if (SWIG_arg_fail(1)) SWIG_fail;
3428 {
3429 PyThreadState* __tstate = wxPyBeginAllowThreads();
3430 result = wxObject_GetClassName(arg1);
3431
3432 wxPyEndAllowThreads(__tstate);
3433 if (PyErr_Occurred()) SWIG_fail;
3434 }
3435 {
3436 #if wxUSE_UNICODE
3437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3438 #else
3439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3440 #endif
3441 }
3442 return resultobj;
3443 fail:
3444 return NULL;
3445 }
3446
3447
3448 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3449 PyObject *resultobj = NULL;
3450 wxObject *arg1 = (wxObject *) 0 ;
3451 PyObject * obj0 = 0 ;
3452 char *kwnames[] = {
3453 (char *) "self", NULL
3454 };
3455
3456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3458 if (SWIG_arg_fail(1)) SWIG_fail;
3459 {
3460 PyThreadState* __tstate = wxPyBeginAllowThreads();
3461 wxObject_Destroy(arg1);
3462
3463 wxPyEndAllowThreads(__tstate);
3464 if (PyErr_Occurred()) SWIG_fail;
3465 }
3466 Py_INCREF(Py_None); resultobj = Py_None;
3467 return resultobj;
3468 fail:
3469 return NULL;
3470 }
3471
3472
3473 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3474 PyObject *obj;
3475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3476 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3477 Py_INCREF(obj);
3478 return Py_BuildValue((char *)"");
3479 }
3480 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3481 PyObject *resultobj = NULL;
3482 wxSize *arg1 = (wxSize *) 0 ;
3483 int arg2 ;
3484 PyObject * obj0 = 0 ;
3485 PyObject * obj1 = 0 ;
3486 char *kwnames[] = {
3487 (char *) "self",(char *) "x", NULL
3488 };
3489
3490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3492 if (SWIG_arg_fail(1)) SWIG_fail;
3493 {
3494 arg2 = static_cast<int >(SWIG_As_int(obj1));
3495 if (SWIG_arg_fail(2)) SWIG_fail;
3496 }
3497 if (arg1) (arg1)->x = arg2;
3498
3499 Py_INCREF(Py_None); resultobj = Py_None;
3500 return resultobj;
3501 fail:
3502 return NULL;
3503 }
3504
3505
3506 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3507 PyObject *resultobj = NULL;
3508 wxSize *arg1 = (wxSize *) 0 ;
3509 int result;
3510 PyObject * obj0 = 0 ;
3511 char *kwnames[] = {
3512 (char *) "self", NULL
3513 };
3514
3515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3517 if (SWIG_arg_fail(1)) SWIG_fail;
3518 result = (int) ((arg1)->x);
3519
3520 {
3521 resultobj = SWIG_From_int(static_cast<int >(result));
3522 }
3523 return resultobj;
3524 fail:
3525 return NULL;
3526 }
3527
3528
3529 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3530 PyObject *resultobj = NULL;
3531 wxSize *arg1 = (wxSize *) 0 ;
3532 int arg2 ;
3533 PyObject * obj0 = 0 ;
3534 PyObject * obj1 = 0 ;
3535 char *kwnames[] = {
3536 (char *) "self",(char *) "y", NULL
3537 };
3538
3539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3541 if (SWIG_arg_fail(1)) SWIG_fail;
3542 {
3543 arg2 = static_cast<int >(SWIG_As_int(obj1));
3544 if (SWIG_arg_fail(2)) SWIG_fail;
3545 }
3546 if (arg1) (arg1)->y = arg2;
3547
3548 Py_INCREF(Py_None); resultobj = Py_None;
3549 return resultobj;
3550 fail:
3551 return NULL;
3552 }
3553
3554
3555 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3556 PyObject *resultobj = NULL;
3557 wxSize *arg1 = (wxSize *) 0 ;
3558 int result;
3559 PyObject * obj0 = 0 ;
3560 char *kwnames[] = {
3561 (char *) "self", NULL
3562 };
3563
3564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3566 if (SWIG_arg_fail(1)) SWIG_fail;
3567 result = (int) ((arg1)->y);
3568
3569 {
3570 resultobj = SWIG_From_int(static_cast<int >(result));
3571 }
3572 return resultobj;
3573 fail:
3574 return NULL;
3575 }
3576
3577
3578 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3579 PyObject *resultobj = NULL;
3580 int arg1 = (int) 0 ;
3581 int arg2 = (int) 0 ;
3582 wxSize *result;
3583 PyObject * obj0 = 0 ;
3584 PyObject * obj1 = 0 ;
3585 char *kwnames[] = {
3586 (char *) "w",(char *) "h", NULL
3587 };
3588
3589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3590 if (obj0) {
3591 {
3592 arg1 = static_cast<int >(SWIG_As_int(obj0));
3593 if (SWIG_arg_fail(1)) SWIG_fail;
3594 }
3595 }
3596 if (obj1) {
3597 {
3598 arg2 = static_cast<int >(SWIG_As_int(obj1));
3599 if (SWIG_arg_fail(2)) SWIG_fail;
3600 }
3601 }
3602 {
3603 PyThreadState* __tstate = wxPyBeginAllowThreads();
3604 result = (wxSize *)new wxSize(arg1,arg2);
3605
3606 wxPyEndAllowThreads(__tstate);
3607 if (PyErr_Occurred()) SWIG_fail;
3608 }
3609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3610 return resultobj;
3611 fail:
3612 return NULL;
3613 }
3614
3615
3616 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3617 PyObject *resultobj = NULL;
3618 wxSize *arg1 = (wxSize *) 0 ;
3619 PyObject * obj0 = 0 ;
3620 char *kwnames[] = {
3621 (char *) "self", NULL
3622 };
3623
3624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3626 if (SWIG_arg_fail(1)) SWIG_fail;
3627 {
3628 PyThreadState* __tstate = wxPyBeginAllowThreads();
3629 delete arg1;
3630
3631 wxPyEndAllowThreads(__tstate);
3632 if (PyErr_Occurred()) SWIG_fail;
3633 }
3634 Py_INCREF(Py_None); resultobj = Py_None;
3635 return resultobj;
3636 fail:
3637 return NULL;
3638 }
3639
3640
3641 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3642 PyObject *resultobj = NULL;
3643 wxSize *arg1 = (wxSize *) 0 ;
3644 wxSize *arg2 = 0 ;
3645 bool result;
3646 wxSize temp2 ;
3647 PyObject * obj0 = 0 ;
3648 PyObject * obj1 = 0 ;
3649 char *kwnames[] = {
3650 (char *) "self",(char *) "sz", NULL
3651 };
3652
3653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3655 if (SWIG_arg_fail(1)) SWIG_fail;
3656 {
3657 arg2 = &temp2;
3658 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3659 }
3660 {
3661 PyThreadState* __tstate = wxPyBeginAllowThreads();
3662 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3663
3664 wxPyEndAllowThreads(__tstate);
3665 if (PyErr_Occurred()) SWIG_fail;
3666 }
3667 {
3668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3669 }
3670 return resultobj;
3671 fail:
3672 return NULL;
3673 }
3674
3675
3676 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3677 PyObject *resultobj = NULL;
3678 wxSize *arg1 = (wxSize *) 0 ;
3679 wxSize *arg2 = 0 ;
3680 bool result;
3681 wxSize temp2 ;
3682 PyObject * obj0 = 0 ;
3683 PyObject * obj1 = 0 ;
3684 char *kwnames[] = {
3685 (char *) "self",(char *) "sz", NULL
3686 };
3687
3688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3690 if (SWIG_arg_fail(1)) SWIG_fail;
3691 {
3692 arg2 = &temp2;
3693 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3694 }
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 {
3703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3704 }
3705 return resultobj;
3706 fail:
3707 return NULL;
3708 }
3709
3710
3711 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3712 PyObject *resultobj = NULL;
3713 wxSize *arg1 = (wxSize *) 0 ;
3714 wxSize *arg2 = 0 ;
3715 wxSize result;
3716 wxSize temp2 ;
3717 PyObject * obj0 = 0 ;
3718 PyObject * obj1 = 0 ;
3719 char *kwnames[] = {
3720 (char *) "self",(char *) "sz", NULL
3721 };
3722
3723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3725 if (SWIG_arg_fail(1)) SWIG_fail;
3726 {
3727 arg2 = &temp2;
3728 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3729 }
3730 {
3731 PyThreadState* __tstate = wxPyBeginAllowThreads();
3732 result = (arg1)->operator +((wxSize const &)*arg2);
3733
3734 wxPyEndAllowThreads(__tstate);
3735 if (PyErr_Occurred()) SWIG_fail;
3736 }
3737 {
3738 wxSize * resultptr;
3739 resultptr = new wxSize(static_cast<wxSize & >(result));
3740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3741 }
3742 return resultobj;
3743 fail:
3744 return NULL;
3745 }
3746
3747
3748 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3749 PyObject *resultobj = NULL;
3750 wxSize *arg1 = (wxSize *) 0 ;
3751 wxSize *arg2 = 0 ;
3752 wxSize result;
3753 wxSize temp2 ;
3754 PyObject * obj0 = 0 ;
3755 PyObject * obj1 = 0 ;
3756 char *kwnames[] = {
3757 (char *) "self",(char *) "sz", NULL
3758 };
3759
3760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3762 if (SWIG_arg_fail(1)) SWIG_fail;
3763 {
3764 arg2 = &temp2;
3765 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3766 }
3767 {
3768 PyThreadState* __tstate = wxPyBeginAllowThreads();
3769 result = (arg1)->operator -((wxSize const &)*arg2);
3770
3771 wxPyEndAllowThreads(__tstate);
3772 if (PyErr_Occurred()) SWIG_fail;
3773 }
3774 {
3775 wxSize * resultptr;
3776 resultptr = new wxSize(static_cast<wxSize & >(result));
3777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3778 }
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj = NULL;
3787 wxSize *arg1 = (wxSize *) 0 ;
3788 wxSize *arg2 = 0 ;
3789 wxSize temp2 ;
3790 PyObject * obj0 = 0 ;
3791 PyObject * obj1 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self",(char *) "sz", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 arg2 = &temp2;
3801 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3802 }
3803 {
3804 PyThreadState* __tstate = wxPyBeginAllowThreads();
3805 (arg1)->IncTo((wxSize const &)*arg2);
3806
3807 wxPyEndAllowThreads(__tstate);
3808 if (PyErr_Occurred()) SWIG_fail;
3809 }
3810 Py_INCREF(Py_None); resultobj = Py_None;
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj = NULL;
3819 wxSize *arg1 = (wxSize *) 0 ;
3820 wxSize *arg2 = 0 ;
3821 wxSize temp2 ;
3822 PyObject * obj0 = 0 ;
3823 PyObject * obj1 = 0 ;
3824 char *kwnames[] = {
3825 (char *) "self",(char *) "sz", NULL
3826 };
3827
3828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3830 if (SWIG_arg_fail(1)) SWIG_fail;
3831 {
3832 arg2 = &temp2;
3833 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3834 }
3835 {
3836 PyThreadState* __tstate = wxPyBeginAllowThreads();
3837 (arg1)->DecTo((wxSize const &)*arg2);
3838
3839 wxPyEndAllowThreads(__tstate);
3840 if (PyErr_Occurred()) SWIG_fail;
3841 }
3842 Py_INCREF(Py_None); resultobj = Py_None;
3843 return resultobj;
3844 fail:
3845 return NULL;
3846 }
3847
3848
3849 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3850 PyObject *resultobj = NULL;
3851 wxSize *arg1 = (wxSize *) 0 ;
3852 int arg2 ;
3853 int arg3 ;
3854 PyObject * obj0 = 0 ;
3855 PyObject * obj1 = 0 ;
3856 PyObject * obj2 = 0 ;
3857 char *kwnames[] = {
3858 (char *) "self",(char *) "w",(char *) "h", NULL
3859 };
3860
3861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3863 if (SWIG_arg_fail(1)) SWIG_fail;
3864 {
3865 arg2 = static_cast<int >(SWIG_As_int(obj1));
3866 if (SWIG_arg_fail(2)) SWIG_fail;
3867 }
3868 {
3869 arg3 = static_cast<int >(SWIG_As_int(obj2));
3870 if (SWIG_arg_fail(3)) SWIG_fail;
3871 }
3872 {
3873 PyThreadState* __tstate = wxPyBeginAllowThreads();
3874 (arg1)->Set(arg2,arg3);
3875
3876 wxPyEndAllowThreads(__tstate);
3877 if (PyErr_Occurred()) SWIG_fail;
3878 }
3879 Py_INCREF(Py_None); resultobj = Py_None;
3880 return resultobj;
3881 fail:
3882 return NULL;
3883 }
3884
3885
3886 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3887 PyObject *resultobj = NULL;
3888 wxSize *arg1 = (wxSize *) 0 ;
3889 int arg2 ;
3890 PyObject * obj0 = 0 ;
3891 PyObject * obj1 = 0 ;
3892 char *kwnames[] = {
3893 (char *) "self",(char *) "w", NULL
3894 };
3895
3896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3898 if (SWIG_arg_fail(1)) SWIG_fail;
3899 {
3900 arg2 = static_cast<int >(SWIG_As_int(obj1));
3901 if (SWIG_arg_fail(2)) SWIG_fail;
3902 }
3903 {
3904 PyThreadState* __tstate = wxPyBeginAllowThreads();
3905 (arg1)->SetWidth(arg2);
3906
3907 wxPyEndAllowThreads(__tstate);
3908 if (PyErr_Occurred()) SWIG_fail;
3909 }
3910 Py_INCREF(Py_None); resultobj = Py_None;
3911 return resultobj;
3912 fail:
3913 return NULL;
3914 }
3915
3916
3917 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3918 PyObject *resultobj = NULL;
3919 wxSize *arg1 = (wxSize *) 0 ;
3920 int arg2 ;
3921 PyObject * obj0 = 0 ;
3922 PyObject * obj1 = 0 ;
3923 char *kwnames[] = {
3924 (char *) "self",(char *) "h", NULL
3925 };
3926
3927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3929 if (SWIG_arg_fail(1)) SWIG_fail;
3930 {
3931 arg2 = static_cast<int >(SWIG_As_int(obj1));
3932 if (SWIG_arg_fail(2)) SWIG_fail;
3933 }
3934 {
3935 PyThreadState* __tstate = wxPyBeginAllowThreads();
3936 (arg1)->SetHeight(arg2);
3937
3938 wxPyEndAllowThreads(__tstate);
3939 if (PyErr_Occurred()) SWIG_fail;
3940 }
3941 Py_INCREF(Py_None); resultobj = Py_None;
3942 return resultobj;
3943 fail:
3944 return NULL;
3945 }
3946
3947
3948 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3949 PyObject *resultobj = NULL;
3950 wxSize *arg1 = (wxSize *) 0 ;
3951 int result;
3952 PyObject * obj0 = 0 ;
3953 char *kwnames[] = {
3954 (char *) "self", NULL
3955 };
3956
3957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3959 if (SWIG_arg_fail(1)) SWIG_fail;
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 result = (int)((wxSize const *)arg1)->GetWidth();
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 {
3968 resultobj = SWIG_From_int(static_cast<int >(result));
3969 }
3970 return resultobj;
3971 fail:
3972 return NULL;
3973 }
3974
3975
3976 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3977 PyObject *resultobj = NULL;
3978 wxSize *arg1 = (wxSize *) 0 ;
3979 int result;
3980 PyObject * obj0 = 0 ;
3981 char *kwnames[] = {
3982 (char *) "self", NULL
3983 };
3984
3985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3987 if (SWIG_arg_fail(1)) SWIG_fail;
3988 {
3989 PyThreadState* __tstate = wxPyBeginAllowThreads();
3990 result = (int)((wxSize const *)arg1)->GetHeight();
3991
3992 wxPyEndAllowThreads(__tstate);
3993 if (PyErr_Occurred()) SWIG_fail;
3994 }
3995 {
3996 resultobj = SWIG_From_int(static_cast<int >(result));
3997 }
3998 return resultobj;
3999 fail:
4000 return NULL;
4001 }
4002
4003
4004 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
4005 PyObject *resultobj = NULL;
4006 wxSize *arg1 = (wxSize *) 0 ;
4007 bool result;
4008 PyObject * obj0 = 0 ;
4009 char *kwnames[] = {
4010 (char *) "self", NULL
4011 };
4012
4013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4015 if (SWIG_arg_fail(1)) SWIG_fail;
4016 {
4017 PyThreadState* __tstate = wxPyBeginAllowThreads();
4018 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4019
4020 wxPyEndAllowThreads(__tstate);
4021 if (PyErr_Occurred()) SWIG_fail;
4022 }
4023 {
4024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4025 }
4026 return resultobj;
4027 fail:
4028 return NULL;
4029 }
4030
4031
4032 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4033 PyObject *resultobj = NULL;
4034 wxSize *arg1 = (wxSize *) 0 ;
4035 wxSize *arg2 = 0 ;
4036 wxSize temp2 ;
4037 PyObject * obj0 = 0 ;
4038 PyObject * obj1 = 0 ;
4039 char *kwnames[] = {
4040 (char *) "self",(char *) "size", NULL
4041 };
4042
4043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4045 if (SWIG_arg_fail(1)) SWIG_fail;
4046 {
4047 arg2 = &temp2;
4048 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4049 }
4050 {
4051 PyThreadState* __tstate = wxPyBeginAllowThreads();
4052 (arg1)->SetDefaults((wxSize const &)*arg2);
4053
4054 wxPyEndAllowThreads(__tstate);
4055 if (PyErr_Occurred()) SWIG_fail;
4056 }
4057 Py_INCREF(Py_None); resultobj = Py_None;
4058 return resultobj;
4059 fail:
4060 return NULL;
4061 }
4062
4063
4064 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4065 PyObject *resultobj = NULL;
4066 wxSize *arg1 = (wxSize *) 0 ;
4067 PyObject *result;
4068 PyObject * obj0 = 0 ;
4069 char *kwnames[] = {
4070 (char *) "self", NULL
4071 };
4072
4073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4075 if (SWIG_arg_fail(1)) SWIG_fail;
4076 {
4077 PyThreadState* __tstate = wxPyBeginAllowThreads();
4078 result = (PyObject *)wxSize_Get(arg1);
4079
4080 wxPyEndAllowThreads(__tstate);
4081 if (PyErr_Occurred()) SWIG_fail;
4082 }
4083 resultobj = result;
4084 return resultobj;
4085 fail:
4086 return NULL;
4087 }
4088
4089
4090 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4091 PyObject *obj;
4092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4093 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4094 Py_INCREF(obj);
4095 return Py_BuildValue((char *)"");
4096 }
4097 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4098 PyObject *resultobj = NULL;
4099 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4100 double arg2 ;
4101 PyObject * obj0 = 0 ;
4102 PyObject * obj1 = 0 ;
4103 char *kwnames[] = {
4104 (char *) "self",(char *) "x", NULL
4105 };
4106
4107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4109 if (SWIG_arg_fail(1)) SWIG_fail;
4110 {
4111 arg2 = static_cast<double >(SWIG_As_double(obj1));
4112 if (SWIG_arg_fail(2)) SWIG_fail;
4113 }
4114 if (arg1) (arg1)->x = arg2;
4115
4116 Py_INCREF(Py_None); resultobj = Py_None;
4117 return resultobj;
4118 fail:
4119 return NULL;
4120 }
4121
4122
4123 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4124 PyObject *resultobj = NULL;
4125 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4126 double result;
4127 PyObject * obj0 = 0 ;
4128 char *kwnames[] = {
4129 (char *) "self", NULL
4130 };
4131
4132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4134 if (SWIG_arg_fail(1)) SWIG_fail;
4135 result = (double) ((arg1)->x);
4136
4137 {
4138 resultobj = SWIG_From_double(static_cast<double >(result));
4139 }
4140 return resultobj;
4141 fail:
4142 return NULL;
4143 }
4144
4145
4146 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4147 PyObject *resultobj = NULL;
4148 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4149 double arg2 ;
4150 PyObject * obj0 = 0 ;
4151 PyObject * obj1 = 0 ;
4152 char *kwnames[] = {
4153 (char *) "self",(char *) "y", NULL
4154 };
4155
4156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4158 if (SWIG_arg_fail(1)) SWIG_fail;
4159 {
4160 arg2 = static_cast<double >(SWIG_As_double(obj1));
4161 if (SWIG_arg_fail(2)) SWIG_fail;
4162 }
4163 if (arg1) (arg1)->y = arg2;
4164
4165 Py_INCREF(Py_None); resultobj = Py_None;
4166 return resultobj;
4167 fail:
4168 return NULL;
4169 }
4170
4171
4172 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4173 PyObject *resultobj = NULL;
4174 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4175 double result;
4176 PyObject * obj0 = 0 ;
4177 char *kwnames[] = {
4178 (char *) "self", NULL
4179 };
4180
4181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4183 if (SWIG_arg_fail(1)) SWIG_fail;
4184 result = (double) ((arg1)->y);
4185
4186 {
4187 resultobj = SWIG_From_double(static_cast<double >(result));
4188 }
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj = NULL;
4197 double arg1 = (double) 0.0 ;
4198 double arg2 = (double) 0.0 ;
4199 wxRealPoint *result;
4200 PyObject * obj0 = 0 ;
4201 PyObject * obj1 = 0 ;
4202 char *kwnames[] = {
4203 (char *) "x",(char *) "y", NULL
4204 };
4205
4206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4207 if (obj0) {
4208 {
4209 arg1 = static_cast<double >(SWIG_As_double(obj0));
4210 if (SWIG_arg_fail(1)) SWIG_fail;
4211 }
4212 }
4213 if (obj1) {
4214 {
4215 arg2 = static_cast<double >(SWIG_As_double(obj1));
4216 if (SWIG_arg_fail(2)) SWIG_fail;
4217 }
4218 }
4219 {
4220 PyThreadState* __tstate = wxPyBeginAllowThreads();
4221 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4222
4223 wxPyEndAllowThreads(__tstate);
4224 if (PyErr_Occurred()) SWIG_fail;
4225 }
4226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4227 return resultobj;
4228 fail:
4229 return NULL;
4230 }
4231
4232
4233 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4234 PyObject *resultobj = NULL;
4235 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4236 PyObject * obj0 = 0 ;
4237 char *kwnames[] = {
4238 (char *) "self", NULL
4239 };
4240
4241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4243 if (SWIG_arg_fail(1)) SWIG_fail;
4244 {
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 delete arg1;
4247
4248 wxPyEndAllowThreads(__tstate);
4249 if (PyErr_Occurred()) SWIG_fail;
4250 }
4251 Py_INCREF(Py_None); resultobj = Py_None;
4252 return resultobj;
4253 fail:
4254 return NULL;
4255 }
4256
4257
4258 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4259 PyObject *resultobj = NULL;
4260 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4261 wxRealPoint *arg2 = 0 ;
4262 bool result;
4263 wxRealPoint temp2 ;
4264 PyObject * obj0 = 0 ;
4265 PyObject * obj1 = 0 ;
4266 char *kwnames[] = {
4267 (char *) "self",(char *) "pt", NULL
4268 };
4269
4270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4272 if (SWIG_arg_fail(1)) SWIG_fail;
4273 {
4274 arg2 = &temp2;
4275 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4276 }
4277 {
4278 PyThreadState* __tstate = wxPyBeginAllowThreads();
4279 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4280
4281 wxPyEndAllowThreads(__tstate);
4282 if (PyErr_Occurred()) SWIG_fail;
4283 }
4284 {
4285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4286 }
4287 return resultobj;
4288 fail:
4289 return NULL;
4290 }
4291
4292
4293 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4294 PyObject *resultobj = NULL;
4295 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4296 wxRealPoint *arg2 = 0 ;
4297 bool result;
4298 wxRealPoint temp2 ;
4299 PyObject * obj0 = 0 ;
4300 PyObject * obj1 = 0 ;
4301 char *kwnames[] = {
4302 (char *) "self",(char *) "pt", NULL
4303 };
4304
4305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4307 if (SWIG_arg_fail(1)) SWIG_fail;
4308 {
4309 arg2 = &temp2;
4310 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4311 }
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4315
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 {
4320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4321 }
4322 return resultobj;
4323 fail:
4324 return NULL;
4325 }
4326
4327
4328 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4329 PyObject *resultobj = NULL;
4330 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4331 wxRealPoint *arg2 = 0 ;
4332 wxRealPoint result;
4333 wxRealPoint temp2 ;
4334 PyObject * obj0 = 0 ;
4335 PyObject * obj1 = 0 ;
4336 char *kwnames[] = {
4337 (char *) "self",(char *) "pt", NULL
4338 };
4339
4340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4342 if (SWIG_arg_fail(1)) SWIG_fail;
4343 {
4344 arg2 = &temp2;
4345 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4346 }
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4350
4351 wxPyEndAllowThreads(__tstate);
4352 if (PyErr_Occurred()) SWIG_fail;
4353 }
4354 {
4355 wxRealPoint * resultptr;
4356 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4358 }
4359 return resultobj;
4360 fail:
4361 return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj = NULL;
4367 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4368 wxRealPoint *arg2 = 0 ;
4369 wxRealPoint result;
4370 wxRealPoint temp2 ;
4371 PyObject * obj0 = 0 ;
4372 PyObject * obj1 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self",(char *) "pt", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4379 if (SWIG_arg_fail(1)) SWIG_fail;
4380 {
4381 arg2 = &temp2;
4382 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4383 }
4384 {
4385 PyThreadState* __tstate = wxPyBeginAllowThreads();
4386 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4387
4388 wxPyEndAllowThreads(__tstate);
4389 if (PyErr_Occurred()) SWIG_fail;
4390 }
4391 {
4392 wxRealPoint * resultptr;
4393 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4395 }
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj = NULL;
4404 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4405 double arg2 ;
4406 double arg3 ;
4407 PyObject * obj0 = 0 ;
4408 PyObject * obj1 = 0 ;
4409 PyObject * obj2 = 0 ;
4410 char *kwnames[] = {
4411 (char *) "self",(char *) "x",(char *) "y", NULL
4412 };
4413
4414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4416 if (SWIG_arg_fail(1)) SWIG_fail;
4417 {
4418 arg2 = static_cast<double >(SWIG_As_double(obj1));
4419 if (SWIG_arg_fail(2)) SWIG_fail;
4420 }
4421 {
4422 arg3 = static_cast<double >(SWIG_As_double(obj2));
4423 if (SWIG_arg_fail(3)) SWIG_fail;
4424 }
4425 {
4426 PyThreadState* __tstate = wxPyBeginAllowThreads();
4427 wxRealPoint_Set(arg1,arg2,arg3);
4428
4429 wxPyEndAllowThreads(__tstate);
4430 if (PyErr_Occurred()) SWIG_fail;
4431 }
4432 Py_INCREF(Py_None); resultobj = Py_None;
4433 return resultobj;
4434 fail:
4435 return NULL;
4436 }
4437
4438
4439 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4440 PyObject *resultobj = NULL;
4441 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4442 PyObject *result;
4443 PyObject * obj0 = 0 ;
4444 char *kwnames[] = {
4445 (char *) "self", NULL
4446 };
4447
4448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4450 if (SWIG_arg_fail(1)) SWIG_fail;
4451 {
4452 PyThreadState* __tstate = wxPyBeginAllowThreads();
4453 result = (PyObject *)wxRealPoint_Get(arg1);
4454
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 resultobj = result;
4459 return resultobj;
4460 fail:
4461 return NULL;
4462 }
4463
4464
4465 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4466 PyObject *obj;
4467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4468 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4469 Py_INCREF(obj);
4470 return Py_BuildValue((char *)"");
4471 }
4472 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj = NULL;
4474 wxPoint *arg1 = (wxPoint *) 0 ;
4475 int arg2 ;
4476 PyObject * obj0 = 0 ;
4477 PyObject * obj1 = 0 ;
4478 char *kwnames[] = {
4479 (char *) "self",(char *) "x", NULL
4480 };
4481
4482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4484 if (SWIG_arg_fail(1)) SWIG_fail;
4485 {
4486 arg2 = static_cast<int >(SWIG_As_int(obj1));
4487 if (SWIG_arg_fail(2)) SWIG_fail;
4488 }
4489 if (arg1) (arg1)->x = arg2;
4490
4491 Py_INCREF(Py_None); resultobj = Py_None;
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj = NULL;
4500 wxPoint *arg1 = (wxPoint *) 0 ;
4501 int result;
4502 PyObject * obj0 = 0 ;
4503 char *kwnames[] = {
4504 (char *) "self", NULL
4505 };
4506
4507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4509 if (SWIG_arg_fail(1)) SWIG_fail;
4510 result = (int) ((arg1)->x);
4511
4512 {
4513 resultobj = SWIG_From_int(static_cast<int >(result));
4514 }
4515 return resultobj;
4516 fail:
4517 return NULL;
4518 }
4519
4520
4521 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4522 PyObject *resultobj = NULL;
4523 wxPoint *arg1 = (wxPoint *) 0 ;
4524 int arg2 ;
4525 PyObject * obj0 = 0 ;
4526 PyObject * obj1 = 0 ;
4527 char *kwnames[] = {
4528 (char *) "self",(char *) "y", NULL
4529 };
4530
4531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4533 if (SWIG_arg_fail(1)) SWIG_fail;
4534 {
4535 arg2 = static_cast<int >(SWIG_As_int(obj1));
4536 if (SWIG_arg_fail(2)) SWIG_fail;
4537 }
4538 if (arg1) (arg1)->y = arg2;
4539
4540 Py_INCREF(Py_None); resultobj = Py_None;
4541 return resultobj;
4542 fail:
4543 return NULL;
4544 }
4545
4546
4547 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj = NULL;
4549 wxPoint *arg1 = (wxPoint *) 0 ;
4550 int result;
4551 PyObject * obj0 = 0 ;
4552 char *kwnames[] = {
4553 (char *) "self", NULL
4554 };
4555
4556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4558 if (SWIG_arg_fail(1)) SWIG_fail;
4559 result = (int) ((arg1)->y);
4560
4561 {
4562 resultobj = SWIG_From_int(static_cast<int >(result));
4563 }
4564 return resultobj;
4565 fail:
4566 return NULL;
4567 }
4568
4569
4570 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4571 PyObject *resultobj = NULL;
4572 int arg1 = (int) 0 ;
4573 int arg2 = (int) 0 ;
4574 wxPoint *result;
4575 PyObject * obj0 = 0 ;
4576 PyObject * obj1 = 0 ;
4577 char *kwnames[] = {
4578 (char *) "x",(char *) "y", NULL
4579 };
4580
4581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4582 if (obj0) {
4583 {
4584 arg1 = static_cast<int >(SWIG_As_int(obj0));
4585 if (SWIG_arg_fail(1)) SWIG_fail;
4586 }
4587 }
4588 if (obj1) {
4589 {
4590 arg2 = static_cast<int >(SWIG_As_int(obj1));
4591 if (SWIG_arg_fail(2)) SWIG_fail;
4592 }
4593 }
4594 {
4595 PyThreadState* __tstate = wxPyBeginAllowThreads();
4596 result = (wxPoint *)new wxPoint(arg1,arg2);
4597
4598 wxPyEndAllowThreads(__tstate);
4599 if (PyErr_Occurred()) SWIG_fail;
4600 }
4601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4602 return resultobj;
4603 fail:
4604 return NULL;
4605 }
4606
4607
4608 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4609 PyObject *resultobj = NULL;
4610 wxPoint *arg1 = (wxPoint *) 0 ;
4611 PyObject * obj0 = 0 ;
4612 char *kwnames[] = {
4613 (char *) "self", NULL
4614 };
4615
4616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4618 if (SWIG_arg_fail(1)) SWIG_fail;
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 delete arg1;
4622
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 Py_INCREF(Py_None); resultobj = Py_None;
4627 return resultobj;
4628 fail:
4629 return NULL;
4630 }
4631
4632
4633 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4634 PyObject *resultobj = NULL;
4635 wxPoint *arg1 = (wxPoint *) 0 ;
4636 wxPoint *arg2 = 0 ;
4637 bool result;
4638 wxPoint temp2 ;
4639 PyObject * obj0 = 0 ;
4640 PyObject * obj1 = 0 ;
4641 char *kwnames[] = {
4642 (char *) "self",(char *) "pt", NULL
4643 };
4644
4645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4647 if (SWIG_arg_fail(1)) SWIG_fail;
4648 {
4649 arg2 = &temp2;
4650 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4651 }
4652 {
4653 PyThreadState* __tstate = wxPyBeginAllowThreads();
4654 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4655
4656 wxPyEndAllowThreads(__tstate);
4657 if (PyErr_Occurred()) SWIG_fail;
4658 }
4659 {
4660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4661 }
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj = NULL;
4670 wxPoint *arg1 = (wxPoint *) 0 ;
4671 wxPoint *arg2 = 0 ;
4672 bool result;
4673 wxPoint temp2 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 char *kwnames[] = {
4677 (char *) "self",(char *) "pt", NULL
4678 };
4679
4680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4682 if (SWIG_arg_fail(1)) SWIG_fail;
4683 {
4684 arg2 = &temp2;
4685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4686 }
4687 {
4688 PyThreadState* __tstate = wxPyBeginAllowThreads();
4689 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4690
4691 wxPyEndAllowThreads(__tstate);
4692 if (PyErr_Occurred()) SWIG_fail;
4693 }
4694 {
4695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4696 }
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4704 PyObject *resultobj = NULL;
4705 wxPoint *arg1 = (wxPoint *) 0 ;
4706 wxPoint *arg2 = 0 ;
4707 wxPoint result;
4708 wxPoint temp2 ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 char *kwnames[] = {
4712 (char *) "self",(char *) "pt", NULL
4713 };
4714
4715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4717 if (SWIG_arg_fail(1)) SWIG_fail;
4718 {
4719 arg2 = &temp2;
4720 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4721 }
4722 {
4723 PyThreadState* __tstate = wxPyBeginAllowThreads();
4724 result = (arg1)->operator +((wxPoint const &)*arg2);
4725
4726 wxPyEndAllowThreads(__tstate);
4727 if (PyErr_Occurred()) SWIG_fail;
4728 }
4729 {
4730 wxPoint * resultptr;
4731 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4732 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4733 }
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj = NULL;
4742 wxPoint *arg1 = (wxPoint *) 0 ;
4743 wxPoint *arg2 = 0 ;
4744 wxPoint result;
4745 wxPoint temp2 ;
4746 PyObject * obj0 = 0 ;
4747 PyObject * obj1 = 0 ;
4748 char *kwnames[] = {
4749 (char *) "self",(char *) "pt", NULL
4750 };
4751
4752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4754 if (SWIG_arg_fail(1)) SWIG_fail;
4755 {
4756 arg2 = &temp2;
4757 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4758 }
4759 {
4760 PyThreadState* __tstate = wxPyBeginAllowThreads();
4761 result = (arg1)->operator -((wxPoint const &)*arg2);
4762
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 {
4767 wxPoint * resultptr;
4768 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4770 }
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4778 PyObject *resultobj = NULL;
4779 wxPoint *arg1 = (wxPoint *) 0 ;
4780 wxPoint *arg2 = 0 ;
4781 wxPoint *result;
4782 wxPoint temp2 ;
4783 PyObject * obj0 = 0 ;
4784 PyObject * obj1 = 0 ;
4785 char *kwnames[] = {
4786 (char *) "self",(char *) "pt", NULL
4787 };
4788
4789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4791 if (SWIG_arg_fail(1)) SWIG_fail;
4792 {
4793 arg2 = &temp2;
4794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4795 }
4796 {
4797 PyThreadState* __tstate = wxPyBeginAllowThreads();
4798 {
4799 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4800 result = (wxPoint *) &_result_ref;
4801 }
4802
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj = NULL;
4815 wxPoint *arg1 = (wxPoint *) 0 ;
4816 wxPoint *arg2 = 0 ;
4817 wxPoint *result;
4818 wxPoint temp2 ;
4819 PyObject * obj0 = 0 ;
4820 PyObject * obj1 = 0 ;
4821 char *kwnames[] = {
4822 (char *) "self",(char *) "pt", NULL
4823 };
4824
4825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4827 if (SWIG_arg_fail(1)) SWIG_fail;
4828 {
4829 arg2 = &temp2;
4830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4831 }
4832 {
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 {
4835 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4836 result = (wxPoint *) &_result_ref;
4837 }
4838
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = NULL;
4851 wxPoint *arg1 = (wxPoint *) 0 ;
4852 long arg2 ;
4853 long arg3 ;
4854 PyObject * obj0 = 0 ;
4855 PyObject * obj1 = 0 ;
4856 PyObject * obj2 = 0 ;
4857 char *kwnames[] = {
4858 (char *) "self",(char *) "x",(char *) "y", NULL
4859 };
4860
4861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4863 if (SWIG_arg_fail(1)) SWIG_fail;
4864 {
4865 arg2 = static_cast<long >(SWIG_As_long(obj1));
4866 if (SWIG_arg_fail(2)) SWIG_fail;
4867 }
4868 {
4869 arg3 = static_cast<long >(SWIG_As_long(obj2));
4870 if (SWIG_arg_fail(3)) SWIG_fail;
4871 }
4872 {
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 wxPoint_Set(arg1,arg2,arg3);
4875
4876 wxPyEndAllowThreads(__tstate);
4877 if (PyErr_Occurred()) SWIG_fail;
4878 }
4879 Py_INCREF(Py_None); resultobj = Py_None;
4880 return resultobj;
4881 fail:
4882 return NULL;
4883 }
4884
4885
4886 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4887 PyObject *resultobj = NULL;
4888 wxPoint *arg1 = (wxPoint *) 0 ;
4889 PyObject *result;
4890 PyObject * obj0 = 0 ;
4891 char *kwnames[] = {
4892 (char *) "self", NULL
4893 };
4894
4895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4897 if (SWIG_arg_fail(1)) SWIG_fail;
4898 {
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 result = (PyObject *)wxPoint_Get(arg1);
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = result;
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4913 PyObject *obj;
4914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4915 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4916 Py_INCREF(obj);
4917 return Py_BuildValue((char *)"");
4918 }
4919 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = NULL;
4921 int arg1 = (int) 0 ;
4922 int arg2 = (int) 0 ;
4923 int arg3 = (int) 0 ;
4924 int arg4 = (int) 0 ;
4925 wxRect *result;
4926 PyObject * obj0 = 0 ;
4927 PyObject * obj1 = 0 ;
4928 PyObject * obj2 = 0 ;
4929 PyObject * obj3 = 0 ;
4930 char *kwnames[] = {
4931 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4932 };
4933
4934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4935 if (obj0) {
4936 {
4937 arg1 = static_cast<int >(SWIG_As_int(obj0));
4938 if (SWIG_arg_fail(1)) SWIG_fail;
4939 }
4940 }
4941 if (obj1) {
4942 {
4943 arg2 = static_cast<int >(SWIG_As_int(obj1));
4944 if (SWIG_arg_fail(2)) SWIG_fail;
4945 }
4946 }
4947 if (obj2) {
4948 {
4949 arg3 = static_cast<int >(SWIG_As_int(obj2));
4950 if (SWIG_arg_fail(3)) SWIG_fail;
4951 }
4952 }
4953 if (obj3) {
4954 {
4955 arg4 = static_cast<int >(SWIG_As_int(obj3));
4956 if (SWIG_arg_fail(4)) SWIG_fail;
4957 }
4958 }
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4962
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4967 return resultobj;
4968 fail:
4969 return NULL;
4970 }
4971
4972
4973 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4974 PyObject *resultobj = NULL;
4975 wxPoint *arg1 = 0 ;
4976 wxPoint *arg2 = 0 ;
4977 wxRect *result;
4978 wxPoint temp1 ;
4979 wxPoint temp2 ;
4980 PyObject * obj0 = 0 ;
4981 PyObject * obj1 = 0 ;
4982 char *kwnames[] = {
4983 (char *) "topLeft",(char *) "bottomRight", NULL
4984 };
4985
4986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4987 {
4988 arg1 = &temp1;
4989 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4990 }
4991 {
4992 arg2 = &temp2;
4993 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4994 }
4995 {
4996 PyThreadState* __tstate = wxPyBeginAllowThreads();
4997 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4998
4999 wxPyEndAllowThreads(__tstate);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5010 PyObject *resultobj = NULL;
5011 wxPoint *arg1 = 0 ;
5012 wxSize *arg2 = 0 ;
5013 wxRect *result;
5014 wxPoint temp1 ;
5015 wxSize temp2 ;
5016 PyObject * obj0 = 0 ;
5017 PyObject * obj1 = 0 ;
5018 char *kwnames[] = {
5019 (char *) "pos",(char *) "size", NULL
5020 };
5021
5022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5023 {
5024 arg1 = &temp1;
5025 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5026 }
5027 {
5028 arg2 = &temp2;
5029 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5030 }
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5034
5035 wxPyEndAllowThreads(__tstate);
5036 if (PyErr_Occurred()) SWIG_fail;
5037 }
5038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5039 return resultobj;
5040 fail:
5041 return NULL;
5042 }
5043
5044
5045 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5046 PyObject *resultobj = NULL;
5047 wxSize *arg1 = 0 ;
5048 wxRect *result;
5049 wxSize temp1 ;
5050 PyObject * obj0 = 0 ;
5051 char *kwnames[] = {
5052 (char *) "size", NULL
5053 };
5054
5055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5056 {
5057 arg1 = &temp1;
5058 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5059 }
5060 {
5061 PyThreadState* __tstate = wxPyBeginAllowThreads();
5062 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5063
5064 wxPyEndAllowThreads(__tstate);
5065 if (PyErr_Occurred()) SWIG_fail;
5066 }
5067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5075 PyObject *resultobj = NULL;
5076 wxRect *arg1 = (wxRect *) 0 ;
5077 PyObject * obj0 = 0 ;
5078 char *kwnames[] = {
5079 (char *) "self", NULL
5080 };
5081
5082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5084 if (SWIG_arg_fail(1)) SWIG_fail;
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 delete arg1;
5088
5089 wxPyEndAllowThreads(__tstate);
5090 if (PyErr_Occurred()) SWIG_fail;
5091 }
5092 Py_INCREF(Py_None); resultobj = Py_None;
5093 return resultobj;
5094 fail:
5095 return NULL;
5096 }
5097
5098
5099 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5100 PyObject *resultobj = NULL;
5101 wxRect *arg1 = (wxRect *) 0 ;
5102 int result;
5103 PyObject * obj0 = 0 ;
5104 char *kwnames[] = {
5105 (char *) "self", NULL
5106 };
5107
5108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5110 if (SWIG_arg_fail(1)) SWIG_fail;
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (int)((wxRect const *)arg1)->GetX();
5114
5115 wxPyEndAllowThreads(__tstate);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 {
5119 resultobj = SWIG_From_int(static_cast<int >(result));
5120 }
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj = NULL;
5129 wxRect *arg1 = (wxRect *) 0 ;
5130 int arg2 ;
5131 PyObject * obj0 = 0 ;
5132 PyObject * obj1 = 0 ;
5133 char *kwnames[] = {
5134 (char *) "self",(char *) "x", NULL
5135 };
5136
5137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5139 if (SWIG_arg_fail(1)) SWIG_fail;
5140 {
5141 arg2 = static_cast<int >(SWIG_As_int(obj1));
5142 if (SWIG_arg_fail(2)) SWIG_fail;
5143 }
5144 {
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 (arg1)->SetX(arg2);
5147
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 Py_INCREF(Py_None); resultobj = Py_None;
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5159 PyObject *resultobj = NULL;
5160 wxRect *arg1 = (wxRect *) 0 ;
5161 int result;
5162 PyObject * obj0 = 0 ;
5163 char *kwnames[] = {
5164 (char *) "self", NULL
5165 };
5166
5167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5169 if (SWIG_arg_fail(1)) SWIG_fail;
5170 {
5171 PyThreadState* __tstate = wxPyBeginAllowThreads();
5172 result = (int)(arg1)->GetY();
5173
5174 wxPyEndAllowThreads(__tstate);
5175 if (PyErr_Occurred()) SWIG_fail;
5176 }
5177 {
5178 resultobj = SWIG_From_int(static_cast<int >(result));
5179 }
5180 return resultobj;
5181 fail:
5182 return NULL;
5183 }
5184
5185
5186 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5187 PyObject *resultobj = NULL;
5188 wxRect *arg1 = (wxRect *) 0 ;
5189 int arg2 ;
5190 PyObject * obj0 = 0 ;
5191 PyObject * obj1 = 0 ;
5192 char *kwnames[] = {
5193 (char *) "self",(char *) "y", NULL
5194 };
5195
5196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5198 if (SWIG_arg_fail(1)) SWIG_fail;
5199 {
5200 arg2 = static_cast<int >(SWIG_As_int(obj1));
5201 if (SWIG_arg_fail(2)) SWIG_fail;
5202 }
5203 {
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 (arg1)->SetY(arg2);
5206
5207 wxPyEndAllowThreads(__tstate);
5208 if (PyErr_Occurred()) SWIG_fail;
5209 }
5210 Py_INCREF(Py_None); resultobj = Py_None;
5211 return resultobj;
5212 fail:
5213 return NULL;
5214 }
5215
5216
5217 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5218 PyObject *resultobj = NULL;
5219 wxRect *arg1 = (wxRect *) 0 ;
5220 int result;
5221 PyObject * obj0 = 0 ;
5222 char *kwnames[] = {
5223 (char *) "self", NULL
5224 };
5225
5226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5228 if (SWIG_arg_fail(1)) SWIG_fail;
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 result = (int)((wxRect const *)arg1)->GetWidth();
5232
5233 wxPyEndAllowThreads(__tstate);
5234 if (PyErr_Occurred()) SWIG_fail;
5235 }
5236 {
5237 resultobj = SWIG_From_int(static_cast<int >(result));
5238 }
5239 return resultobj;
5240 fail:
5241 return NULL;
5242 }
5243
5244
5245 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj = NULL;
5247 wxRect *arg1 = (wxRect *) 0 ;
5248 int arg2 ;
5249 PyObject * obj0 = 0 ;
5250 PyObject * obj1 = 0 ;
5251 char *kwnames[] = {
5252 (char *) "self",(char *) "w", NULL
5253 };
5254
5255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5257 if (SWIG_arg_fail(1)) SWIG_fail;
5258 {
5259 arg2 = static_cast<int >(SWIG_As_int(obj1));
5260 if (SWIG_arg_fail(2)) SWIG_fail;
5261 }
5262 {
5263 PyThreadState* __tstate = wxPyBeginAllowThreads();
5264 (arg1)->SetWidth(arg2);
5265
5266 wxPyEndAllowThreads(__tstate);
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 Py_INCREF(Py_None); resultobj = Py_None;
5270 return resultobj;
5271 fail:
5272 return NULL;
5273 }
5274
5275
5276 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5277 PyObject *resultobj = NULL;
5278 wxRect *arg1 = (wxRect *) 0 ;
5279 int result;
5280 PyObject * obj0 = 0 ;
5281 char *kwnames[] = {
5282 (char *) "self", NULL
5283 };
5284
5285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5287 if (SWIG_arg_fail(1)) SWIG_fail;
5288 {
5289 PyThreadState* __tstate = wxPyBeginAllowThreads();
5290 result = (int)((wxRect const *)arg1)->GetHeight();
5291
5292 wxPyEndAllowThreads(__tstate);
5293 if (PyErr_Occurred()) SWIG_fail;
5294 }
5295 {
5296 resultobj = SWIG_From_int(static_cast<int >(result));
5297 }
5298 return resultobj;
5299 fail:
5300 return NULL;
5301 }
5302
5303
5304 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5305 PyObject *resultobj = NULL;
5306 wxRect *arg1 = (wxRect *) 0 ;
5307 int arg2 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 char *kwnames[] = {
5311 (char *) "self",(char *) "h", NULL
5312 };
5313
5314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5316 if (SWIG_arg_fail(1)) SWIG_fail;
5317 {
5318 arg2 = static_cast<int >(SWIG_As_int(obj1));
5319 if (SWIG_arg_fail(2)) SWIG_fail;
5320 }
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 (arg1)->SetHeight(arg2);
5324
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 Py_INCREF(Py_None); resultobj = Py_None;
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj = NULL;
5337 wxRect *arg1 = (wxRect *) 0 ;
5338 wxPoint result;
5339 PyObject * obj0 = 0 ;
5340 char *kwnames[] = {
5341 (char *) "self", NULL
5342 };
5343
5344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5346 if (SWIG_arg_fail(1)) SWIG_fail;
5347 {
5348 PyThreadState* __tstate = wxPyBeginAllowThreads();
5349 result = ((wxRect const *)arg1)->GetPosition();
5350
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 wxPoint * resultptr;
5356 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj = NULL;
5367 wxRect *arg1 = (wxRect *) 0 ;
5368 wxPoint *arg2 = 0 ;
5369 wxPoint temp2 ;
5370 PyObject * obj0 = 0 ;
5371 PyObject * obj1 = 0 ;
5372 char *kwnames[] = {
5373 (char *) "self",(char *) "p", NULL
5374 };
5375
5376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5378 if (SWIG_arg_fail(1)) SWIG_fail;
5379 {
5380 arg2 = &temp2;
5381 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5382 }
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 (arg1)->SetPosition((wxPoint const &)*arg2);
5386
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 Py_INCREF(Py_None); resultobj = Py_None;
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5398 PyObject *resultobj = NULL;
5399 wxRect *arg1 = (wxRect *) 0 ;
5400 wxSize result;
5401 PyObject * obj0 = 0 ;
5402 char *kwnames[] = {
5403 (char *) "self", NULL
5404 };
5405
5406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5408 if (SWIG_arg_fail(1)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = ((wxRect const *)arg1)->GetSize();
5412
5413 wxPyEndAllowThreads(__tstate);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 {
5417 wxSize * resultptr;
5418 resultptr = new wxSize(static_cast<wxSize & >(result));
5419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5420 }
5421 return resultobj;
5422 fail:
5423 return NULL;
5424 }
5425
5426
5427 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5428 PyObject *resultobj = NULL;
5429 wxRect *arg1 = (wxRect *) 0 ;
5430 wxSize *arg2 = 0 ;
5431 wxSize temp2 ;
5432 PyObject * obj0 = 0 ;
5433 PyObject * obj1 = 0 ;
5434 char *kwnames[] = {
5435 (char *) "self",(char *) "s", NULL
5436 };
5437
5438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5440 if (SWIG_arg_fail(1)) SWIG_fail;
5441 {
5442 arg2 = &temp2;
5443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5444 }
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 (arg1)->SetSize((wxSize const &)*arg2);
5448
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 Py_INCREF(Py_None); resultobj = Py_None;
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5460 PyObject *resultobj = NULL;
5461 wxRect *arg1 = (wxRect *) 0 ;
5462 bool result;
5463 PyObject * obj0 = 0 ;
5464 char *kwnames[] = {
5465 (char *) "self", NULL
5466 };
5467
5468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5470 if (SWIG_arg_fail(1)) SWIG_fail;
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 result = (bool)((wxRect const *)arg1)->IsEmpty();
5474
5475 wxPyEndAllowThreads(__tstate);
5476 if (PyErr_Occurred()) SWIG_fail;
5477 }
5478 {
5479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5480 }
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj = NULL;
5489 wxRect *arg1 = (wxRect *) 0 ;
5490 wxPoint result;
5491 PyObject * obj0 = 0 ;
5492 char *kwnames[] = {
5493 (char *) "self", NULL
5494 };
5495
5496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5498 if (SWIG_arg_fail(1)) SWIG_fail;
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = ((wxRect const *)arg1)->GetTopLeft();
5502
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 {
5507 wxPoint * resultptr;
5508 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5510 }
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = NULL;
5519 wxRect *arg1 = (wxRect *) 0 ;
5520 wxPoint *arg2 = 0 ;
5521 wxPoint temp2 ;
5522 PyObject * obj0 = 0 ;
5523 PyObject * obj1 = 0 ;
5524 char *kwnames[] = {
5525 (char *) "self",(char *) "p", NULL
5526 };
5527
5528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5530 if (SWIG_arg_fail(1)) SWIG_fail;
5531 {
5532 arg2 = &temp2;
5533 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5534 }
5535 {
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 Py_INCREF(Py_None); resultobj = Py_None;
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5550 PyObject *resultobj = NULL;
5551 wxRect *arg1 = (wxRect *) 0 ;
5552 wxPoint result;
5553 PyObject * obj0 = 0 ;
5554 char *kwnames[] = {
5555 (char *) "self", NULL
5556 };
5557
5558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5560 if (SWIG_arg_fail(1)) SWIG_fail;
5561 {
5562 PyThreadState* __tstate = wxPyBeginAllowThreads();
5563 result = ((wxRect const *)arg1)->GetBottomRight();
5564
5565 wxPyEndAllowThreads(__tstate);
5566 if (PyErr_Occurred()) SWIG_fail;
5567 }
5568 {
5569 wxPoint * resultptr;
5570 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5572 }
5573 return resultobj;
5574 fail:
5575 return NULL;
5576 }
5577
5578
5579 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5580 PyObject *resultobj = NULL;
5581 wxRect *arg1 = (wxRect *) 0 ;
5582 wxPoint *arg2 = 0 ;
5583 wxPoint temp2 ;
5584 PyObject * obj0 = 0 ;
5585 PyObject * obj1 = 0 ;
5586 char *kwnames[] = {
5587 (char *) "self",(char *) "p", NULL
5588 };
5589
5590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5592 if (SWIG_arg_fail(1)) SWIG_fail;
5593 {
5594 arg2 = &temp2;
5595 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5596 }
5597 {
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5600
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 Py_INCREF(Py_None); resultobj = Py_None;
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5612 PyObject *resultobj = NULL;
5613 wxRect *arg1 = (wxRect *) 0 ;
5614 int result;
5615 PyObject * obj0 = 0 ;
5616 char *kwnames[] = {
5617 (char *) "self", NULL
5618 };
5619
5620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5622 if (SWIG_arg_fail(1)) SWIG_fail;
5623 {
5624 PyThreadState* __tstate = wxPyBeginAllowThreads();
5625 result = (int)((wxRect const *)arg1)->GetLeft();
5626
5627 wxPyEndAllowThreads(__tstate);
5628 if (PyErr_Occurred()) SWIG_fail;
5629 }
5630 {
5631 resultobj = SWIG_From_int(static_cast<int >(result));
5632 }
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj = NULL;
5641 wxRect *arg1 = (wxRect *) 0 ;
5642 int result;
5643 PyObject * obj0 = 0 ;
5644 char *kwnames[] = {
5645 (char *) "self", NULL
5646 };
5647
5648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5650 if (SWIG_arg_fail(1)) SWIG_fail;
5651 {
5652 PyThreadState* __tstate = wxPyBeginAllowThreads();
5653 result = (int)((wxRect const *)arg1)->GetTop();
5654
5655 wxPyEndAllowThreads(__tstate);
5656 if (PyErr_Occurred()) SWIG_fail;
5657 }
5658 {
5659 resultobj = SWIG_From_int(static_cast<int >(result));
5660 }
5661 return resultobj;
5662 fail:
5663 return NULL;
5664 }
5665
5666
5667 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5668 PyObject *resultobj = NULL;
5669 wxRect *arg1 = (wxRect *) 0 ;
5670 int result;
5671 PyObject * obj0 = 0 ;
5672 char *kwnames[] = {
5673 (char *) "self", NULL
5674 };
5675
5676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5678 if (SWIG_arg_fail(1)) SWIG_fail;
5679 {
5680 PyThreadState* __tstate = wxPyBeginAllowThreads();
5681 result = (int)((wxRect const *)arg1)->GetBottom();
5682
5683 wxPyEndAllowThreads(__tstate);
5684 if (PyErr_Occurred()) SWIG_fail;
5685 }
5686 {
5687 resultobj = SWIG_From_int(static_cast<int >(result));
5688 }
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5696 PyObject *resultobj = NULL;
5697 wxRect *arg1 = (wxRect *) 0 ;
5698 int result;
5699 PyObject * obj0 = 0 ;
5700 char *kwnames[] = {
5701 (char *) "self", NULL
5702 };
5703
5704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5706 if (SWIG_arg_fail(1)) SWIG_fail;
5707 {
5708 PyThreadState* __tstate = wxPyBeginAllowThreads();
5709 result = (int)((wxRect const *)arg1)->GetRight();
5710
5711 wxPyEndAllowThreads(__tstate);
5712 if (PyErr_Occurred()) SWIG_fail;
5713 }
5714 {
5715 resultobj = SWIG_From_int(static_cast<int >(result));
5716 }
5717 return resultobj;
5718 fail:
5719 return NULL;
5720 }
5721
5722
5723 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5724 PyObject *resultobj = NULL;
5725 wxRect *arg1 = (wxRect *) 0 ;
5726 int arg2 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 char *kwnames[] = {
5730 (char *) "self",(char *) "left", NULL
5731 };
5732
5733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5735 if (SWIG_arg_fail(1)) SWIG_fail;
5736 {
5737 arg2 = static_cast<int >(SWIG_As_int(obj1));
5738 if (SWIG_arg_fail(2)) SWIG_fail;
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 (arg1)->SetLeft(arg2);
5743
5744 wxPyEndAllowThreads(__tstate);
5745 if (PyErr_Occurred()) SWIG_fail;
5746 }
5747 Py_INCREF(Py_None); resultobj = Py_None;
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5755 PyObject *resultobj = NULL;
5756 wxRect *arg1 = (wxRect *) 0 ;
5757 int arg2 ;
5758 PyObject * obj0 = 0 ;
5759 PyObject * obj1 = 0 ;
5760 char *kwnames[] = {
5761 (char *) "self",(char *) "right", NULL
5762 };
5763
5764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5766 if (SWIG_arg_fail(1)) SWIG_fail;
5767 {
5768 arg2 = static_cast<int >(SWIG_As_int(obj1));
5769 if (SWIG_arg_fail(2)) SWIG_fail;
5770 }
5771 {
5772 PyThreadState* __tstate = wxPyBeginAllowThreads();
5773 (arg1)->SetRight(arg2);
5774
5775 wxPyEndAllowThreads(__tstate);
5776 if (PyErr_Occurred()) SWIG_fail;
5777 }
5778 Py_INCREF(Py_None); resultobj = Py_None;
5779 return resultobj;
5780 fail:
5781 return NULL;
5782 }
5783
5784
5785 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj = NULL;
5787 wxRect *arg1 = (wxRect *) 0 ;
5788 int arg2 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 char *kwnames[] = {
5792 (char *) "self",(char *) "top", NULL
5793 };
5794
5795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5797 if (SWIG_arg_fail(1)) SWIG_fail;
5798 {
5799 arg2 = static_cast<int >(SWIG_As_int(obj1));
5800 if (SWIG_arg_fail(2)) SWIG_fail;
5801 }
5802 {
5803 PyThreadState* __tstate = wxPyBeginAllowThreads();
5804 (arg1)->SetTop(arg2);
5805
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 Py_INCREF(Py_None); resultobj = Py_None;
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj = NULL;
5818 wxRect *arg1 = (wxRect *) 0 ;
5819 int arg2 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char *kwnames[] = {
5823 (char *) "self",(char *) "bottom", NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5828 if (SWIG_arg_fail(1)) SWIG_fail;
5829 {
5830 arg2 = static_cast<int >(SWIG_As_int(obj1));
5831 if (SWIG_arg_fail(2)) SWIG_fail;
5832 }
5833 {
5834 PyThreadState* __tstate = wxPyBeginAllowThreads();
5835 (arg1)->SetBottom(arg2);
5836
5837 wxPyEndAllowThreads(__tstate);
5838 if (PyErr_Occurred()) SWIG_fail;
5839 }
5840 Py_INCREF(Py_None); resultobj = Py_None;
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = NULL;
5849 wxRect *arg1 = (wxRect *) 0 ;
5850 int arg2 ;
5851 int arg3 ;
5852 wxRect *result;
5853 PyObject * obj0 = 0 ;
5854 PyObject * obj1 = 0 ;
5855 PyObject * obj2 = 0 ;
5856 char *kwnames[] = {
5857 (char *) "self",(char *) "dx",(char *) "dy", NULL
5858 };
5859
5860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5862 if (SWIG_arg_fail(1)) SWIG_fail;
5863 {
5864 arg2 = static_cast<int >(SWIG_As_int(obj1));
5865 if (SWIG_arg_fail(2)) SWIG_fail;
5866 }
5867 {
5868 arg3 = static_cast<int >(SWIG_As_int(obj2));
5869 if (SWIG_arg_fail(3)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 {
5874 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5875 result = (wxRect *) &_result_ref;
5876 }
5877
5878 wxPyEndAllowThreads(__tstate);
5879 if (PyErr_Occurred()) SWIG_fail;
5880 }
5881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5882 return resultobj;
5883 fail:
5884 return NULL;
5885 }
5886
5887
5888 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5889 PyObject *resultobj = NULL;
5890 wxRect *arg1 = (wxRect *) 0 ;
5891 int arg2 ;
5892 int arg3 ;
5893 wxRect *result;
5894 PyObject * obj0 = 0 ;
5895 PyObject * obj1 = 0 ;
5896 PyObject * obj2 = 0 ;
5897 char *kwnames[] = {
5898 (char *) "self",(char *) "dx",(char *) "dy", NULL
5899 };
5900
5901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5903 if (SWIG_arg_fail(1)) SWIG_fail;
5904 {
5905 arg2 = static_cast<int >(SWIG_As_int(obj1));
5906 if (SWIG_arg_fail(2)) SWIG_fail;
5907 }
5908 {
5909 arg3 = static_cast<int >(SWIG_As_int(obj2));
5910 if (SWIG_arg_fail(3)) SWIG_fail;
5911 }
5912 {
5913 PyThreadState* __tstate = wxPyBeginAllowThreads();
5914 {
5915 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5916 result = (wxRect *) &_result_ref;
5917 }
5918
5919 wxPyEndAllowThreads(__tstate);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5923 return resultobj;
5924 fail:
5925 return NULL;
5926 }
5927
5928
5929 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5930 PyObject *resultobj = NULL;
5931 wxRect *arg1 = (wxRect *) 0 ;
5932 int arg2 ;
5933 int arg3 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 PyObject * obj2 = 0 ;
5937 char *kwnames[] = {
5938 (char *) "self",(char *) "dx",(char *) "dy", NULL
5939 };
5940
5941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5943 if (SWIG_arg_fail(1)) SWIG_fail;
5944 {
5945 arg2 = static_cast<int >(SWIG_As_int(obj1));
5946 if (SWIG_arg_fail(2)) SWIG_fail;
5947 }
5948 {
5949 arg3 = static_cast<int >(SWIG_As_int(obj2));
5950 if (SWIG_arg_fail(3)) SWIG_fail;
5951 }
5952 {
5953 PyThreadState* __tstate = wxPyBeginAllowThreads();
5954 (arg1)->Offset(arg2,arg3);
5955
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 Py_INCREF(Py_None); resultobj = Py_None;
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = NULL;
5968 wxRect *arg1 = (wxRect *) 0 ;
5969 wxPoint *arg2 = 0 ;
5970 wxPoint temp2 ;
5971 PyObject * obj0 = 0 ;
5972 PyObject * obj1 = 0 ;
5973 char *kwnames[] = {
5974 (char *) "self",(char *) "pt", NULL
5975 };
5976
5977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5979 if (SWIG_arg_fail(1)) SWIG_fail;
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 (arg1)->Offset((wxPoint const &)*arg2);
5987
5988 wxPyEndAllowThreads(__tstate);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 Py_INCREF(Py_None); resultobj = Py_None;
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj = NULL;
6000 wxRect *arg1 = (wxRect *) 0 ;
6001 wxRect *arg2 = 0 ;
6002 wxRect result;
6003 wxRect temp2 ;
6004 PyObject * obj0 = 0 ;
6005 PyObject * obj1 = 0 ;
6006 char *kwnames[] = {
6007 (char *) "self",(char *) "rect", NULL
6008 };
6009
6010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6012 if (SWIG_arg_fail(1)) SWIG_fail;
6013 {
6014 arg2 = &temp2;
6015 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6016 }
6017 {
6018 PyThreadState* __tstate = wxPyBeginAllowThreads();
6019 result = (arg1)->Intersect((wxRect const &)*arg2);
6020
6021 wxPyEndAllowThreads(__tstate);
6022 if (PyErr_Occurred()) SWIG_fail;
6023 }
6024 {
6025 wxRect * resultptr;
6026 resultptr = new wxRect(static_cast<wxRect & >(result));
6027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6028 }
6029 return resultobj;
6030 fail:
6031 return NULL;
6032 }
6033
6034
6035 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6036 PyObject *resultobj = NULL;
6037 wxRect *arg1 = (wxRect *) 0 ;
6038 wxRect *arg2 = 0 ;
6039 wxRect result;
6040 wxRect temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "self",(char *) "rect", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6049 if (SWIG_arg_fail(1)) SWIG_fail;
6050 {
6051 arg2 = &temp2;
6052 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6053 }
6054 {
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 result = (arg1)->Union((wxRect const &)*arg2);
6057
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 {
6062 wxRect * resultptr;
6063 resultptr = new wxRect(static_cast<wxRect & >(result));
6064 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6065 }
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj = NULL;
6074 wxRect *arg1 = (wxRect *) 0 ;
6075 wxRect *arg2 = 0 ;
6076 wxRect result;
6077 wxRect temp2 ;
6078 PyObject * obj0 = 0 ;
6079 PyObject * obj1 = 0 ;
6080 char *kwnames[] = {
6081 (char *) "self",(char *) "rect", NULL
6082 };
6083
6084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6086 if (SWIG_arg_fail(1)) SWIG_fail;
6087 {
6088 arg2 = &temp2;
6089 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6090 }
6091 {
6092 PyThreadState* __tstate = wxPyBeginAllowThreads();
6093 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6094
6095 wxPyEndAllowThreads(__tstate);
6096 if (PyErr_Occurred()) SWIG_fail;
6097 }
6098 {
6099 wxRect * resultptr;
6100 resultptr = new wxRect(static_cast<wxRect & >(result));
6101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6102 }
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj = NULL;
6111 wxRect *arg1 = (wxRect *) 0 ;
6112 wxRect *arg2 = 0 ;
6113 wxRect *result;
6114 wxRect temp2 ;
6115 PyObject * obj0 = 0 ;
6116 PyObject * obj1 = 0 ;
6117 char *kwnames[] = {
6118 (char *) "self",(char *) "rect", NULL
6119 };
6120
6121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6123 if (SWIG_arg_fail(1)) SWIG_fail;
6124 {
6125 arg2 = &temp2;
6126 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6127 }
6128 {
6129 PyThreadState* __tstate = wxPyBeginAllowThreads();
6130 {
6131 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6132 result = (wxRect *) &_result_ref;
6133 }
6134
6135 wxPyEndAllowThreads(__tstate);
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj = NULL;
6147 wxRect *arg1 = (wxRect *) 0 ;
6148 wxRect *arg2 = 0 ;
6149 bool result;
6150 wxRect temp2 ;
6151 PyObject * obj0 = 0 ;
6152 PyObject * obj1 = 0 ;
6153 char *kwnames[] = {
6154 (char *) "self",(char *) "rect", NULL
6155 };
6156
6157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6159 if (SWIG_arg_fail(1)) SWIG_fail;
6160 {
6161 arg2 = &temp2;
6162 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6163 }
6164 {
6165 PyThreadState* __tstate = wxPyBeginAllowThreads();
6166 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6167
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 {
6172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6173 }
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj = NULL;
6182 wxRect *arg1 = (wxRect *) 0 ;
6183 wxRect *arg2 = 0 ;
6184 bool result;
6185 wxRect temp2 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self",(char *) "rect", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 {
6196 arg2 = &temp2;
6197 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6198 }
6199 {
6200 PyThreadState* __tstate = wxPyBeginAllowThreads();
6201 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6202
6203 wxPyEndAllowThreads(__tstate);
6204 if (PyErr_Occurred()) SWIG_fail;
6205 }
6206 {
6207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6208 }
6209 return resultobj;
6210 fail:
6211 return NULL;
6212 }
6213
6214
6215 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6216 PyObject *resultobj = NULL;
6217 wxRect *arg1 = (wxRect *) 0 ;
6218 int arg2 ;
6219 int arg3 ;
6220 bool result;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6223 PyObject * obj2 = 0 ;
6224 char *kwnames[] = {
6225 (char *) "self",(char *) "x",(char *) "y", NULL
6226 };
6227
6228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6230 if (SWIG_arg_fail(1)) SWIG_fail;
6231 {
6232 arg2 = static_cast<int >(SWIG_As_int(obj1));
6233 if (SWIG_arg_fail(2)) SWIG_fail;
6234 }
6235 {
6236 arg3 = static_cast<int >(SWIG_As_int(obj2));
6237 if (SWIG_arg_fail(3)) SWIG_fail;
6238 }
6239 {
6240 PyThreadState* __tstate = wxPyBeginAllowThreads();
6241 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6242
6243 wxPyEndAllowThreads(__tstate);
6244 if (PyErr_Occurred()) SWIG_fail;
6245 }
6246 {
6247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6248 }
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj = NULL;
6257 wxRect *arg1 = (wxRect *) 0 ;
6258 wxPoint *arg2 = 0 ;
6259 bool result;
6260 wxPoint temp2 ;
6261 PyObject * obj0 = 0 ;
6262 PyObject * obj1 = 0 ;
6263 char *kwnames[] = {
6264 (char *) "self",(char *) "pt", NULL
6265 };
6266
6267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6269 if (SWIG_arg_fail(1)) SWIG_fail;
6270 {
6271 arg2 = &temp2;
6272 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6273 }
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6277
6278 wxPyEndAllowThreads(__tstate);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 {
6282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6283 }
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj = NULL;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 wxRect *arg2 = 0 ;
6294 bool result;
6295 wxRect temp2 ;
6296 PyObject * obj0 = 0 ;
6297 PyObject * obj1 = 0 ;
6298 char *kwnames[] = {
6299 (char *) "self",(char *) "rect", NULL
6300 };
6301
6302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6304 if (SWIG_arg_fail(1)) SWIG_fail;
6305 {
6306 arg2 = &temp2;
6307 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6308 }
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6312
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 {
6317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6318 }
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj = NULL;
6327 wxRect *arg1 = (wxRect *) 0 ;
6328 int arg2 ;
6329 PyObject * obj0 = 0 ;
6330 PyObject * obj1 = 0 ;
6331 char *kwnames[] = {
6332 (char *) "self",(char *) "x", NULL
6333 };
6334
6335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6337 if (SWIG_arg_fail(1)) SWIG_fail;
6338 {
6339 arg2 = static_cast<int >(SWIG_As_int(obj1));
6340 if (SWIG_arg_fail(2)) SWIG_fail;
6341 }
6342 if (arg1) (arg1)->x = arg2;
6343
6344 Py_INCREF(Py_None); resultobj = Py_None;
6345 return resultobj;
6346 fail:
6347 return NULL;
6348 }
6349
6350
6351 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj = NULL;
6353 wxRect *arg1 = (wxRect *) 0 ;
6354 int result;
6355 PyObject * obj0 = 0 ;
6356 char *kwnames[] = {
6357 (char *) "self", NULL
6358 };
6359
6360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6362 if (SWIG_arg_fail(1)) SWIG_fail;
6363 result = (int) ((arg1)->x);
6364
6365 {
6366 resultobj = SWIG_From_int(static_cast<int >(result));
6367 }
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6375 PyObject *resultobj = NULL;
6376 wxRect *arg1 = (wxRect *) 0 ;
6377 int arg2 ;
6378 PyObject * obj0 = 0 ;
6379 PyObject * obj1 = 0 ;
6380 char *kwnames[] = {
6381 (char *) "self",(char *) "y", NULL
6382 };
6383
6384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6386 if (SWIG_arg_fail(1)) SWIG_fail;
6387 {
6388 arg2 = static_cast<int >(SWIG_As_int(obj1));
6389 if (SWIG_arg_fail(2)) SWIG_fail;
6390 }
6391 if (arg1) (arg1)->y = arg2;
6392
6393 Py_INCREF(Py_None); resultobj = Py_None;
6394 return resultobj;
6395 fail:
6396 return NULL;
6397 }
6398
6399
6400 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6401 PyObject *resultobj = NULL;
6402 wxRect *arg1 = (wxRect *) 0 ;
6403 int result;
6404 PyObject * obj0 = 0 ;
6405 char *kwnames[] = {
6406 (char *) "self", NULL
6407 };
6408
6409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6411 if (SWIG_arg_fail(1)) SWIG_fail;
6412 result = (int) ((arg1)->y);
6413
6414 {
6415 resultobj = SWIG_From_int(static_cast<int >(result));
6416 }
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj = NULL;
6425 wxRect *arg1 = (wxRect *) 0 ;
6426 int arg2 ;
6427 PyObject * obj0 = 0 ;
6428 PyObject * obj1 = 0 ;
6429 char *kwnames[] = {
6430 (char *) "self",(char *) "width", NULL
6431 };
6432
6433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6435 if (SWIG_arg_fail(1)) SWIG_fail;
6436 {
6437 arg2 = static_cast<int >(SWIG_As_int(obj1));
6438 if (SWIG_arg_fail(2)) SWIG_fail;
6439 }
6440 if (arg1) (arg1)->width = arg2;
6441
6442 Py_INCREF(Py_None); resultobj = Py_None;
6443 return resultobj;
6444 fail:
6445 return NULL;
6446 }
6447
6448
6449 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6450 PyObject *resultobj = NULL;
6451 wxRect *arg1 = (wxRect *) 0 ;
6452 int result;
6453 PyObject * obj0 = 0 ;
6454 char *kwnames[] = {
6455 (char *) "self", NULL
6456 };
6457
6458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6460 if (SWIG_arg_fail(1)) SWIG_fail;
6461 result = (int) ((arg1)->width);
6462
6463 {
6464 resultobj = SWIG_From_int(static_cast<int >(result));
6465 }
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj = NULL;
6474 wxRect *arg1 = (wxRect *) 0 ;
6475 int arg2 ;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 char *kwnames[] = {
6479 (char *) "self",(char *) "height", NULL
6480 };
6481
6482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6484 if (SWIG_arg_fail(1)) SWIG_fail;
6485 {
6486 arg2 = static_cast<int >(SWIG_As_int(obj1));
6487 if (SWIG_arg_fail(2)) SWIG_fail;
6488 }
6489 if (arg1) (arg1)->height = arg2;
6490
6491 Py_INCREF(Py_None); resultobj = Py_None;
6492 return resultobj;
6493 fail:
6494 return NULL;
6495 }
6496
6497
6498 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj = NULL;
6500 wxRect *arg1 = (wxRect *) 0 ;
6501 int result;
6502 PyObject * obj0 = 0 ;
6503 char *kwnames[] = {
6504 (char *) "self", NULL
6505 };
6506
6507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6509 if (SWIG_arg_fail(1)) SWIG_fail;
6510 result = (int) ((arg1)->height);
6511
6512 {
6513 resultobj = SWIG_From_int(static_cast<int >(result));
6514 }
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6522 PyObject *resultobj = NULL;
6523 wxRect *arg1 = (wxRect *) 0 ;
6524 int arg2 = (int) 0 ;
6525 int arg3 = (int) 0 ;
6526 int arg4 = (int) 0 ;
6527 int arg5 = (int) 0 ;
6528 PyObject * obj0 = 0 ;
6529 PyObject * obj1 = 0 ;
6530 PyObject * obj2 = 0 ;
6531 PyObject * obj3 = 0 ;
6532 PyObject * obj4 = 0 ;
6533 char *kwnames[] = {
6534 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6535 };
6536
6537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6539 if (SWIG_arg_fail(1)) SWIG_fail;
6540 if (obj1) {
6541 {
6542 arg2 = static_cast<int >(SWIG_As_int(obj1));
6543 if (SWIG_arg_fail(2)) SWIG_fail;
6544 }
6545 }
6546 if (obj2) {
6547 {
6548 arg3 = static_cast<int >(SWIG_As_int(obj2));
6549 if (SWIG_arg_fail(3)) SWIG_fail;
6550 }
6551 }
6552 if (obj3) {
6553 {
6554 arg4 = static_cast<int >(SWIG_As_int(obj3));
6555 if (SWIG_arg_fail(4)) SWIG_fail;
6556 }
6557 }
6558 if (obj4) {
6559 {
6560 arg5 = static_cast<int >(SWIG_As_int(obj4));
6561 if (SWIG_arg_fail(5)) SWIG_fail;
6562 }
6563 }
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6567
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 Py_INCREF(Py_None); resultobj = Py_None;
6572 return resultobj;
6573 fail:
6574 return NULL;
6575 }
6576
6577
6578 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6579 PyObject *resultobj = NULL;
6580 wxRect *arg1 = (wxRect *) 0 ;
6581 PyObject *result;
6582 PyObject * obj0 = 0 ;
6583 char *kwnames[] = {
6584 (char *) "self", NULL
6585 };
6586
6587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6589 if (SWIG_arg_fail(1)) SWIG_fail;
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 result = (PyObject *)wxRect_Get(arg1);
6593
6594 wxPyEndAllowThreads(__tstate);
6595 if (PyErr_Occurred()) SWIG_fail;
6596 }
6597 resultobj = result;
6598 return resultobj;
6599 fail:
6600 return NULL;
6601 }
6602
6603
6604 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6605 PyObject *obj;
6606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6607 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6608 Py_INCREF(obj);
6609 return Py_BuildValue((char *)"");
6610 }
6611 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6612 PyObject *resultobj = NULL;
6613 wxRect *arg1 = (wxRect *) 0 ;
6614 wxRect *arg2 = (wxRect *) 0 ;
6615 PyObject *result;
6616 PyObject * obj0 = 0 ;
6617 PyObject * obj1 = 0 ;
6618 char *kwnames[] = {
6619 (char *) "r1",(char *) "r2", NULL
6620 };
6621
6622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6624 if (SWIG_arg_fail(1)) SWIG_fail;
6625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6626 if (SWIG_arg_fail(2)) SWIG_fail;
6627 {
6628 if (!wxPyCheckForApp()) SWIG_fail;
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 result = (PyObject *)wxIntersectRect(arg1,arg2);
6631
6632 wxPyEndAllowThreads(__tstate);
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 resultobj = result;
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6643 PyObject *resultobj = NULL;
6644 double arg1 = (double) 0.0 ;
6645 double arg2 = (double) 0.0 ;
6646 wxPoint2D *result;
6647 PyObject * obj0 = 0 ;
6648 PyObject * obj1 = 0 ;
6649 char *kwnames[] = {
6650 (char *) "x",(char *) "y", NULL
6651 };
6652
6653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6654 if (obj0) {
6655 {
6656 arg1 = static_cast<double >(SWIG_As_double(obj0));
6657 if (SWIG_arg_fail(1)) SWIG_fail;
6658 }
6659 }
6660 if (obj1) {
6661 {
6662 arg2 = static_cast<double >(SWIG_As_double(obj1));
6663 if (SWIG_arg_fail(2)) SWIG_fail;
6664 }
6665 }
6666 {
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6669
6670 wxPyEndAllowThreads(__tstate);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6681 PyObject *resultobj = NULL;
6682 wxPoint2D *arg1 = 0 ;
6683 wxPoint2D *result;
6684 wxPoint2D temp1 ;
6685 PyObject * obj0 = 0 ;
6686 char *kwnames[] = {
6687 (char *) "pt", NULL
6688 };
6689
6690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6691 {
6692 arg1 = &temp1;
6693 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6694 }
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6698
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj = NULL;
6711 wxPoint *arg1 = 0 ;
6712 wxPoint2D *result;
6713 wxPoint temp1 ;
6714 PyObject * obj0 = 0 ;
6715 char *kwnames[] = {
6716 (char *) "pt", NULL
6717 };
6718
6719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6720 {
6721 arg1 = &temp1;
6722 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6723 }
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6739 PyObject *resultobj = NULL;
6740 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6741 int *arg2 = (int *) 0 ;
6742 int *arg3 = (int *) 0 ;
6743 int temp2 ;
6744 int res2 = 0 ;
6745 int temp3 ;
6746 int res3 = 0 ;
6747 PyObject * obj0 = 0 ;
6748 char *kwnames[] = {
6749 (char *) "self", NULL
6750 };
6751
6752 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6753 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 PyThreadState* __tstate = wxPyBeginAllowThreads();
6759 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6760
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 Py_INCREF(Py_None); resultobj = Py_None;
6765 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6766 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6767 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6768 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj = NULL;
6777 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6778 int *arg2 = (int *) 0 ;
6779 int *arg3 = (int *) 0 ;
6780 int temp2 ;
6781 int res2 = 0 ;
6782 int temp3 ;
6783 int res3 = 0 ;
6784 PyObject * obj0 = 0 ;
6785 char *kwnames[] = {
6786 (char *) "self", NULL
6787 };
6788
6789 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6790 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(1)) SWIG_fail;
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6797
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 Py_INCREF(Py_None); resultobj = Py_None;
6802 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6803 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6804 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6805 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6813 PyObject *resultobj = NULL;
6814 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6815 double result;
6816 PyObject * obj0 = 0 ;
6817 char *kwnames[] = {
6818 (char *) "self", NULL
6819 };
6820
6821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6823 if (SWIG_arg_fail(1)) SWIG_fail;
6824 {
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6827
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 {
6832 resultobj = SWIG_From_double(static_cast<double >(result));
6833 }
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6841 PyObject *resultobj = NULL;
6842 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6843 double result;
6844 PyObject * obj0 = 0 ;
6845 char *kwnames[] = {
6846 (char *) "self", NULL
6847 };
6848
6849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6851 if (SWIG_arg_fail(1)) SWIG_fail;
6852 {
6853 PyThreadState* __tstate = wxPyBeginAllowThreads();
6854 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6855
6856 wxPyEndAllowThreads(__tstate);
6857 if (PyErr_Occurred()) SWIG_fail;
6858 }
6859 {
6860 resultobj = SWIG_From_double(static_cast<double >(result));
6861 }
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6869 PyObject *resultobj = NULL;
6870 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6871 double arg2 ;
6872 PyObject * obj0 = 0 ;
6873 PyObject * obj1 = 0 ;
6874 char *kwnames[] = {
6875 (char *) "self",(char *) "length", NULL
6876 };
6877
6878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6880 if (SWIG_arg_fail(1)) SWIG_fail;
6881 {
6882 arg2 = static_cast<double >(SWIG_As_double(obj1));
6883 if (SWIG_arg_fail(2)) SWIG_fail;
6884 }
6885 {
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 (arg1)->SetVectorLength(arg2);
6888
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 Py_INCREF(Py_None); resultobj = Py_None;
6893 return resultobj;
6894 fail:
6895 return NULL;
6896 }
6897
6898
6899 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6900 PyObject *resultobj = NULL;
6901 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6902 double arg2 ;
6903 PyObject * obj0 = 0 ;
6904 PyObject * obj1 = 0 ;
6905 char *kwnames[] = {
6906 (char *) "self",(char *) "degrees", NULL
6907 };
6908
6909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6911 if (SWIG_arg_fail(1)) SWIG_fail;
6912 {
6913 arg2 = static_cast<double >(SWIG_As_double(obj1));
6914 if (SWIG_arg_fail(2)) SWIG_fail;
6915 }
6916 {
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 (arg1)->SetVectorAngle(arg2);
6919
6920 wxPyEndAllowThreads(__tstate);
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 Py_INCREF(Py_None); resultobj = Py_None;
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj = NULL;
6932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6933 wxPoint2D *arg2 = 0 ;
6934 double result;
6935 wxPoint2D temp2 ;
6936 PyObject * obj0 = 0 ;
6937 PyObject * obj1 = 0 ;
6938 char *kwnames[] = {
6939 (char *) "self",(char *) "pt", NULL
6940 };
6941
6942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6944 if (SWIG_arg_fail(1)) SWIG_fail;
6945 {
6946 arg2 = &temp2;
6947 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6948 }
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6952
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 {
6957 resultobj = SWIG_From_double(static_cast<double >(result));
6958 }
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj = NULL;
6967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6968 wxPoint2D *arg2 = 0 ;
6969 double result;
6970 wxPoint2D temp2 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "self",(char *) "pt", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6979 if (SWIG_arg_fail(1)) SWIG_fail;
6980 {
6981 arg2 = &temp2;
6982 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6987
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 {
6992 resultobj = SWIG_From_double(static_cast<double >(result));
6993 }
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = NULL;
7002 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7003 wxPoint2D *arg2 = 0 ;
7004 double result;
7005 wxPoint2D temp2 ;
7006 PyObject * obj0 = 0 ;
7007 PyObject * obj1 = 0 ;
7008 char *kwnames[] = {
7009 (char *) "self",(char *) "vec", NULL
7010 };
7011
7012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7014 if (SWIG_arg_fail(1)) SWIG_fail;
7015 {
7016 arg2 = &temp2;
7017 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7018 }
7019 {
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7022
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 {
7027 resultobj = SWIG_From_double(static_cast<double >(result));
7028 }
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj = NULL;
7037 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7038 wxPoint2D *arg2 = 0 ;
7039 double result;
7040 wxPoint2D temp2 ;
7041 PyObject * obj0 = 0 ;
7042 PyObject * obj1 = 0 ;
7043 char *kwnames[] = {
7044 (char *) "self",(char *) "vec", NULL
7045 };
7046
7047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7049 if (SWIG_arg_fail(1)) SWIG_fail;
7050 {
7051 arg2 = &temp2;
7052 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7053 }
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7057
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 {
7062 resultobj = SWIG_From_double(static_cast<double >(result));
7063 }
7064 return resultobj;
7065 fail:
7066 return NULL;
7067 }
7068
7069
7070 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7071 PyObject *resultobj = NULL;
7072 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7073 wxPoint2D result;
7074 PyObject * obj0 = 0 ;
7075 char *kwnames[] = {
7076 (char *) "self", NULL
7077 };
7078
7079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7081 if (SWIG_arg_fail(1)) SWIG_fail;
7082 {
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 result = (arg1)->operator -();
7085
7086 wxPyEndAllowThreads(__tstate);
7087 if (PyErr_Occurred()) SWIG_fail;
7088 }
7089 {
7090 wxPoint2D * resultptr;
7091 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7093 }
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7101 PyObject *resultobj = NULL;
7102 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7103 wxPoint2D *arg2 = 0 ;
7104 wxPoint2D *result;
7105 wxPoint2D temp2 ;
7106 PyObject * obj0 = 0 ;
7107 PyObject * obj1 = 0 ;
7108 char *kwnames[] = {
7109 (char *) "self",(char *) "pt", NULL
7110 };
7111
7112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7114 if (SWIG_arg_fail(1)) SWIG_fail;
7115 {
7116 arg2 = &temp2;
7117 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7118 }
7119 {
7120 PyThreadState* __tstate = wxPyBeginAllowThreads();
7121 {
7122 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7123 result = (wxPoint2D *) &_result_ref;
7124 }
7125
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj = NULL;
7138 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7139 wxPoint2D *arg2 = 0 ;
7140 wxPoint2D *result;
7141 wxPoint2D temp2 ;
7142 PyObject * obj0 = 0 ;
7143 PyObject * obj1 = 0 ;
7144 char *kwnames[] = {
7145 (char *) "self",(char *) "pt", NULL
7146 };
7147
7148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7150 if (SWIG_arg_fail(1)) SWIG_fail;
7151 {
7152 arg2 = &temp2;
7153 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7154 }
7155 {
7156 PyThreadState* __tstate = wxPyBeginAllowThreads();
7157 {
7158 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7159 result = (wxPoint2D *) &_result_ref;
7160 }
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj = NULL;
7174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7175 wxPoint2D *arg2 = 0 ;
7176 wxPoint2D *result;
7177 wxPoint2D temp2 ;
7178 PyObject * obj0 = 0 ;
7179 PyObject * obj1 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self",(char *) "pt", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 {
7188 arg2 = &temp2;
7189 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7190 }
7191 {
7192 PyThreadState* __tstate = wxPyBeginAllowThreads();
7193 {
7194 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7195 result = (wxPoint2D *) &_result_ref;
7196 }
7197
7198 wxPyEndAllowThreads(__tstate);
7199 if (PyErr_Occurred()) SWIG_fail;
7200 }
7201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7202 return resultobj;
7203 fail:
7204 return NULL;
7205 }
7206
7207
7208 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7209 PyObject *resultobj = NULL;
7210 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7211 wxPoint2D *arg2 = 0 ;
7212 wxPoint2D *result;
7213 wxPoint2D temp2 ;
7214 PyObject * obj0 = 0 ;
7215 PyObject * obj1 = 0 ;
7216 char *kwnames[] = {
7217 (char *) "self",(char *) "pt", NULL
7218 };
7219
7220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7222 if (SWIG_arg_fail(1)) SWIG_fail;
7223 {
7224 arg2 = &temp2;
7225 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7226 }
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 {
7230 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7231 result = (wxPoint2D *) &_result_ref;
7232 }
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj = NULL;
7246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7247 wxPoint2D *arg2 = 0 ;
7248 bool result;
7249 wxPoint2D temp2 ;
7250 PyObject * obj0 = 0 ;
7251 PyObject * obj1 = 0 ;
7252 char *kwnames[] = {
7253 (char *) "self",(char *) "pt", NULL
7254 };
7255
7256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7258 if (SWIG_arg_fail(1)) SWIG_fail;
7259 {
7260 arg2 = &temp2;
7261 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7262 }
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7266
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 {
7271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7272 }
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj = NULL;
7281 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7282 wxPoint2D *arg2 = 0 ;
7283 bool result;
7284 wxPoint2D temp2 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char *kwnames[] = {
7288 (char *) "self",(char *) "pt", NULL
7289 };
7290
7291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7293 if (SWIG_arg_fail(1)) SWIG_fail;
7294 {
7295 arg2 = &temp2;
7296 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7297 }
7298 {
7299 PyThreadState* __tstate = wxPyBeginAllowThreads();
7300 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7301
7302 wxPyEndAllowThreads(__tstate);
7303 if (PyErr_Occurred()) SWIG_fail;
7304 }
7305 {
7306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7307 }
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = NULL;
7316 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7317 double arg2 ;
7318 PyObject * obj0 = 0 ;
7319 PyObject * obj1 = 0 ;
7320 char *kwnames[] = {
7321 (char *) "self",(char *) "m_x", NULL
7322 };
7323
7324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7326 if (SWIG_arg_fail(1)) SWIG_fail;
7327 {
7328 arg2 = static_cast<double >(SWIG_As_double(obj1));
7329 if (SWIG_arg_fail(2)) SWIG_fail;
7330 }
7331 if (arg1) (arg1)->m_x = arg2;
7332
7333 Py_INCREF(Py_None); resultobj = Py_None;
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7341 PyObject *resultobj = NULL;
7342 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7343 double result;
7344 PyObject * obj0 = 0 ;
7345 char *kwnames[] = {
7346 (char *) "self", NULL
7347 };
7348
7349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7351 if (SWIG_arg_fail(1)) SWIG_fail;
7352 result = (double) ((arg1)->m_x);
7353
7354 {
7355 resultobj = SWIG_From_double(static_cast<double >(result));
7356 }
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7364 PyObject *resultobj = NULL;
7365 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7366 double arg2 ;
7367 PyObject * obj0 = 0 ;
7368 PyObject * obj1 = 0 ;
7369 char *kwnames[] = {
7370 (char *) "self",(char *) "m_y", NULL
7371 };
7372
7373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7375 if (SWIG_arg_fail(1)) SWIG_fail;
7376 {
7377 arg2 = static_cast<double >(SWIG_As_double(obj1));
7378 if (SWIG_arg_fail(2)) SWIG_fail;
7379 }
7380 if (arg1) (arg1)->m_y = arg2;
7381
7382 Py_INCREF(Py_None); resultobj = Py_None;
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj = NULL;
7391 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7392 double result;
7393 PyObject * obj0 = 0 ;
7394 char *kwnames[] = {
7395 (char *) "self", NULL
7396 };
7397
7398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7400 if (SWIG_arg_fail(1)) SWIG_fail;
7401 result = (double) ((arg1)->m_y);
7402
7403 {
7404 resultobj = SWIG_From_double(static_cast<double >(result));
7405 }
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj = NULL;
7414 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7415 double arg2 = (double) 0 ;
7416 double arg3 = (double) 0 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 PyObject * obj2 = 0 ;
7420 char *kwnames[] = {
7421 (char *) "self",(char *) "x",(char *) "y", NULL
7422 };
7423
7424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7426 if (SWIG_arg_fail(1)) SWIG_fail;
7427 if (obj1) {
7428 {
7429 arg2 = static_cast<double >(SWIG_As_double(obj1));
7430 if (SWIG_arg_fail(2)) SWIG_fail;
7431 }
7432 }
7433 if (obj2) {
7434 {
7435 arg3 = static_cast<double >(SWIG_As_double(obj2));
7436 if (SWIG_arg_fail(3)) SWIG_fail;
7437 }
7438 }
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 wxPoint2D_Set(arg1,arg2,arg3);
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 Py_INCREF(Py_None); resultobj = Py_None;
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj = NULL;
7455 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7456 PyObject *result;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 result = (PyObject *)wxPoint2D_Get(arg1);
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 resultobj = result;
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7480 PyObject *obj;
7481 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7482 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7483 Py_INCREF(obj);
7484 return Py_BuildValue((char *)"");
7485 }
7486 static int _wrap_DefaultPosition_set(PyObject *) {
7487 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7488 return 1;
7489 }
7490
7491
7492 static PyObject *_wrap_DefaultPosition_get(void) {
7493 PyObject *pyobj = NULL;
7494
7495 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7496 return pyobj;
7497 }
7498
7499
7500 static int _wrap_DefaultSize_set(PyObject *) {
7501 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7502 return 1;
7503 }
7504
7505
7506 static PyObject *_wrap_DefaultSize_get(void) {
7507 PyObject *pyobj = NULL;
7508
7509 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7510 return pyobj;
7511 }
7512
7513
7514 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7515 PyObject *resultobj = NULL;
7516 PyObject *arg1 = (PyObject *) 0 ;
7517 wxPyInputStream *result;
7518 PyObject * obj0 = 0 ;
7519 char *kwnames[] = {
7520 (char *) "p", NULL
7521 };
7522
7523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7524 arg1 = obj0;
7525 {
7526 PyThreadState* __tstate = wxPyBeginAllowThreads();
7527 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7528
7529 wxPyEndAllowThreads(__tstate);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj = NULL;
7541 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7542 PyObject * obj0 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 delete arg1;
7553
7554 wxPyEndAllowThreads(__tstate);
7555 if (PyErr_Occurred()) SWIG_fail;
7556 }
7557 Py_INCREF(Py_None); resultobj = Py_None;
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj = NULL;
7566 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7567 PyObject * obj0 = 0 ;
7568 char *kwnames[] = {
7569 (char *) "self", NULL
7570 };
7571
7572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7574 if (SWIG_arg_fail(1)) SWIG_fail;
7575 {
7576 PyThreadState* __tstate = wxPyBeginAllowThreads();
7577 (arg1)->close();
7578
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 Py_INCREF(Py_None); resultobj = Py_None;
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = NULL;
7591 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7592 PyObject * obj0 = 0 ;
7593 char *kwnames[] = {
7594 (char *) "self", NULL
7595 };
7596
7597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7599 if (SWIG_arg_fail(1)) SWIG_fail;
7600 {
7601 PyThreadState* __tstate = wxPyBeginAllowThreads();
7602 (arg1)->flush();
7603
7604 wxPyEndAllowThreads(__tstate);
7605 if (PyErr_Occurred()) SWIG_fail;
7606 }
7607 Py_INCREF(Py_None); resultobj = Py_None;
7608 return resultobj;
7609 fail:
7610 return NULL;
7611 }
7612
7613
7614 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7615 PyObject *resultobj = NULL;
7616 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7617 bool result;
7618 PyObject * obj0 = 0 ;
7619 char *kwnames[] = {
7620 (char *) "self", NULL
7621 };
7622
7623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7625 if (SWIG_arg_fail(1)) SWIG_fail;
7626 {
7627 PyThreadState* __tstate = wxPyBeginAllowThreads();
7628 result = (bool)(arg1)->eof();
7629
7630 wxPyEndAllowThreads(__tstate);
7631 if (PyErr_Occurred()) SWIG_fail;
7632 }
7633 {
7634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7635 }
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj = NULL;
7644 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7645 int arg2 = (int) -1 ;
7646 PyObject *result;
7647 PyObject * obj0 = 0 ;
7648 PyObject * obj1 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "self",(char *) "size", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7655 if (SWIG_arg_fail(1)) SWIG_fail;
7656 if (obj1) {
7657 {
7658 arg2 = static_cast<int >(SWIG_As_int(obj1));
7659 if (SWIG_arg_fail(2)) SWIG_fail;
7660 }
7661 }
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (PyObject *)(arg1)->read(arg2);
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 resultobj = result;
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj = NULL;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 int arg2 = (int) -1 ;
7680 PyObject *result;
7681 PyObject * obj0 = 0 ;
7682 PyObject * obj1 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self",(char *) "size", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7689 if (SWIG_arg_fail(1)) SWIG_fail;
7690 if (obj1) {
7691 {
7692 arg2 = static_cast<int >(SWIG_As_int(obj1));
7693 if (SWIG_arg_fail(2)) SWIG_fail;
7694 }
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (PyObject *)(arg1)->readline(arg2);
7699
7700 wxPyEndAllowThreads(__tstate);
7701 if (PyErr_Occurred()) SWIG_fail;
7702 }
7703 resultobj = result;
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7711 PyObject *resultobj = NULL;
7712 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7713 int arg2 = (int) -1 ;
7714 PyObject *result;
7715 PyObject * obj0 = 0 ;
7716 PyObject * obj1 = 0 ;
7717 char *kwnames[] = {
7718 (char *) "self",(char *) "sizehint", NULL
7719 };
7720
7721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7723 if (SWIG_arg_fail(1)) SWIG_fail;
7724 if (obj1) {
7725 {
7726 arg2 = static_cast<int >(SWIG_As_int(obj1));
7727 if (SWIG_arg_fail(2)) SWIG_fail;
7728 }
7729 }
7730 {
7731 PyThreadState* __tstate = wxPyBeginAllowThreads();
7732 result = (PyObject *)(arg1)->readlines(arg2);
7733
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 resultobj = result;
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj = NULL;
7746 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7747 int arg2 ;
7748 int arg3 = (int) 0 ;
7749 PyObject * obj0 = 0 ;
7750 PyObject * obj1 = 0 ;
7751 PyObject * obj2 = 0 ;
7752 char *kwnames[] = {
7753 (char *) "self",(char *) "offset",(char *) "whence", NULL
7754 };
7755
7756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7758 if (SWIG_arg_fail(1)) SWIG_fail;
7759 {
7760 arg2 = static_cast<int >(SWIG_As_int(obj1));
7761 if (SWIG_arg_fail(2)) SWIG_fail;
7762 }
7763 if (obj2) {
7764 {
7765 arg3 = static_cast<int >(SWIG_As_int(obj2));
7766 if (SWIG_arg_fail(3)) SWIG_fail;
7767 }
7768 }
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 (arg1)->seek(arg2,arg3);
7772
7773 wxPyEndAllowThreads(__tstate);
7774 if (PyErr_Occurred()) SWIG_fail;
7775 }
7776 Py_INCREF(Py_None); resultobj = Py_None;
7777 return resultobj;
7778 fail:
7779 return NULL;
7780 }
7781
7782
7783 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7784 PyObject *resultobj = NULL;
7785 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7786 int result;
7787 PyObject * obj0 = 0 ;
7788 char *kwnames[] = {
7789 (char *) "self", NULL
7790 };
7791
7792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 {
7796 PyThreadState* __tstate = wxPyBeginAllowThreads();
7797 result = (int)(arg1)->tell();
7798
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 {
7803 resultobj = SWIG_From_int(static_cast<int >(result));
7804 }
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj = NULL;
7813 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7814 char result;
7815 PyObject * obj0 = 0 ;
7816 char *kwnames[] = {
7817 (char *) "self", NULL
7818 };
7819
7820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7822 if (SWIG_arg_fail(1)) SWIG_fail;
7823 {
7824 PyThreadState* __tstate = wxPyBeginAllowThreads();
7825 result = (char)(arg1)->Peek();
7826
7827 wxPyEndAllowThreads(__tstate);
7828 if (PyErr_Occurred()) SWIG_fail;
7829 }
7830 {
7831 resultobj = SWIG_From_char(static_cast<char >(result));
7832 }
7833 return resultobj;
7834 fail:
7835 return NULL;
7836 }
7837
7838
7839 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7840 PyObject *resultobj = NULL;
7841 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7842 char result;
7843 PyObject * obj0 = 0 ;
7844 char *kwnames[] = {
7845 (char *) "self", NULL
7846 };
7847
7848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7850 if (SWIG_arg_fail(1)) SWIG_fail;
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 result = (char)(arg1)->GetC();
7854
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 {
7859 resultobj = SWIG_From_char(static_cast<char >(result));
7860 }
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7868 PyObject *resultobj = NULL;
7869 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7870 size_t result;
7871 PyObject * obj0 = 0 ;
7872 char *kwnames[] = {
7873 (char *) "self", NULL
7874 };
7875
7876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7878 if (SWIG_arg_fail(1)) SWIG_fail;
7879 {
7880 PyThreadState* __tstate = wxPyBeginAllowThreads();
7881 result = (size_t)(arg1)->LastRead();
7882
7883 wxPyEndAllowThreads(__tstate);
7884 if (PyErr_Occurred()) SWIG_fail;
7885 }
7886 {
7887 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7888 }
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7896 PyObject *resultobj = NULL;
7897 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7898 bool result;
7899 PyObject * obj0 = 0 ;
7900 char *kwnames[] = {
7901 (char *) "self", NULL
7902 };
7903
7904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7906 if (SWIG_arg_fail(1)) SWIG_fail;
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 result = (bool)(arg1)->CanRead();
7910
7911 wxPyEndAllowThreads(__tstate);
7912 if (PyErr_Occurred()) SWIG_fail;
7913 }
7914 {
7915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7916 }
7917 return resultobj;
7918 fail:
7919 return NULL;
7920 }
7921
7922
7923 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj = NULL;
7925 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7926 bool result;
7927 PyObject * obj0 = 0 ;
7928 char *kwnames[] = {
7929 (char *) "self", NULL
7930 };
7931
7932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7934 if (SWIG_arg_fail(1)) SWIG_fail;
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (bool)(arg1)->Eof();
7938
7939 wxPyEndAllowThreads(__tstate);
7940 if (PyErr_Occurred()) SWIG_fail;
7941 }
7942 {
7943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7944 }
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7952 PyObject *resultobj = NULL;
7953 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7954 char arg2 ;
7955 bool result;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char *kwnames[] = {
7959 (char *) "self",(char *) "c", NULL
7960 };
7961
7962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7964 if (SWIG_arg_fail(1)) SWIG_fail;
7965 {
7966 arg2 = static_cast<char >(SWIG_As_char(obj1));
7967 if (SWIG_arg_fail(2)) SWIG_fail;
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (bool)(arg1)->Ungetch(arg2);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 {
7977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7978 }
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj = NULL;
7987 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7988 long arg2 ;
7989 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7990 long result;
7991 PyObject * obj0 = 0 ;
7992 PyObject * obj1 = 0 ;
7993 PyObject * obj2 = 0 ;
7994 char *kwnames[] = {
7995 (char *) "self",(char *) "pos",(char *) "mode", NULL
7996 };
7997
7998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8000 if (SWIG_arg_fail(1)) SWIG_fail;
8001 {
8002 arg2 = static_cast<long >(SWIG_As_long(obj1));
8003 if (SWIG_arg_fail(2)) SWIG_fail;
8004 }
8005 if (obj2) {
8006 {
8007 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8008 if (SWIG_arg_fail(3)) SWIG_fail;
8009 }
8010 }
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (long)(arg1)->SeekI(arg2,arg3);
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 {
8019 resultobj = SWIG_From_long(static_cast<long >(result));
8020 }
8021 return resultobj;
8022 fail:
8023 return NULL;
8024 }
8025
8026
8027 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8028 PyObject *resultobj = NULL;
8029 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8030 long result;
8031 PyObject * obj0 = 0 ;
8032 char *kwnames[] = {
8033 (char *) "self", NULL
8034 };
8035
8036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8038 if (SWIG_arg_fail(1)) SWIG_fail;
8039 {
8040 PyThreadState* __tstate = wxPyBeginAllowThreads();
8041 result = (long)(arg1)->TellI();
8042
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 {
8047 resultobj = SWIG_From_long(static_cast<long >(result));
8048 }
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8056 PyObject *obj;
8057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8058 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8059 Py_INCREF(obj);
8060 return Py_BuildValue((char *)"");
8061 }
8062 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8063 PyObject *resultobj = NULL;
8064 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8065 PyObject *arg2 = (PyObject *) 0 ;
8066 PyObject * obj0 = 0 ;
8067 PyObject * obj1 = 0 ;
8068 char *kwnames[] = {
8069 (char *) "self",(char *) "obj", NULL
8070 };
8071
8072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8074 if (SWIG_arg_fail(1)) SWIG_fail;
8075 arg2 = obj1;
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 wxOutputStream_write(arg1,arg2);
8079
8080 wxPyEndAllowThreads(__tstate);
8081 if (PyErr_Occurred()) SWIG_fail;
8082 }
8083 Py_INCREF(Py_None); resultobj = Py_None;
8084 return resultobj;
8085 fail:
8086 return NULL;
8087 }
8088
8089
8090 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8091 PyObject *obj;
8092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8093 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8094 Py_INCREF(obj);
8095 return Py_BuildValue((char *)"");
8096 }
8097 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8098 PyObject *resultobj = NULL;
8099 wxInputStream *arg1 = (wxInputStream *) 0 ;
8100 wxString *arg2 = 0 ;
8101 wxString *arg3 = 0 ;
8102 wxString *arg4 = 0 ;
8103 wxDateTime arg5 ;
8104 wxFSFile *result;
8105 wxPyInputStream *temp1 ;
8106 bool temp2 = false ;
8107 bool temp3 = false ;
8108 bool temp4 = false ;
8109 PyObject * obj0 = 0 ;
8110 PyObject * obj1 = 0 ;
8111 PyObject * obj2 = 0 ;
8112 PyObject * obj3 = 0 ;
8113 PyObject * obj4 = 0 ;
8114 char *kwnames[] = {
8115 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8116 };
8117
8118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8119 {
8120 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8121 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8122 } else {
8123 PyErr_Clear(); // clear the failure of the wxPyConvert above
8124 arg1 = wxPyCBInputStream_create(obj0, true);
8125 if (arg1 == NULL) {
8126 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8127 SWIG_fail;
8128 }
8129 }
8130 }
8131 {
8132 arg2 = wxString_in_helper(obj1);
8133 if (arg2 == NULL) SWIG_fail;
8134 temp2 = true;
8135 }
8136 {
8137 arg3 = wxString_in_helper(obj2);
8138 if (arg3 == NULL) SWIG_fail;
8139 temp3 = true;
8140 }
8141 {
8142 arg4 = wxString_in_helper(obj3);
8143 if (arg4 == NULL) SWIG_fail;
8144 temp4 = true;
8145 }
8146 {
8147 wxDateTime * argp;
8148 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8149 if (SWIG_arg_fail(5)) SWIG_fail;
8150 if (argp == NULL) {
8151 SWIG_null_ref("wxDateTime");
8152 }
8153 if (SWIG_arg_fail(5)) SWIG_fail;
8154 arg5 = *argp;
8155 }
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8159
8160 wxPyEndAllowThreads(__tstate);
8161 if (PyErr_Occurred()) SWIG_fail;
8162 }
8163 {
8164 resultobj = wxPyMake_wxObject(result, 1);
8165 }
8166 {
8167 if (temp2)
8168 delete arg2;
8169 }
8170 {
8171 if (temp3)
8172 delete arg3;
8173 }
8174 {
8175 if (temp4)
8176 delete arg4;
8177 }
8178 return resultobj;
8179 fail:
8180 {
8181 if (temp2)
8182 delete arg2;
8183 }
8184 {
8185 if (temp3)
8186 delete arg3;
8187 }
8188 {
8189 if (temp4)
8190 delete arg4;
8191 }
8192 return NULL;
8193 }
8194
8195
8196 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8197 PyObject *resultobj = NULL;
8198 wxFSFile *arg1 = (wxFSFile *) 0 ;
8199 PyObject * obj0 = 0 ;
8200 char *kwnames[] = {
8201 (char *) "self", NULL
8202 };
8203
8204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8206 if (SWIG_arg_fail(1)) SWIG_fail;
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 delete arg1;
8210
8211 wxPyEndAllowThreads(__tstate);
8212 if (PyErr_Occurred()) SWIG_fail;
8213 }
8214 Py_INCREF(Py_None); resultobj = Py_None;
8215 return resultobj;
8216 fail:
8217 return NULL;
8218 }
8219
8220
8221 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8222 PyObject *resultobj = NULL;
8223 wxFSFile *arg1 = (wxFSFile *) 0 ;
8224 wxInputStream *result;
8225 PyObject * obj0 = 0 ;
8226 char *kwnames[] = {
8227 (char *) "self", NULL
8228 };
8229
8230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8232 if (SWIG_arg_fail(1)) SWIG_fail;
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 result = (wxInputStream *)(arg1)->GetStream();
8236
8237 wxPyEndAllowThreads(__tstate);
8238 if (PyErr_Occurred()) SWIG_fail;
8239 }
8240 {
8241 wxPyInputStream * _ptr = NULL;
8242
8243 if (result) {
8244 _ptr = new wxPyInputStream(result);
8245 }
8246 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8247 }
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj = NULL;
8256 wxFSFile *arg1 = (wxFSFile *) 0 ;
8257 wxString *result;
8258 PyObject * obj0 = 0 ;
8259 char *kwnames[] = {
8260 (char *) "self", NULL
8261 };
8262
8263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8265 if (SWIG_arg_fail(1)) SWIG_fail;
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 {
8269 wxString const &_result_ref = (arg1)->GetMimeType();
8270 result = (wxString *) &_result_ref;
8271 }
8272
8273 wxPyEndAllowThreads(__tstate);
8274 if (PyErr_Occurred()) SWIG_fail;
8275 }
8276 {
8277 #if wxUSE_UNICODE
8278 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8279 #else
8280 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8281 #endif
8282 }
8283 return resultobj;
8284 fail:
8285 return NULL;
8286 }
8287
8288
8289 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8290 PyObject *resultobj = NULL;
8291 wxFSFile *arg1 = (wxFSFile *) 0 ;
8292 wxString *result;
8293 PyObject * obj0 = 0 ;
8294 char *kwnames[] = {
8295 (char *) "self", NULL
8296 };
8297
8298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8300 if (SWIG_arg_fail(1)) SWIG_fail;
8301 {
8302 PyThreadState* __tstate = wxPyBeginAllowThreads();
8303 {
8304 wxString const &_result_ref = (arg1)->GetLocation();
8305 result = (wxString *) &_result_ref;
8306 }
8307
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 {
8312 #if wxUSE_UNICODE
8313 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8314 #else
8315 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8316 #endif
8317 }
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = NULL;
8326 wxFSFile *arg1 = (wxFSFile *) 0 ;
8327 wxString *result;
8328 PyObject * obj0 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 {
8337 PyThreadState* __tstate = wxPyBeginAllowThreads();
8338 {
8339 wxString const &_result_ref = (arg1)->GetAnchor();
8340 result = (wxString *) &_result_ref;
8341 }
8342
8343 wxPyEndAllowThreads(__tstate);
8344 if (PyErr_Occurred()) SWIG_fail;
8345 }
8346 {
8347 #if wxUSE_UNICODE
8348 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8349 #else
8350 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8351 #endif
8352 }
8353 return resultobj;
8354 fail:
8355 return NULL;
8356 }
8357
8358
8359 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj = NULL;
8361 wxFSFile *arg1 = (wxFSFile *) 0 ;
8362 wxDateTime result;
8363 PyObject * obj0 = 0 ;
8364 char *kwnames[] = {
8365 (char *) "self", NULL
8366 };
8367
8368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8370 if (SWIG_arg_fail(1)) SWIG_fail;
8371 {
8372 PyThreadState* __tstate = wxPyBeginAllowThreads();
8373 result = (arg1)->GetModificationTime();
8374
8375 wxPyEndAllowThreads(__tstate);
8376 if (PyErr_Occurred()) SWIG_fail;
8377 }
8378 {
8379 wxDateTime * resultptr;
8380 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8382 }
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8390 PyObject *obj;
8391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8392 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8393 Py_INCREF(obj);
8394 return Py_BuildValue((char *)"");
8395 }
8396 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8397 PyObject *obj;
8398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8399 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8400 Py_INCREF(obj);
8401 return Py_BuildValue((char *)"");
8402 }
8403 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8404 PyObject *resultobj = NULL;
8405 wxPyFileSystemHandler *result;
8406 char *kwnames[] = {
8407 NULL
8408 };
8409
8410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8411 {
8412 PyThreadState* __tstate = wxPyBeginAllowThreads();
8413 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8414
8415 wxPyEndAllowThreads(__tstate);
8416 if (PyErr_Occurred()) SWIG_fail;
8417 }
8418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8419 return resultobj;
8420 fail:
8421 return NULL;
8422 }
8423
8424
8425 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8426 PyObject *resultobj = NULL;
8427 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8428 PyObject *arg2 = (PyObject *) 0 ;
8429 PyObject *arg3 = (PyObject *) 0 ;
8430 PyObject * obj0 = 0 ;
8431 PyObject * obj1 = 0 ;
8432 PyObject * obj2 = 0 ;
8433 char *kwnames[] = {
8434 (char *) "self",(char *) "self",(char *) "_class", NULL
8435 };
8436
8437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8439 if (SWIG_arg_fail(1)) SWIG_fail;
8440 arg2 = obj1;
8441 arg3 = obj2;
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 (arg1)->_setCallbackInfo(arg2,arg3);
8445
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 Py_INCREF(Py_None); resultobj = Py_None;
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = NULL;
8458 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8459 wxString *arg2 = 0 ;
8460 bool result;
8461 bool temp2 = false ;
8462 PyObject * obj0 = 0 ;
8463 PyObject * obj1 = 0 ;
8464 char *kwnames[] = {
8465 (char *) "self",(char *) "location", NULL
8466 };
8467
8468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8470 if (SWIG_arg_fail(1)) SWIG_fail;
8471 {
8472 arg2 = wxString_in_helper(obj1);
8473 if (arg2 == NULL) SWIG_fail;
8474 temp2 = true;
8475 }
8476 {
8477 PyThreadState* __tstate = wxPyBeginAllowThreads();
8478 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8479
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 {
8484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8485 }
8486 {
8487 if (temp2)
8488 delete arg2;
8489 }
8490 return resultobj;
8491 fail:
8492 {
8493 if (temp2)
8494 delete arg2;
8495 }
8496 return NULL;
8497 }
8498
8499
8500 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8501 PyObject *resultobj = NULL;
8502 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8503 wxFileSystem *arg2 = 0 ;
8504 wxString *arg3 = 0 ;
8505 wxFSFile *result;
8506 bool temp3 = false ;
8507 PyObject * obj0 = 0 ;
8508 PyObject * obj1 = 0 ;
8509 PyObject * obj2 = 0 ;
8510 char *kwnames[] = {
8511 (char *) "self",(char *) "fs",(char *) "location", NULL
8512 };
8513
8514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8516 if (SWIG_arg_fail(1)) SWIG_fail;
8517 {
8518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8519 if (SWIG_arg_fail(2)) SWIG_fail;
8520 if (arg2 == NULL) {
8521 SWIG_null_ref("wxFileSystem");
8522 }
8523 if (SWIG_arg_fail(2)) SWIG_fail;
8524 }
8525 {
8526 arg3 = wxString_in_helper(obj2);
8527 if (arg3 == NULL) SWIG_fail;
8528 temp3 = true;
8529 }
8530 {
8531 PyThreadState* __tstate = wxPyBeginAllowThreads();
8532 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8533
8534 wxPyEndAllowThreads(__tstate);
8535 if (PyErr_Occurred()) SWIG_fail;
8536 }
8537 {
8538 resultobj = wxPyMake_wxObject(result, 1);
8539 }
8540 {
8541 if (temp3)
8542 delete arg3;
8543 }
8544 return resultobj;
8545 fail:
8546 {
8547 if (temp3)
8548 delete arg3;
8549 }
8550 return NULL;
8551 }
8552
8553
8554 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8555 PyObject *resultobj = NULL;
8556 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8557 wxString *arg2 = 0 ;
8558 int arg3 = (int) 0 ;
8559 wxString result;
8560 bool temp2 = false ;
8561 PyObject * obj0 = 0 ;
8562 PyObject * obj1 = 0 ;
8563 PyObject * obj2 = 0 ;
8564 char *kwnames[] = {
8565 (char *) "self",(char *) "spec",(char *) "flags", NULL
8566 };
8567
8568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8570 if (SWIG_arg_fail(1)) SWIG_fail;
8571 {
8572 arg2 = wxString_in_helper(obj1);
8573 if (arg2 == NULL) SWIG_fail;
8574 temp2 = true;
8575 }
8576 if (obj2) {
8577 {
8578 arg3 = static_cast<int >(SWIG_As_int(obj2));
8579 if (SWIG_arg_fail(3)) SWIG_fail;
8580 }
8581 }
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8585
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 {
8590 #if wxUSE_UNICODE
8591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8592 #else
8593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8594 #endif
8595 }
8596 {
8597 if (temp2)
8598 delete arg2;
8599 }
8600 return resultobj;
8601 fail:
8602 {
8603 if (temp2)
8604 delete arg2;
8605 }
8606 return NULL;
8607 }
8608
8609
8610 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8611 PyObject *resultobj = NULL;
8612 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8613 wxString result;
8614 PyObject * obj0 = 0 ;
8615 char *kwnames[] = {
8616 (char *) "self", NULL
8617 };
8618
8619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8621 if (SWIG_arg_fail(1)) SWIG_fail;
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 result = (arg1)->FindNext();
8625
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 {
8630 #if wxUSE_UNICODE
8631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8632 #else
8633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8634 #endif
8635 }
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8643 PyObject *resultobj = NULL;
8644 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8645 wxString *arg2 = 0 ;
8646 wxString result;
8647 bool temp2 = false ;
8648 PyObject * obj0 = 0 ;
8649 PyObject * obj1 = 0 ;
8650 char *kwnames[] = {
8651 (char *) "self",(char *) "location", NULL
8652 };
8653
8654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8656 if (SWIG_arg_fail(1)) SWIG_fail;
8657 {
8658 arg2 = wxString_in_helper(obj1);
8659 if (arg2 == NULL) SWIG_fail;
8660 temp2 = true;
8661 }
8662 {
8663 PyThreadState* __tstate = wxPyBeginAllowThreads();
8664 result = (arg1)->GetProtocol((wxString const &)*arg2);
8665
8666 wxPyEndAllowThreads(__tstate);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 {
8670 #if wxUSE_UNICODE
8671 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8672 #else
8673 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8674 #endif
8675 }
8676 {
8677 if (temp2)
8678 delete arg2;
8679 }
8680 return resultobj;
8681 fail:
8682 {
8683 if (temp2)
8684 delete arg2;
8685 }
8686 return NULL;
8687 }
8688
8689
8690 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(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_GetLeftLocation",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)->GetLeftLocation((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_GetAnchor(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_GetAnchor",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)->GetAnchor((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_GetRightLocation(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_GetRightLocation",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)->GetRightLocation((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_GetMimeTypeFromExt(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_GetMimeTypeFromExt",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)->GetMimeTypeFromExt((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 * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8883 PyObject *obj;
8884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8885 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8886 Py_INCREF(obj);
8887 return Py_BuildValue((char *)"");
8888 }
8889 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8890 PyObject *resultobj = NULL;
8891 wxFileSystem *result;
8892 char *kwnames[] = {
8893 NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8897 {
8898 PyThreadState* __tstate = wxPyBeginAllowThreads();
8899 result = (wxFileSystem *)new wxFileSystem();
8900
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 {
8905 resultobj = wxPyMake_wxObject(result, 1);
8906 }
8907 return resultobj;
8908 fail:
8909 return NULL;
8910 }
8911
8912
8913 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj = NULL;
8915 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8916 PyObject * obj0 = 0 ;
8917 char *kwnames[] = {
8918 (char *) "self", NULL
8919 };
8920
8921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8923 if (SWIG_arg_fail(1)) SWIG_fail;
8924 {
8925 PyThreadState* __tstate = wxPyBeginAllowThreads();
8926 delete arg1;
8927
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 Py_INCREF(Py_None); resultobj = Py_None;
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8939 PyObject *resultobj = NULL;
8940 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8941 wxString *arg2 = 0 ;
8942 bool arg3 = (bool) false ;
8943 bool temp2 = false ;
8944 PyObject * obj0 = 0 ;
8945 PyObject * obj1 = 0 ;
8946 PyObject * obj2 = 0 ;
8947 char *kwnames[] = {
8948 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 {
8955 arg2 = wxString_in_helper(obj1);
8956 if (arg2 == NULL) SWIG_fail;
8957 temp2 = true;
8958 }
8959 if (obj2) {
8960 {
8961 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8962 if (SWIG_arg_fail(3)) SWIG_fail;
8963 }
8964 }
8965 {
8966 PyThreadState* __tstate = wxPyBeginAllowThreads();
8967 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8968
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 Py_INCREF(Py_None); resultobj = Py_None;
8973 {
8974 if (temp2)
8975 delete arg2;
8976 }
8977 return resultobj;
8978 fail:
8979 {
8980 if (temp2)
8981 delete arg2;
8982 }
8983 return NULL;
8984 }
8985
8986
8987 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8988 PyObject *resultobj = NULL;
8989 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8990 wxString result;
8991 PyObject * obj0 = 0 ;
8992 char *kwnames[] = {
8993 (char *) "self", NULL
8994 };
8995
8996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8998 if (SWIG_arg_fail(1)) SWIG_fail;
8999 {
9000 PyThreadState* __tstate = wxPyBeginAllowThreads();
9001 result = (arg1)->GetPath();
9002
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 {
9007 #if wxUSE_UNICODE
9008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9009 #else
9010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9011 #endif
9012 }
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj = NULL;
9021 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9022 wxString *arg2 = 0 ;
9023 wxFSFile *result;
9024 bool temp2 = false ;
9025 PyObject * obj0 = 0 ;
9026 PyObject * obj1 = 0 ;
9027 char *kwnames[] = {
9028 (char *) "self",(char *) "location", NULL
9029 };
9030
9031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9033 if (SWIG_arg_fail(1)) SWIG_fail;
9034 {
9035 arg2 = wxString_in_helper(obj1);
9036 if (arg2 == NULL) SWIG_fail;
9037 temp2 = true;
9038 }
9039 {
9040 PyThreadState* __tstate = wxPyBeginAllowThreads();
9041 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9042
9043 wxPyEndAllowThreads(__tstate);
9044 if (PyErr_Occurred()) SWIG_fail;
9045 }
9046 {
9047 resultobj = wxPyMake_wxObject(result, 1);
9048 }
9049 {
9050 if (temp2)
9051 delete arg2;
9052 }
9053 return resultobj;
9054 fail:
9055 {
9056 if (temp2)
9057 delete arg2;
9058 }
9059 return NULL;
9060 }
9061
9062
9063 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9064 PyObject *resultobj = NULL;
9065 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9066 wxString *arg2 = 0 ;
9067 int arg3 = (int) 0 ;
9068 wxString result;
9069 bool temp2 = false ;
9070 PyObject * obj0 = 0 ;
9071 PyObject * obj1 = 0 ;
9072 PyObject * obj2 = 0 ;
9073 char *kwnames[] = {
9074 (char *) "self",(char *) "spec",(char *) "flags", NULL
9075 };
9076
9077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9079 if (SWIG_arg_fail(1)) SWIG_fail;
9080 {
9081 arg2 = wxString_in_helper(obj1);
9082 if (arg2 == NULL) SWIG_fail;
9083 temp2 = true;
9084 }
9085 if (obj2) {
9086 {
9087 arg3 = static_cast<int >(SWIG_As_int(obj2));
9088 if (SWIG_arg_fail(3)) SWIG_fail;
9089 }
9090 }
9091 {
9092 PyThreadState* __tstate = wxPyBeginAllowThreads();
9093 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9094
9095 wxPyEndAllowThreads(__tstate);
9096 if (PyErr_Occurred()) SWIG_fail;
9097 }
9098 {
9099 #if wxUSE_UNICODE
9100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9101 #else
9102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9103 #endif
9104 }
9105 {
9106 if (temp2)
9107 delete arg2;
9108 }
9109 return resultobj;
9110 fail:
9111 {
9112 if (temp2)
9113 delete arg2;
9114 }
9115 return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj = NULL;
9121 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9122 wxString result;
9123 PyObject * obj0 = 0 ;
9124 char *kwnames[] = {
9125 (char *) "self", NULL
9126 };
9127
9128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9130 if (SWIG_arg_fail(1)) SWIG_fail;
9131 {
9132 PyThreadState* __tstate = wxPyBeginAllowThreads();
9133 result = (arg1)->FindNext();
9134
9135 wxPyEndAllowThreads(__tstate);
9136 if (PyErr_Occurred()) SWIG_fail;
9137 }
9138 {
9139 #if wxUSE_UNICODE
9140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9141 #else
9142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9143 #endif
9144 }
9145 return resultobj;
9146 fail:
9147 return NULL;
9148 }
9149
9150
9151 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9152 PyObject *resultobj = NULL;
9153 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9154 PyObject * obj0 = 0 ;
9155 char *kwnames[] = {
9156 (char *) "handler", NULL
9157 };
9158
9159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9161 if (SWIG_arg_fail(1)) SWIG_fail;
9162 {
9163 PyThreadState* __tstate = wxPyBeginAllowThreads();
9164 wxFileSystem::AddHandler(arg1);
9165
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 Py_INCREF(Py_None); resultobj = Py_None;
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj = NULL;
9178 char *kwnames[] = {
9179 NULL
9180 };
9181
9182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9183 {
9184 PyThreadState* __tstate = wxPyBeginAllowThreads();
9185 wxFileSystem::CleanUpHandlers();
9186
9187 wxPyEndAllowThreads(__tstate);
9188 if (PyErr_Occurred()) SWIG_fail;
9189 }
9190 Py_INCREF(Py_None); resultobj = Py_None;
9191 return resultobj;
9192 fail:
9193 return NULL;
9194 }
9195
9196
9197 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj = NULL;
9199 wxString *arg1 = 0 ;
9200 wxString result;
9201 bool temp1 = false ;
9202 PyObject * obj0 = 0 ;
9203 char *kwnames[] = {
9204 (char *) "filename", NULL
9205 };
9206
9207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9208 {
9209 arg1 = wxString_in_helper(obj0);
9210 if (arg1 == NULL) SWIG_fail;
9211 temp1 = true;
9212 }
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9216
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 {
9221 #if wxUSE_UNICODE
9222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9223 #else
9224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9225 #endif
9226 }
9227 {
9228 if (temp1)
9229 delete arg1;
9230 }
9231 return resultobj;
9232 fail:
9233 {
9234 if (temp1)
9235 delete arg1;
9236 }
9237 return NULL;
9238 }
9239
9240
9241 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj = NULL;
9243 wxString *arg1 = 0 ;
9244 wxString result;
9245 bool temp1 = false ;
9246 PyObject * obj0 = 0 ;
9247 char *kwnames[] = {
9248 (char *) "url", NULL
9249 };
9250
9251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9252 {
9253 arg1 = wxString_in_helper(obj0);
9254 if (arg1 == NULL) SWIG_fail;
9255 temp1 = true;
9256 }
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9260
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 {
9265 #if wxUSE_UNICODE
9266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9267 #else
9268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9269 #endif
9270 }
9271 {
9272 if (temp1)
9273 delete arg1;
9274 }
9275 return resultobj;
9276 fail:
9277 {
9278 if (temp1)
9279 delete arg1;
9280 }
9281 return NULL;
9282 }
9283
9284
9285 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9286 PyObject *obj;
9287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9288 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9289 Py_INCREF(obj);
9290 return Py_BuildValue((char *)"");
9291 }
9292 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9293 PyObject *resultobj = NULL;
9294 wxInternetFSHandler *result;
9295 char *kwnames[] = {
9296 NULL
9297 };
9298
9299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj = NULL;
9316 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9317 wxString *arg2 = 0 ;
9318 bool result;
9319 bool temp2 = false ;
9320 PyObject * obj0 = 0 ;
9321 PyObject * obj1 = 0 ;
9322 char *kwnames[] = {
9323 (char *) "self",(char *) "location", NULL
9324 };
9325
9326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9328 if (SWIG_arg_fail(1)) SWIG_fail;
9329 {
9330 arg2 = wxString_in_helper(obj1);
9331 if (arg2 == NULL) SWIG_fail;
9332 temp2 = true;
9333 }
9334 {
9335 PyThreadState* __tstate = wxPyBeginAllowThreads();
9336 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9337
9338 wxPyEndAllowThreads(__tstate);
9339 if (PyErr_Occurred()) SWIG_fail;
9340 }
9341 {
9342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9343 }
9344 {
9345 if (temp2)
9346 delete arg2;
9347 }
9348 return resultobj;
9349 fail:
9350 {
9351 if (temp2)
9352 delete arg2;
9353 }
9354 return NULL;
9355 }
9356
9357
9358 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9359 PyObject *resultobj = NULL;
9360 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9361 wxFileSystem *arg2 = 0 ;
9362 wxString *arg3 = 0 ;
9363 wxFSFile *result;
9364 bool temp3 = false ;
9365 PyObject * obj0 = 0 ;
9366 PyObject * obj1 = 0 ;
9367 PyObject * obj2 = 0 ;
9368 char *kwnames[] = {
9369 (char *) "self",(char *) "fs",(char *) "location", NULL
9370 };
9371
9372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9374 if (SWIG_arg_fail(1)) SWIG_fail;
9375 {
9376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9377 if (SWIG_arg_fail(2)) SWIG_fail;
9378 if (arg2 == NULL) {
9379 SWIG_null_ref("wxFileSystem");
9380 }
9381 if (SWIG_arg_fail(2)) SWIG_fail;
9382 }
9383 {
9384 arg3 = wxString_in_helper(obj2);
9385 if (arg3 == NULL) SWIG_fail;
9386 temp3 = true;
9387 }
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9391
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 {
9396 resultobj = wxPyMake_wxObject(result, 1);
9397 }
9398 {
9399 if (temp3)
9400 delete arg3;
9401 }
9402 return resultobj;
9403 fail:
9404 {
9405 if (temp3)
9406 delete arg3;
9407 }
9408 return NULL;
9409 }
9410
9411
9412 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9413 PyObject *obj;
9414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9415 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9416 Py_INCREF(obj);
9417 return Py_BuildValue((char *)"");
9418 }
9419 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9420 PyObject *resultobj = NULL;
9421 wxZipFSHandler *result;
9422 char *kwnames[] = {
9423 NULL
9424 };
9425
9426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9427 {
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 result = (wxZipFSHandler *)new wxZipFSHandler();
9430
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj = NULL;
9443 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9444 wxString *arg2 = 0 ;
9445 bool result;
9446 bool temp2 = false ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 char *kwnames[] = {
9450 (char *) "self",(char *) "location", NULL
9451 };
9452
9453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9455 if (SWIG_arg_fail(1)) SWIG_fail;
9456 {
9457 arg2 = wxString_in_helper(obj1);
9458 if (arg2 == NULL) SWIG_fail;
9459 temp2 = true;
9460 }
9461 {
9462 PyThreadState* __tstate = wxPyBeginAllowThreads();
9463 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9464
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 {
9469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9470 }
9471 {
9472 if (temp2)
9473 delete arg2;
9474 }
9475 return resultobj;
9476 fail:
9477 {
9478 if (temp2)
9479 delete arg2;
9480 }
9481 return NULL;
9482 }
9483
9484
9485 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9486 PyObject *resultobj = NULL;
9487 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9488 wxFileSystem *arg2 = 0 ;
9489 wxString *arg3 = 0 ;
9490 wxFSFile *result;
9491 bool temp3 = false ;
9492 PyObject * obj0 = 0 ;
9493 PyObject * obj1 = 0 ;
9494 PyObject * obj2 = 0 ;
9495 char *kwnames[] = {
9496 (char *) "self",(char *) "fs",(char *) "location", NULL
9497 };
9498
9499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9501 if (SWIG_arg_fail(1)) SWIG_fail;
9502 {
9503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9504 if (SWIG_arg_fail(2)) SWIG_fail;
9505 if (arg2 == NULL) {
9506 SWIG_null_ref("wxFileSystem");
9507 }
9508 if (SWIG_arg_fail(2)) SWIG_fail;
9509 }
9510 {
9511 arg3 = wxString_in_helper(obj2);
9512 if (arg3 == NULL) SWIG_fail;
9513 temp3 = true;
9514 }
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9518
9519 wxPyEndAllowThreads(__tstate);
9520 if (PyErr_Occurred()) SWIG_fail;
9521 }
9522 {
9523 resultobj = wxPyMake_wxObject(result, 1);
9524 }
9525 {
9526 if (temp3)
9527 delete arg3;
9528 }
9529 return resultobj;
9530 fail:
9531 {
9532 if (temp3)
9533 delete arg3;
9534 }
9535 return NULL;
9536 }
9537
9538
9539 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9540 PyObject *resultobj = NULL;
9541 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9542 wxString *arg2 = 0 ;
9543 int arg3 = (int) 0 ;
9544 wxString result;
9545 bool temp2 = false ;
9546 PyObject * obj0 = 0 ;
9547 PyObject * obj1 = 0 ;
9548 PyObject * obj2 = 0 ;
9549 char *kwnames[] = {
9550 (char *) "self",(char *) "spec",(char *) "flags", NULL
9551 };
9552
9553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9555 if (SWIG_arg_fail(1)) SWIG_fail;
9556 {
9557 arg2 = wxString_in_helper(obj1);
9558 if (arg2 == NULL) SWIG_fail;
9559 temp2 = true;
9560 }
9561 if (obj2) {
9562 {
9563 arg3 = static_cast<int >(SWIG_As_int(obj2));
9564 if (SWIG_arg_fail(3)) SWIG_fail;
9565 }
9566 }
9567 {
9568 PyThreadState* __tstate = wxPyBeginAllowThreads();
9569 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9570
9571 wxPyEndAllowThreads(__tstate);
9572 if (PyErr_Occurred()) SWIG_fail;
9573 }
9574 {
9575 #if wxUSE_UNICODE
9576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9577 #else
9578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9579 #endif
9580 }
9581 {
9582 if (temp2)
9583 delete arg2;
9584 }
9585 return resultobj;
9586 fail:
9587 {
9588 if (temp2)
9589 delete arg2;
9590 }
9591 return NULL;
9592 }
9593
9594
9595 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj = NULL;
9597 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9598 wxString result;
9599 PyObject * obj0 = 0 ;
9600 char *kwnames[] = {
9601 (char *) "self", NULL
9602 };
9603
9604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9606 if (SWIG_arg_fail(1)) SWIG_fail;
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = (arg1)->FindNext();
9610
9611 wxPyEndAllowThreads(__tstate);
9612 if (PyErr_Occurred()) SWIG_fail;
9613 }
9614 {
9615 #if wxUSE_UNICODE
9616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9617 #else
9618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9619 #endif
9620 }
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
9627 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9628 PyObject *obj;
9629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9630 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9631 Py_INCREF(obj);
9632 return Py_BuildValue((char *)"");
9633 }
9634 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = NULL;
9636 wxString *arg1 = 0 ;
9637 wxImage *arg2 = 0 ;
9638 long arg3 ;
9639 bool temp1 = false ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 PyObject * obj2 = 0 ;
9643 char *kwnames[] = {
9644 (char *) "filename",(char *) "image",(char *) "type", NULL
9645 };
9646
9647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9648 {
9649 arg1 = wxString_in_helper(obj0);
9650 if (arg1 == NULL) SWIG_fail;
9651 temp1 = true;
9652 }
9653 {
9654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9655 if (SWIG_arg_fail(2)) SWIG_fail;
9656 if (arg2 == NULL) {
9657 SWIG_null_ref("wxImage");
9658 }
9659 if (SWIG_arg_fail(2)) SWIG_fail;
9660 }
9661 {
9662 arg3 = static_cast<long >(SWIG_As_long(obj2));
9663 if (SWIG_arg_fail(3)) SWIG_fail;
9664 }
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9668
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 Py_INCREF(Py_None); resultobj = Py_None;
9673 {
9674 if (temp1)
9675 delete arg1;
9676 }
9677 return resultobj;
9678 fail:
9679 {
9680 if (temp1)
9681 delete arg1;
9682 }
9683 return NULL;
9684 }
9685
9686
9687 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj = NULL;
9689 wxString *arg1 = 0 ;
9690 wxBitmap *arg2 = 0 ;
9691 long arg3 ;
9692 bool temp1 = false ;
9693 PyObject * obj0 = 0 ;
9694 PyObject * obj1 = 0 ;
9695 PyObject * obj2 = 0 ;
9696 char *kwnames[] = {
9697 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9698 };
9699
9700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9701 {
9702 arg1 = wxString_in_helper(obj0);
9703 if (arg1 == NULL) SWIG_fail;
9704 temp1 = true;
9705 }
9706 {
9707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9708 if (SWIG_arg_fail(2)) SWIG_fail;
9709 if (arg2 == NULL) {
9710 SWIG_null_ref("wxBitmap");
9711 }
9712 if (SWIG_arg_fail(2)) SWIG_fail;
9713 }
9714 {
9715 arg3 = static_cast<long >(SWIG_As_long(obj2));
9716 if (SWIG_arg_fail(3)) SWIG_fail;
9717 }
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9721
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 Py_INCREF(Py_None); resultobj = Py_None;
9726 {
9727 if (temp1)
9728 delete arg1;
9729 }
9730 return resultobj;
9731 fail:
9732 {
9733 if (temp1)
9734 delete arg1;
9735 }
9736 return NULL;
9737 }
9738
9739
9740 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj = NULL;
9742 wxString *arg1 = 0 ;
9743 PyObject *arg2 = (PyObject *) 0 ;
9744 bool temp1 = false ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 char *kwnames[] = {
9748 (char *) "filename",(char *) "data", NULL
9749 };
9750
9751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9752 {
9753 arg1 = wxString_in_helper(obj0);
9754 if (arg1 == NULL) SWIG_fail;
9755 temp1 = true;
9756 }
9757 arg2 = obj1;
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 Py_INCREF(Py_None); resultobj = Py_None;
9766 {
9767 if (temp1)
9768 delete arg1;
9769 }
9770 return resultobj;
9771 fail:
9772 {
9773 if (temp1)
9774 delete arg1;
9775 }
9776 return NULL;
9777 }
9778
9779
9780 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9781 PyObject *resultobj = NULL;
9782 wxMemoryFSHandler *result;
9783 char *kwnames[] = {
9784 NULL
9785 };
9786
9787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9788 {
9789 PyThreadState* __tstate = wxPyBeginAllowThreads();
9790 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9791
9792 wxPyEndAllowThreads(__tstate);
9793 if (PyErr_Occurred()) SWIG_fail;
9794 }
9795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9796 return resultobj;
9797 fail:
9798 return NULL;
9799 }
9800
9801
9802 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9803 PyObject *resultobj = NULL;
9804 wxString *arg1 = 0 ;
9805 bool temp1 = false ;
9806 PyObject * obj0 = 0 ;
9807 char *kwnames[] = {
9808 (char *) "filename", NULL
9809 };
9810
9811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9812 {
9813 arg1 = wxString_in_helper(obj0);
9814 if (arg1 == NULL) SWIG_fail;
9815 temp1 = true;
9816 }
9817 {
9818 PyThreadState* __tstate = wxPyBeginAllowThreads();
9819 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9820
9821 wxPyEndAllowThreads(__tstate);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 Py_INCREF(Py_None); resultobj = Py_None;
9825 {
9826 if (temp1)
9827 delete arg1;
9828 }
9829 return resultobj;
9830 fail:
9831 {
9832 if (temp1)
9833 delete arg1;
9834 }
9835 return NULL;
9836 }
9837
9838
9839 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9840 PyObject *resultobj = NULL;
9841 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9842 wxString *arg2 = 0 ;
9843 bool result;
9844 bool temp2 = false ;
9845 PyObject * obj0 = 0 ;
9846 PyObject * obj1 = 0 ;
9847 char *kwnames[] = {
9848 (char *) "self",(char *) "location", NULL
9849 };
9850
9851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9853 if (SWIG_arg_fail(1)) SWIG_fail;
9854 {
9855 arg2 = wxString_in_helper(obj1);
9856 if (arg2 == NULL) SWIG_fail;
9857 temp2 = true;
9858 }
9859 {
9860 PyThreadState* __tstate = wxPyBeginAllowThreads();
9861 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9862
9863 wxPyEndAllowThreads(__tstate);
9864 if (PyErr_Occurred()) SWIG_fail;
9865 }
9866 {
9867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9868 }
9869 {
9870 if (temp2)
9871 delete arg2;
9872 }
9873 return resultobj;
9874 fail:
9875 {
9876 if (temp2)
9877 delete arg2;
9878 }
9879 return NULL;
9880 }
9881
9882
9883 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9884 PyObject *resultobj = NULL;
9885 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9886 wxFileSystem *arg2 = 0 ;
9887 wxString *arg3 = 0 ;
9888 wxFSFile *result;
9889 bool temp3 = false ;
9890 PyObject * obj0 = 0 ;
9891 PyObject * obj1 = 0 ;
9892 PyObject * obj2 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "self",(char *) "fs",(char *) "location", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9899 if (SWIG_arg_fail(1)) SWIG_fail;
9900 {
9901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(2)) SWIG_fail;
9903 if (arg2 == NULL) {
9904 SWIG_null_ref("wxFileSystem");
9905 }
9906 if (SWIG_arg_fail(2)) SWIG_fail;
9907 }
9908 {
9909 arg3 = wxString_in_helper(obj2);
9910 if (arg3 == NULL) SWIG_fail;
9911 temp3 = true;
9912 }
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 {
9921 resultobj = wxPyMake_wxObject(result, 1);
9922 }
9923 {
9924 if (temp3)
9925 delete arg3;
9926 }
9927 return resultobj;
9928 fail:
9929 {
9930 if (temp3)
9931 delete arg3;
9932 }
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj = NULL;
9939 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9940 wxString *arg2 = 0 ;
9941 int arg3 = (int) 0 ;
9942 wxString result;
9943 bool temp2 = false ;
9944 PyObject * obj0 = 0 ;
9945 PyObject * obj1 = 0 ;
9946 PyObject * obj2 = 0 ;
9947 char *kwnames[] = {
9948 (char *) "self",(char *) "spec",(char *) "flags", NULL
9949 };
9950
9951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9953 if (SWIG_arg_fail(1)) SWIG_fail;
9954 {
9955 arg2 = wxString_in_helper(obj1);
9956 if (arg2 == NULL) SWIG_fail;
9957 temp2 = true;
9958 }
9959 if (obj2) {
9960 {
9961 arg3 = static_cast<int >(SWIG_As_int(obj2));
9962 if (SWIG_arg_fail(3)) SWIG_fail;
9963 }
9964 }
9965 {
9966 PyThreadState* __tstate = wxPyBeginAllowThreads();
9967 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9968
9969 wxPyEndAllowThreads(__tstate);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 {
9973 #if wxUSE_UNICODE
9974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9975 #else
9976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9977 #endif
9978 }
9979 {
9980 if (temp2)
9981 delete arg2;
9982 }
9983 return resultobj;
9984 fail:
9985 {
9986 if (temp2)
9987 delete arg2;
9988 }
9989 return NULL;
9990 }
9991
9992
9993 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = NULL;
9995 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9996 wxString result;
9997 PyObject * obj0 = 0 ;
9998 char *kwnames[] = {
9999 (char *) "self", NULL
10000 };
10001
10002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
10003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10004 if (SWIG_arg_fail(1)) SWIG_fail;
10005 {
10006 PyThreadState* __tstate = wxPyBeginAllowThreads();
10007 result = (arg1)->FindNext();
10008
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 {
10013 #if wxUSE_UNICODE
10014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10015 #else
10016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10017 #endif
10018 }
10019 return resultobj;
10020 fail:
10021 return NULL;
10022 }
10023
10024
10025 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10026 PyObject *obj;
10027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10028 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10029 Py_INCREF(obj);
10030 return Py_BuildValue((char *)"");
10031 }
10032 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10033 PyObject *resultobj = NULL;
10034 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10035 wxString result;
10036 PyObject * obj0 = 0 ;
10037 char *kwnames[] = {
10038 (char *) "self", NULL
10039 };
10040
10041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10043 if (SWIG_arg_fail(1)) SWIG_fail;
10044 {
10045 PyThreadState* __tstate = wxPyBeginAllowThreads();
10046 result = (arg1)->GetName();
10047
10048 wxPyEndAllowThreads(__tstate);
10049 if (PyErr_Occurred()) SWIG_fail;
10050 }
10051 {
10052 #if wxUSE_UNICODE
10053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10054 #else
10055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10056 #endif
10057 }
10058 return resultobj;
10059 fail:
10060 return NULL;
10061 }
10062
10063
10064 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj = NULL;
10066 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10067 wxString result;
10068 PyObject * obj0 = 0 ;
10069 char *kwnames[] = {
10070 (char *) "self", NULL
10071 };
10072
10073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10075 if (SWIG_arg_fail(1)) SWIG_fail;
10076 {
10077 PyThreadState* __tstate = wxPyBeginAllowThreads();
10078 result = (arg1)->GetExtension();
10079
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 #if wxUSE_UNICODE
10085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10086 #else
10087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10088 #endif
10089 }
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj = NULL;
10098 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10099 long result;
10100 PyObject * obj0 = 0 ;
10101 char *kwnames[] = {
10102 (char *) "self", NULL
10103 };
10104
10105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10107 if (SWIG_arg_fail(1)) SWIG_fail;
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 result = (long)(arg1)->GetType();
10111
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 {
10116 resultobj = SWIG_From_long(static_cast<long >(result));
10117 }
10118 return resultobj;
10119 fail:
10120 return NULL;
10121 }
10122
10123
10124 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj = NULL;
10126 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10127 wxString result;
10128 PyObject * obj0 = 0 ;
10129 char *kwnames[] = {
10130 (char *) "self", NULL
10131 };
10132
10133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10135 if (SWIG_arg_fail(1)) SWIG_fail;
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 result = (arg1)->GetMimeType();
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 {
10144 #if wxUSE_UNICODE
10145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10146 #else
10147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10148 #endif
10149 }
10150 return resultobj;
10151 fail:
10152 return NULL;
10153 }
10154
10155
10156 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10157 PyObject *resultobj = NULL;
10158 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10159 wxString *arg2 = 0 ;
10160 bool result;
10161 bool temp2 = false ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self",(char *) "name", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 {
10172 arg2 = wxString_in_helper(obj1);
10173 if (arg2 == NULL) SWIG_fail;
10174 temp2 = true;
10175 }
10176 {
10177 PyThreadState* __tstate = wxPyBeginAllowThreads();
10178 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10179
10180 wxPyEndAllowThreads(__tstate);
10181 if (PyErr_Occurred()) SWIG_fail;
10182 }
10183 {
10184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10185 }
10186 {
10187 if (temp2)
10188 delete arg2;
10189 }
10190 return resultobj;
10191 fail:
10192 {
10193 if (temp2)
10194 delete arg2;
10195 }
10196 return NULL;
10197 }
10198
10199
10200 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj = NULL;
10202 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10203 wxString *arg2 = 0 ;
10204 bool temp2 = false ;
10205 PyObject * obj0 = 0 ;
10206 PyObject * obj1 = 0 ;
10207 char *kwnames[] = {
10208 (char *) "self",(char *) "name", NULL
10209 };
10210
10211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10213 if (SWIG_arg_fail(1)) SWIG_fail;
10214 {
10215 arg2 = wxString_in_helper(obj1);
10216 if (arg2 == NULL) SWIG_fail;
10217 temp2 = true;
10218 }
10219 {
10220 PyThreadState* __tstate = wxPyBeginAllowThreads();
10221 (arg1)->SetName((wxString const &)*arg2);
10222
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 Py_INCREF(Py_None); resultobj = Py_None;
10227 {
10228 if (temp2)
10229 delete arg2;
10230 }
10231 return resultobj;
10232 fail:
10233 {
10234 if (temp2)
10235 delete arg2;
10236 }
10237 return NULL;
10238 }
10239
10240
10241 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10242 PyObject *resultobj = NULL;
10243 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10244 wxString *arg2 = 0 ;
10245 bool temp2 = false ;
10246 PyObject * obj0 = 0 ;
10247 PyObject * obj1 = 0 ;
10248 char *kwnames[] = {
10249 (char *) "self",(char *) "extension", NULL
10250 };
10251
10252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 {
10256 arg2 = wxString_in_helper(obj1);
10257 if (arg2 == NULL) SWIG_fail;
10258 temp2 = true;
10259 }
10260 {
10261 PyThreadState* __tstate = wxPyBeginAllowThreads();
10262 (arg1)->SetExtension((wxString const &)*arg2);
10263
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 Py_INCREF(Py_None); resultobj = Py_None;
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp2)
10276 delete arg2;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj = NULL;
10284 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10285 long arg2 ;
10286 PyObject * obj0 = 0 ;
10287 PyObject * obj1 = 0 ;
10288 char *kwnames[] = {
10289 (char *) "self",(char *) "type", NULL
10290 };
10291
10292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10294 if (SWIG_arg_fail(1)) SWIG_fail;
10295 {
10296 arg2 = static_cast<long >(SWIG_As_long(obj1));
10297 if (SWIG_arg_fail(2)) SWIG_fail;
10298 }
10299 {
10300 PyThreadState* __tstate = wxPyBeginAllowThreads();
10301 (arg1)->SetType(arg2);
10302
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 Py_INCREF(Py_None); resultobj = Py_None;
10307 return resultobj;
10308 fail:
10309 return NULL;
10310 }
10311
10312
10313 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj = NULL;
10315 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10316 wxString *arg2 = 0 ;
10317 bool temp2 = false ;
10318 PyObject * obj0 = 0 ;
10319 PyObject * obj1 = 0 ;
10320 char *kwnames[] = {
10321 (char *) "self",(char *) "mimetype", NULL
10322 };
10323
10324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10326 if (SWIG_arg_fail(1)) SWIG_fail;
10327 {
10328 arg2 = wxString_in_helper(obj1);
10329 if (arg2 == NULL) SWIG_fail;
10330 temp2 = true;
10331 }
10332 {
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 (arg1)->SetMimeType((wxString const &)*arg2);
10335
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 Py_INCREF(Py_None); resultobj = Py_None;
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return resultobj;
10345 fail:
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return NULL;
10351 }
10352
10353
10354 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10355 PyObject *obj;
10356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10357 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10358 Py_INCREF(obj);
10359 return Py_BuildValue((char *)"");
10360 }
10361 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10362 PyObject *resultobj = NULL;
10363 wxPyImageHandler *result;
10364 char *kwnames[] = {
10365 NULL
10366 };
10367
10368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 result = (wxPyImageHandler *)new wxPyImageHandler();
10372
10373 wxPyEndAllowThreads(__tstate);
10374 if (PyErr_Occurred()) SWIG_fail;
10375 }
10376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10377 return resultobj;
10378 fail:
10379 return NULL;
10380 }
10381
10382
10383 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10384 PyObject *resultobj = NULL;
10385 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10386 PyObject *arg2 = (PyObject *) 0 ;
10387 PyObject * obj0 = 0 ;
10388 PyObject * obj1 = 0 ;
10389 char *kwnames[] = {
10390 (char *) "self",(char *) "self", NULL
10391 };
10392
10393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10395 if (SWIG_arg_fail(1)) SWIG_fail;
10396 arg2 = obj1;
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 (arg1)->_SetSelf(arg2);
10400
10401 wxPyEndAllowThreads(__tstate);
10402 if (PyErr_Occurred()) SWIG_fail;
10403 }
10404 Py_INCREF(Py_None); resultobj = Py_None;
10405 return resultobj;
10406 fail:
10407 return NULL;
10408 }
10409
10410
10411 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10412 PyObject *obj;
10413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10414 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10415 Py_INCREF(obj);
10416 return Py_BuildValue((char *)"");
10417 }
10418 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10419 PyObject *resultobj = NULL;
10420 wxImageHistogram *result;
10421 char *kwnames[] = {
10422 NULL
10423 };
10424
10425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (wxImageHistogram *)new wxImageHistogram();
10429
10430 wxPyEndAllowThreads(__tstate);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj = NULL;
10442 byte arg1 ;
10443 byte arg2 ;
10444 byte arg3 ;
10445 unsigned long result;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 PyObject * obj2 = 0 ;
10449 char *kwnames[] = {
10450 (char *) "r",(char *) "g",(char *) "b", NULL
10451 };
10452
10453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10454 {
10455 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10456 if (SWIG_arg_fail(1)) SWIG_fail;
10457 }
10458 {
10459 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10460 if (SWIG_arg_fail(2)) SWIG_fail;
10461 }
10462 {
10463 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10464 if (SWIG_arg_fail(3)) SWIG_fail;
10465 }
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10469
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 {
10474 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10475 }
10476 return resultobj;
10477 fail:
10478 return NULL;
10479 }
10480
10481
10482 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10483 PyObject *resultobj = NULL;
10484 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10485 byte *arg2 = (byte *) 0 ;
10486 byte *arg3 = (byte *) 0 ;
10487 byte *arg4 = (byte *) 0 ;
10488 byte arg5 = (byte) 1 ;
10489 byte arg6 = (byte) 0 ;
10490 byte arg7 = (byte) 0 ;
10491 bool result;
10492 byte temp2 ;
10493 int res2 = 0 ;
10494 byte temp3 ;
10495 int res3 = 0 ;
10496 byte temp4 ;
10497 int res4 = 0 ;
10498 PyObject * obj0 = 0 ;
10499 PyObject * obj1 = 0 ;
10500 PyObject * obj2 = 0 ;
10501 PyObject * obj3 = 0 ;
10502 char *kwnames[] = {
10503 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10504 };
10505
10506 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10507 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10508 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10511 if (SWIG_arg_fail(1)) SWIG_fail;
10512 if (obj1) {
10513 {
10514 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10515 if (SWIG_arg_fail(5)) SWIG_fail;
10516 }
10517 }
10518 if (obj2) {
10519 {
10520 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10521 if (SWIG_arg_fail(6)) SWIG_fail;
10522 }
10523 }
10524 if (obj3) {
10525 {
10526 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10527 if (SWIG_arg_fail(7)) SWIG_fail;
10528 }
10529 }
10530 {
10531 PyThreadState* __tstate = wxPyBeginAllowThreads();
10532 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10533
10534 wxPyEndAllowThreads(__tstate);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 {
10538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10539 }
10540 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10541 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10542 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10543 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10544 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10545 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10546 return resultobj;
10547 fail:
10548 return NULL;
10549 }
10550
10551
10552 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj = NULL;
10554 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10555 unsigned long arg2 ;
10556 unsigned long result;
10557 PyObject * obj0 = 0 ;
10558 PyObject * obj1 = 0 ;
10559 char *kwnames[] = {
10560 (char *) "self",(char *) "key", NULL
10561 };
10562
10563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10565 if (SWIG_arg_fail(1)) SWIG_fail;
10566 {
10567 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10568 if (SWIG_arg_fail(2)) SWIG_fail;
10569 }
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 {
10578 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10579 }
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj = NULL;
10588 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10589 byte arg2 ;
10590 byte arg3 ;
10591 byte arg4 ;
10592 unsigned long result;
10593 PyObject * obj0 = 0 ;
10594 PyObject * obj1 = 0 ;
10595 PyObject * obj2 = 0 ;
10596 PyObject * obj3 = 0 ;
10597 char *kwnames[] = {
10598 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10599 };
10600
10601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10603 if (SWIG_arg_fail(1)) SWIG_fail;
10604 {
10605 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10606 if (SWIG_arg_fail(2)) SWIG_fail;
10607 }
10608 {
10609 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10610 if (SWIG_arg_fail(3)) SWIG_fail;
10611 }
10612 {
10613 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10614 if (SWIG_arg_fail(4)) SWIG_fail;
10615 }
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10619
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 {
10624 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10625 }
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj = NULL;
10634 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10635 wxColour *arg2 = 0 ;
10636 unsigned long result;
10637 wxColour temp2 ;
10638 PyObject * obj0 = 0 ;
10639 PyObject * obj1 = 0 ;
10640 char *kwnames[] = {
10641 (char *) "self",(char *) "colour", NULL
10642 };
10643
10644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10646 if (SWIG_arg_fail(1)) SWIG_fail;
10647 {
10648 arg2 = &temp2;
10649 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10650 }
10651 {
10652 PyThreadState* __tstate = wxPyBeginAllowThreads();
10653 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10654
10655 wxPyEndAllowThreads(__tstate);
10656 if (PyErr_Occurred()) SWIG_fail;
10657 }
10658 {
10659 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10660 }
10661 return resultobj;
10662 fail:
10663 return NULL;
10664 }
10665
10666
10667 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10668 PyObject *obj;
10669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10670 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10671 Py_INCREF(obj);
10672 return Py_BuildValue((char *)"");
10673 }
10674 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10675 PyObject *resultobj = NULL;
10676 byte arg1 = (byte) 0 ;
10677 byte arg2 = (byte) 0 ;
10678 byte arg3 = (byte) 0 ;
10679 wxImage_RGBValue *result;
10680 PyObject * obj0 = 0 ;
10681 PyObject * obj1 = 0 ;
10682 PyObject * obj2 = 0 ;
10683 char *kwnames[] = {
10684 (char *) "r",(char *) "g",(char *) "b", NULL
10685 };
10686
10687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10688 if (obj0) {
10689 {
10690 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10691 if (SWIG_arg_fail(1)) SWIG_fail;
10692 }
10693 }
10694 if (obj1) {
10695 {
10696 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10697 if (SWIG_arg_fail(2)) SWIG_fail;
10698 }
10699 }
10700 if (obj2) {
10701 {
10702 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10703 if (SWIG_arg_fail(3)) SWIG_fail;
10704 }
10705 }
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10709
10710 wxPyEndAllowThreads(__tstate);
10711 if (PyErr_Occurred()) SWIG_fail;
10712 }
10713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10714 return resultobj;
10715 fail:
10716 return NULL;
10717 }
10718
10719
10720 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10721 PyObject *resultobj = NULL;
10722 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10723 byte arg2 ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 char *kwnames[] = {
10727 (char *) "self",(char *) "red", NULL
10728 };
10729
10730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10732 if (SWIG_arg_fail(1)) SWIG_fail;
10733 {
10734 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10735 if (SWIG_arg_fail(2)) SWIG_fail;
10736 }
10737 if (arg1) (arg1)->red = arg2;
10738
10739 Py_INCREF(Py_None); resultobj = Py_None;
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj = NULL;
10748 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10749 byte result;
10750 PyObject * obj0 = 0 ;
10751 char *kwnames[] = {
10752 (char *) "self", NULL
10753 };
10754
10755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10757 if (SWIG_arg_fail(1)) SWIG_fail;
10758 result = (byte) ((arg1)->red);
10759
10760 {
10761 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10762 }
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj = NULL;
10771 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10772 byte arg2 ;
10773 PyObject * obj0 = 0 ;
10774 PyObject * obj1 = 0 ;
10775 char *kwnames[] = {
10776 (char *) "self",(char *) "green", NULL
10777 };
10778
10779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10781 if (SWIG_arg_fail(1)) SWIG_fail;
10782 {
10783 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10784 if (SWIG_arg_fail(2)) SWIG_fail;
10785 }
10786 if (arg1) (arg1)->green = arg2;
10787
10788 Py_INCREF(Py_None); resultobj = Py_None;
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj = NULL;
10797 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10798 byte result;
10799 PyObject * obj0 = 0 ;
10800 char *kwnames[] = {
10801 (char *) "self", NULL
10802 };
10803
10804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10806 if (SWIG_arg_fail(1)) SWIG_fail;
10807 result = (byte) ((arg1)->green);
10808
10809 {
10810 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10811 }
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj = NULL;
10820 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10821 byte arg2 ;
10822 PyObject * obj0 = 0 ;
10823 PyObject * obj1 = 0 ;
10824 char *kwnames[] = {
10825 (char *) "self",(char *) "blue", NULL
10826 };
10827
10828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10830 if (SWIG_arg_fail(1)) SWIG_fail;
10831 {
10832 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10833 if (SWIG_arg_fail(2)) SWIG_fail;
10834 }
10835 if (arg1) (arg1)->blue = arg2;
10836
10837 Py_INCREF(Py_None); resultobj = Py_None;
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj = NULL;
10846 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10847 byte result;
10848 PyObject * obj0 = 0 ;
10849 char *kwnames[] = {
10850 (char *) "self", NULL
10851 };
10852
10853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10855 if (SWIG_arg_fail(1)) SWIG_fail;
10856 result = (byte) ((arg1)->blue);
10857
10858 {
10859 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10860 }
10861 return resultobj;
10862 fail:
10863 return NULL;
10864 }
10865
10866
10867 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10868 PyObject *obj;
10869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10870 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10871 Py_INCREF(obj);
10872 return Py_BuildValue((char *)"");
10873 }
10874 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = NULL;
10876 double arg1 = (double) 0.0 ;
10877 double arg2 = (double) 0.0 ;
10878 double arg3 = (double) 0.0 ;
10879 wxImage_HSVValue *result;
10880 PyObject * obj0 = 0 ;
10881 PyObject * obj1 = 0 ;
10882 PyObject * obj2 = 0 ;
10883 char *kwnames[] = {
10884 (char *) "h",(char *) "s",(char *) "v", NULL
10885 };
10886
10887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10888 if (obj0) {
10889 {
10890 arg1 = static_cast<double >(SWIG_As_double(obj0));
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 }
10893 }
10894 if (obj1) {
10895 {
10896 arg2 = static_cast<double >(SWIG_As_double(obj1));
10897 if (SWIG_arg_fail(2)) SWIG_fail;
10898 }
10899 }
10900 if (obj2) {
10901 {
10902 arg3 = static_cast<double >(SWIG_As_double(obj2));
10903 if (SWIG_arg_fail(3)) SWIG_fail;
10904 }
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10909
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10914 return resultobj;
10915 fail:
10916 return NULL;
10917 }
10918
10919
10920 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10921 PyObject *resultobj = NULL;
10922 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10923 double arg2 ;
10924 PyObject * obj0 = 0 ;
10925 PyObject * obj1 = 0 ;
10926 char *kwnames[] = {
10927 (char *) "self",(char *) "hue", NULL
10928 };
10929
10930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10932 if (SWIG_arg_fail(1)) SWIG_fail;
10933 {
10934 arg2 = static_cast<double >(SWIG_As_double(obj1));
10935 if (SWIG_arg_fail(2)) SWIG_fail;
10936 }
10937 if (arg1) (arg1)->hue = arg2;
10938
10939 Py_INCREF(Py_None); resultobj = Py_None;
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj = NULL;
10948 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10949 double result;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 result = (double) ((arg1)->hue);
10959
10960 {
10961 resultobj = SWIG_From_double(static_cast<double >(result));
10962 }
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj = NULL;
10971 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10972 double arg2 ;
10973 PyObject * obj0 = 0 ;
10974 PyObject * obj1 = 0 ;
10975 char *kwnames[] = {
10976 (char *) "self",(char *) "saturation", NULL
10977 };
10978
10979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10981 if (SWIG_arg_fail(1)) SWIG_fail;
10982 {
10983 arg2 = static_cast<double >(SWIG_As_double(obj1));
10984 if (SWIG_arg_fail(2)) SWIG_fail;
10985 }
10986 if (arg1) (arg1)->saturation = arg2;
10987
10988 Py_INCREF(Py_None); resultobj = Py_None;
10989 return resultobj;
10990 fail:
10991 return NULL;
10992 }
10993
10994
10995 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10996 PyObject *resultobj = NULL;
10997 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10998 double result;
10999 PyObject * obj0 = 0 ;
11000 char *kwnames[] = {
11001 (char *) "self", NULL
11002 };
11003
11004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
11005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11006 if (SWIG_arg_fail(1)) SWIG_fail;
11007 result = (double) ((arg1)->saturation);
11008
11009 {
11010 resultobj = SWIG_From_double(static_cast<double >(result));
11011 }
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj = NULL;
11020 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11021 double arg2 ;
11022 PyObject * obj0 = 0 ;
11023 PyObject * obj1 = 0 ;
11024 char *kwnames[] = {
11025 (char *) "self",(char *) "value", NULL
11026 };
11027
11028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11030 if (SWIG_arg_fail(1)) SWIG_fail;
11031 {
11032 arg2 = static_cast<double >(SWIG_As_double(obj1));
11033 if (SWIG_arg_fail(2)) SWIG_fail;
11034 }
11035 if (arg1) (arg1)->value = arg2;
11036
11037 Py_INCREF(Py_None); resultobj = Py_None;
11038 return resultobj;
11039 fail:
11040 return NULL;
11041 }
11042
11043
11044 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj = NULL;
11046 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11047 double result;
11048 PyObject * obj0 = 0 ;
11049 char *kwnames[] = {
11050 (char *) "self", NULL
11051 };
11052
11053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11055 if (SWIG_arg_fail(1)) SWIG_fail;
11056 result = (double) ((arg1)->value);
11057
11058 {
11059 resultobj = SWIG_From_double(static_cast<double >(result));
11060 }
11061 return resultobj;
11062 fail:
11063 return NULL;
11064 }
11065
11066
11067 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11068 PyObject *obj;
11069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11070 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11071 Py_INCREF(obj);
11072 return Py_BuildValue((char *)"");
11073 }
11074 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj = NULL;
11076 wxString *arg1 = 0 ;
11077 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11078 int arg3 = (int) -1 ;
11079 wxImage *result;
11080 bool temp1 = false ;
11081 PyObject * obj0 = 0 ;
11082 PyObject * obj1 = 0 ;
11083 PyObject * obj2 = 0 ;
11084 char *kwnames[] = {
11085 (char *) "name",(char *) "type",(char *) "index", NULL
11086 };
11087
11088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11089 {
11090 arg1 = wxString_in_helper(obj0);
11091 if (arg1 == NULL) SWIG_fail;
11092 temp1 = true;
11093 }
11094 if (obj1) {
11095 {
11096 arg2 = static_cast<long >(SWIG_As_long(obj1));
11097 if (SWIG_arg_fail(2)) SWIG_fail;
11098 }
11099 }
11100 if (obj2) {
11101 {
11102 arg3 = static_cast<int >(SWIG_As_int(obj2));
11103 if (SWIG_arg_fail(3)) SWIG_fail;
11104 }
11105 }
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11109
11110 wxPyEndAllowThreads(__tstate);
11111 if (PyErr_Occurred()) SWIG_fail;
11112 }
11113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11114 {
11115 if (temp1)
11116 delete arg1;
11117 }
11118 return resultobj;
11119 fail:
11120 {
11121 if (temp1)
11122 delete arg1;
11123 }
11124 return NULL;
11125 }
11126
11127
11128 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11129 PyObject *resultobj = NULL;
11130 wxImage *arg1 = (wxImage *) 0 ;
11131 PyObject * obj0 = 0 ;
11132 char *kwnames[] = {
11133 (char *) "self", NULL
11134 };
11135
11136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11138 if (SWIG_arg_fail(1)) SWIG_fail;
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 delete arg1;
11142
11143 wxPyEndAllowThreads(__tstate);
11144 if (PyErr_Occurred()) SWIG_fail;
11145 }
11146 Py_INCREF(Py_None); resultobj = Py_None;
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11154 PyObject *resultobj = NULL;
11155 wxString *arg1 = 0 ;
11156 wxString *arg2 = 0 ;
11157 int arg3 = (int) -1 ;
11158 wxImage *result;
11159 bool temp1 = false ;
11160 bool temp2 = false ;
11161 PyObject * obj0 = 0 ;
11162 PyObject * obj1 = 0 ;
11163 PyObject * obj2 = 0 ;
11164 char *kwnames[] = {
11165 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11166 };
11167
11168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11169 {
11170 arg1 = wxString_in_helper(obj0);
11171 if (arg1 == NULL) SWIG_fail;
11172 temp1 = true;
11173 }
11174 {
11175 arg2 = wxString_in_helper(obj1);
11176 if (arg2 == NULL) SWIG_fail;
11177 temp2 = true;
11178 }
11179 if (obj2) {
11180 {
11181 arg3 = static_cast<int >(SWIG_As_int(obj2));
11182 if (SWIG_arg_fail(3)) SWIG_fail;
11183 }
11184 }
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11188
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11193 {
11194 if (temp1)
11195 delete arg1;
11196 }
11197 {
11198 if (temp2)
11199 delete arg2;
11200 }
11201 return resultobj;
11202 fail:
11203 {
11204 if (temp1)
11205 delete arg1;
11206 }
11207 {
11208 if (temp2)
11209 delete arg2;
11210 }
11211 return NULL;
11212 }
11213
11214
11215 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj = NULL;
11217 wxInputStream *arg1 = 0 ;
11218 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11219 int arg3 = (int) -1 ;
11220 wxImage *result;
11221 wxPyInputStream *temp1 ;
11222 bool created1 ;
11223 PyObject * obj0 = 0 ;
11224 PyObject * obj1 = 0 ;
11225 PyObject * obj2 = 0 ;
11226 char *kwnames[] = {
11227 (char *) "stream",(char *) "type",(char *) "index", NULL
11228 };
11229
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11231 {
11232 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11233 arg1 = temp1->m_wxis;
11234 created1 = false;
11235 } else {
11236 PyErr_Clear(); // clear the failure of the wxPyConvert above
11237 arg1 = wxPyCBInputStream_create(obj0, false);
11238 if (arg1 == NULL) {
11239 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11240 SWIG_fail;
11241 }
11242 created1 = true;
11243 }
11244 }
11245 if (obj1) {
11246 {
11247 arg2 = static_cast<long >(SWIG_As_long(obj1));
11248 if (SWIG_arg_fail(2)) SWIG_fail;
11249 }
11250 }
11251 if (obj2) {
11252 {
11253 arg3 = static_cast<int >(SWIG_As_int(obj2));
11254 if (SWIG_arg_fail(3)) SWIG_fail;
11255 }
11256 }
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11260
11261 wxPyEndAllowThreads(__tstate);
11262 if (PyErr_Occurred()) SWIG_fail;
11263 }
11264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11265 {
11266 if (created1) delete arg1;
11267 }
11268 return resultobj;
11269 fail:
11270 {
11271 if (created1) delete arg1;
11272 }
11273 return NULL;
11274 }
11275
11276
11277 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11278 PyObject *resultobj = NULL;
11279 wxInputStream *arg1 = 0 ;
11280 wxString *arg2 = 0 ;
11281 int arg3 = (int) -1 ;
11282 wxImage *result;
11283 wxPyInputStream *temp1 ;
11284 bool created1 ;
11285 bool temp2 = false ;
11286 PyObject * obj0 = 0 ;
11287 PyObject * obj1 = 0 ;
11288 PyObject * obj2 = 0 ;
11289 char *kwnames[] = {
11290 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11291 };
11292
11293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11294 {
11295 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11296 arg1 = temp1->m_wxis;
11297 created1 = false;
11298 } else {
11299 PyErr_Clear(); // clear the failure of the wxPyConvert above
11300 arg1 = wxPyCBInputStream_create(obj0, false);
11301 if (arg1 == NULL) {
11302 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11303 SWIG_fail;
11304 }
11305 created1 = true;
11306 }
11307 }
11308 {
11309 arg2 = wxString_in_helper(obj1);
11310 if (arg2 == NULL) SWIG_fail;
11311 temp2 = true;
11312 }
11313 if (obj2) {
11314 {
11315 arg3 = static_cast<int >(SWIG_As_int(obj2));
11316 if (SWIG_arg_fail(3)) SWIG_fail;
11317 }
11318 }
11319 {
11320 PyThreadState* __tstate = wxPyBeginAllowThreads();
11321 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11322
11323 wxPyEndAllowThreads(__tstate);
11324 if (PyErr_Occurred()) SWIG_fail;
11325 }
11326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11327 {
11328 if (created1) delete arg1;
11329 }
11330 {
11331 if (temp2)
11332 delete arg2;
11333 }
11334 return resultobj;
11335 fail:
11336 {
11337 if (created1) delete arg1;
11338 }
11339 {
11340 if (temp2)
11341 delete arg2;
11342 }
11343 return NULL;
11344 }
11345
11346
11347 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj = NULL;
11349 int arg1 = (int) 0 ;
11350 int arg2 = (int) 0 ;
11351 bool arg3 = (bool) true ;
11352 wxImage *result;
11353 PyObject * obj0 = 0 ;
11354 PyObject * obj1 = 0 ;
11355 PyObject * obj2 = 0 ;
11356 char *kwnames[] = {
11357 (char *) "width",(char *) "height",(char *) "clear", NULL
11358 };
11359
11360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11361 if (obj0) {
11362 {
11363 arg1 = static_cast<int >(SWIG_As_int(obj0));
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 }
11366 }
11367 if (obj1) {
11368 {
11369 arg2 = static_cast<int >(SWIG_As_int(obj1));
11370 if (SWIG_arg_fail(2)) SWIG_fail;
11371 }
11372 }
11373 if (obj2) {
11374 {
11375 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11376 if (SWIG_arg_fail(3)) SWIG_fail;
11377 }
11378 }
11379 {
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11382
11383 wxPyEndAllowThreads(__tstate);
11384 if (PyErr_Occurred()) SWIG_fail;
11385 }
11386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11387 return resultobj;
11388 fail:
11389 return NULL;
11390 }
11391
11392
11393 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11394 PyObject *resultobj = NULL;
11395 wxBitmap *arg1 = 0 ;
11396 wxImage *result;
11397 PyObject * obj0 = 0 ;
11398 char *kwnames[] = {
11399 (char *) "bitmap", NULL
11400 };
11401
11402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11403 {
11404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11405 if (SWIG_arg_fail(1)) SWIG_fail;
11406 if (arg1 == NULL) {
11407 SWIG_null_ref("wxBitmap");
11408 }
11409 if (SWIG_arg_fail(1)) SWIG_fail;
11410 }
11411 {
11412 if (!wxPyCheckForApp()) SWIG_fail;
11413 PyThreadState* __tstate = wxPyBeginAllowThreads();
11414 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11415
11416 wxPyEndAllowThreads(__tstate);
11417 if (PyErr_Occurred()) SWIG_fail;
11418 }
11419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11420 return resultobj;
11421 fail:
11422 return NULL;
11423 }
11424
11425
11426 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11427 PyObject *resultobj = NULL;
11428 int arg1 ;
11429 int arg2 ;
11430 buffer arg3 ;
11431 int arg4 ;
11432 wxImage *result;
11433 PyObject * obj0 = 0 ;
11434 PyObject * obj1 = 0 ;
11435 PyObject * obj2 = 0 ;
11436 char *kwnames[] = {
11437 (char *) "width",(char *) "height",(char *) "data", NULL
11438 };
11439
11440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11441 {
11442 arg1 = static_cast<int >(SWIG_As_int(obj0));
11443 if (SWIG_arg_fail(1)) SWIG_fail;
11444 }
11445 {
11446 arg2 = static_cast<int >(SWIG_As_int(obj1));
11447 if (SWIG_arg_fail(2)) SWIG_fail;
11448 }
11449 {
11450 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11451 }
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11455
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj = NULL;
11468 int arg1 ;
11469 int arg2 ;
11470 buffer arg3 ;
11471 int arg4 ;
11472 buffer arg5 ;
11473 int arg6 ;
11474 wxImage *result;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 PyObject * obj2 = 0 ;
11478 PyObject * obj3 = 0 ;
11479 char *kwnames[] = {
11480 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11481 };
11482
11483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11484 {
11485 arg1 = static_cast<int >(SWIG_As_int(obj0));
11486 if (SWIG_arg_fail(1)) SWIG_fail;
11487 }
11488 {
11489 arg2 = static_cast<int >(SWIG_As_int(obj1));
11490 if (SWIG_arg_fail(2)) SWIG_fail;
11491 }
11492 {
11493 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11494 }
11495 {
11496 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11497 }
11498 {
11499 PyThreadState* __tstate = wxPyBeginAllowThreads();
11500 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11501
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11506 return resultobj;
11507 fail:
11508 return NULL;
11509 }
11510
11511
11512 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11513 PyObject *resultobj = NULL;
11514 wxImage *arg1 = (wxImage *) 0 ;
11515 int arg2 ;
11516 int arg3 ;
11517 bool arg4 = (bool) true ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 PyObject * obj3 = 0 ;
11522 char *kwnames[] = {
11523 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11524 };
11525
11526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11528 if (SWIG_arg_fail(1)) SWIG_fail;
11529 {
11530 arg2 = static_cast<int >(SWIG_As_int(obj1));
11531 if (SWIG_arg_fail(2)) SWIG_fail;
11532 }
11533 {
11534 arg3 = static_cast<int >(SWIG_As_int(obj2));
11535 if (SWIG_arg_fail(3)) SWIG_fail;
11536 }
11537 if (obj3) {
11538 {
11539 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11540 if (SWIG_arg_fail(4)) SWIG_fail;
11541 }
11542 }
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 (arg1)->Create(arg2,arg3,arg4);
11546
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 Py_INCREF(Py_None); resultobj = Py_None;
11551 return resultobj;
11552 fail:
11553 return NULL;
11554 }
11555
11556
11557 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11558 PyObject *resultobj = NULL;
11559 wxImage *arg1 = (wxImage *) 0 ;
11560 PyObject * obj0 = 0 ;
11561 char *kwnames[] = {
11562 (char *) "self", NULL
11563 };
11564
11565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11567 if (SWIG_arg_fail(1)) SWIG_fail;
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 (arg1)->Destroy();
11571
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 Py_INCREF(Py_None); resultobj = Py_None;
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj = NULL;
11584 wxImage *arg1 = (wxImage *) 0 ;
11585 int arg2 ;
11586 int arg3 ;
11587 SwigValueWrapper<wxImage > result;
11588 PyObject * obj0 = 0 ;
11589 PyObject * obj1 = 0 ;
11590 PyObject * obj2 = 0 ;
11591 char *kwnames[] = {
11592 (char *) "self",(char *) "width",(char *) "height", NULL
11593 };
11594
11595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11597 if (SWIG_arg_fail(1)) SWIG_fail;
11598 {
11599 arg2 = static_cast<int >(SWIG_As_int(obj1));
11600 if (SWIG_arg_fail(2)) SWIG_fail;
11601 }
11602 {
11603 arg3 = static_cast<int >(SWIG_As_int(obj2));
11604 if (SWIG_arg_fail(3)) SWIG_fail;
11605 }
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (arg1)->Scale(arg2,arg3);
11609
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 wxImage * resultptr;
11615 resultptr = new wxImage(static_cast<wxImage & >(result));
11616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11617 }
11618 return resultobj;
11619 fail:
11620 return NULL;
11621 }
11622
11623
11624 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11625 PyObject *resultobj = NULL;
11626 wxImage *arg1 = (wxImage *) 0 ;
11627 int arg2 ;
11628 int arg3 ;
11629 SwigValueWrapper<wxImage > result;
11630 PyObject * obj0 = 0 ;
11631 PyObject * obj1 = 0 ;
11632 PyObject * obj2 = 0 ;
11633 char *kwnames[] = {
11634 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11635 };
11636
11637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11639 if (SWIG_arg_fail(1)) SWIG_fail;
11640 {
11641 arg2 = static_cast<int >(SWIG_As_int(obj1));
11642 if (SWIG_arg_fail(2)) SWIG_fail;
11643 }
11644 {
11645 arg3 = static_cast<int >(SWIG_As_int(obj2));
11646 if (SWIG_arg_fail(3)) SWIG_fail;
11647 }
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11651
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 {
11656 wxImage * resultptr;
11657 resultptr = new wxImage(static_cast<wxImage & >(result));
11658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11659 }
11660 return resultobj;
11661 fail:
11662 return NULL;
11663 }
11664
11665
11666 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11667 PyObject *resultobj = NULL;
11668 wxImage *arg1 = (wxImage *) 0 ;
11669 int arg2 ;
11670 int arg3 ;
11671 wxImage *result;
11672 PyObject * obj0 = 0 ;
11673 PyObject * obj1 = 0 ;
11674 PyObject * obj2 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self",(char *) "width",(char *) "height", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 arg2 = static_cast<int >(SWIG_As_int(obj1));
11684 if (SWIG_arg_fail(2)) SWIG_fail;
11685 }
11686 {
11687 arg3 = static_cast<int >(SWIG_As_int(obj2));
11688 if (SWIG_arg_fail(3)) SWIG_fail;
11689 }
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 {
11693 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11694 result = (wxImage *) &_result_ref;
11695 }
11696
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11708 PyObject *resultobj = NULL;
11709 wxImage *arg1 = (wxImage *) 0 ;
11710 wxSize *arg2 = 0 ;
11711 wxPoint *arg3 = 0 ;
11712 int arg4 = (int) -1 ;
11713 int arg5 = (int) -1 ;
11714 int arg6 = (int) -1 ;
11715 wxImage *result;
11716 wxSize temp2 ;
11717 wxPoint temp3 ;
11718 PyObject * obj0 = 0 ;
11719 PyObject * obj1 = 0 ;
11720 PyObject * obj2 = 0 ;
11721 PyObject * obj3 = 0 ;
11722 PyObject * obj4 = 0 ;
11723 PyObject * obj5 = 0 ;
11724 char *kwnames[] = {
11725 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11726 };
11727
11728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11730 if (SWIG_arg_fail(1)) SWIG_fail;
11731 {
11732 arg2 = &temp2;
11733 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11734 }
11735 {
11736 arg3 = &temp3;
11737 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11738 }
11739 if (obj3) {
11740 {
11741 arg4 = static_cast<int >(SWIG_As_int(obj3));
11742 if (SWIG_arg_fail(4)) SWIG_fail;
11743 }
11744 }
11745 if (obj4) {
11746 {
11747 arg5 = static_cast<int >(SWIG_As_int(obj4));
11748 if (SWIG_arg_fail(5)) SWIG_fail;
11749 }
11750 }
11751 if (obj5) {
11752 {
11753 arg6 = static_cast<int >(SWIG_As_int(obj5));
11754 if (SWIG_arg_fail(6)) SWIG_fail;
11755 }
11756 }
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 {
11760 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11761 result = (wxImage *) &_result_ref;
11762 }
11763
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11768 return resultobj;
11769 fail:
11770 return NULL;
11771 }
11772
11773
11774 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11775 PyObject *resultobj = NULL;
11776 wxImage *arg1 = (wxImage *) 0 ;
11777 int arg2 ;
11778 int arg3 ;
11779 byte arg4 ;
11780 byte arg5 ;
11781 byte arg6 ;
11782 PyObject * obj0 = 0 ;
11783 PyObject * obj1 = 0 ;
11784 PyObject * obj2 = 0 ;
11785 PyObject * obj3 = 0 ;
11786 PyObject * obj4 = 0 ;
11787 PyObject * obj5 = 0 ;
11788 char *kwnames[] = {
11789 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11790 };
11791
11792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11794 if (SWIG_arg_fail(1)) SWIG_fail;
11795 {
11796 arg2 = static_cast<int >(SWIG_As_int(obj1));
11797 if (SWIG_arg_fail(2)) SWIG_fail;
11798 }
11799 {
11800 arg3 = static_cast<int >(SWIG_As_int(obj2));
11801 if (SWIG_arg_fail(3)) SWIG_fail;
11802 }
11803 {
11804 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11805 if (SWIG_arg_fail(4)) SWIG_fail;
11806 }
11807 {
11808 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11809 if (SWIG_arg_fail(5)) SWIG_fail;
11810 }
11811 {
11812 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11813 if (SWIG_arg_fail(6)) SWIG_fail;
11814 }
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 Py_INCREF(Py_None); resultobj = Py_None;
11823 return resultobj;
11824 fail:
11825 return NULL;
11826 }
11827
11828
11829 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11830 PyObject *resultobj = NULL;
11831 wxImage *arg1 = (wxImage *) 0 ;
11832 wxRect *arg2 = 0 ;
11833 byte arg3 ;
11834 byte arg4 ;
11835 byte arg5 ;
11836 wxRect temp2 ;
11837 PyObject * obj0 = 0 ;
11838 PyObject * obj1 = 0 ;
11839 PyObject * obj2 = 0 ;
11840 PyObject * obj3 = 0 ;
11841 PyObject * obj4 = 0 ;
11842 char *kwnames[] = {
11843 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11844 };
11845
11846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11848 if (SWIG_arg_fail(1)) SWIG_fail;
11849 {
11850 arg2 = &temp2;
11851 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11852 }
11853 {
11854 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11855 if (SWIG_arg_fail(3)) SWIG_fail;
11856 }
11857 {
11858 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11859 if (SWIG_arg_fail(4)) SWIG_fail;
11860 }
11861 {
11862 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11863 if (SWIG_arg_fail(5)) SWIG_fail;
11864 }
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11868
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 Py_INCREF(Py_None); resultobj = Py_None;
11873 return resultobj;
11874 fail:
11875 return NULL;
11876 }
11877
11878
11879 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11880 PyObject *resultobj = NULL;
11881 wxImage *arg1 = (wxImage *) 0 ;
11882 int arg2 ;
11883 int arg3 ;
11884 byte result;
11885 PyObject * obj0 = 0 ;
11886 PyObject * obj1 = 0 ;
11887 PyObject * obj2 = 0 ;
11888 char *kwnames[] = {
11889 (char *) "self",(char *) "x",(char *) "y", NULL
11890 };
11891
11892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11894 if (SWIG_arg_fail(1)) SWIG_fail;
11895 {
11896 arg2 = static_cast<int >(SWIG_As_int(obj1));
11897 if (SWIG_arg_fail(2)) SWIG_fail;
11898 }
11899 {
11900 arg3 = static_cast<int >(SWIG_As_int(obj2));
11901 if (SWIG_arg_fail(3)) SWIG_fail;
11902 }
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (byte)(arg1)->GetRed(arg2,arg3);
11906
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11912 }
11913 return resultobj;
11914 fail:
11915 return NULL;
11916 }
11917
11918
11919 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11920 PyObject *resultobj = NULL;
11921 wxImage *arg1 = (wxImage *) 0 ;
11922 int arg2 ;
11923 int arg3 ;
11924 byte result;
11925 PyObject * obj0 = 0 ;
11926 PyObject * obj1 = 0 ;
11927 PyObject * obj2 = 0 ;
11928 char *kwnames[] = {
11929 (char *) "self",(char *) "x",(char *) "y", NULL
11930 };
11931
11932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11934 if (SWIG_arg_fail(1)) SWIG_fail;
11935 {
11936 arg2 = static_cast<int >(SWIG_As_int(obj1));
11937 if (SWIG_arg_fail(2)) SWIG_fail;
11938 }
11939 {
11940 arg3 = static_cast<int >(SWIG_As_int(obj2));
11941 if (SWIG_arg_fail(3)) SWIG_fail;
11942 }
11943 {
11944 PyThreadState* __tstate = wxPyBeginAllowThreads();
11945 result = (byte)(arg1)->GetGreen(arg2,arg3);
11946
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 {
11951 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11952 }
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11960 PyObject *resultobj = NULL;
11961 wxImage *arg1 = (wxImage *) 0 ;
11962 int arg2 ;
11963 int arg3 ;
11964 byte result;
11965 PyObject * obj0 = 0 ;
11966 PyObject * obj1 = 0 ;
11967 PyObject * obj2 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self",(char *) "x",(char *) "y", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 arg2 = static_cast<int >(SWIG_As_int(obj1));
11977 if (SWIG_arg_fail(2)) SWIG_fail;
11978 }
11979 {
11980 arg3 = static_cast<int >(SWIG_As_int(obj2));
11981 if (SWIG_arg_fail(3)) SWIG_fail;
11982 }
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (byte)(arg1)->GetBlue(arg2,arg3);
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11992 }
11993 return resultobj;
11994 fail:
11995 return NULL;
11996 }
11997
11998
11999 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj = NULL;
12001 wxImage *arg1 = (wxImage *) 0 ;
12002 int arg2 ;
12003 int arg3 ;
12004 byte arg4 ;
12005 PyObject * obj0 = 0 ;
12006 PyObject * obj1 = 0 ;
12007 PyObject * obj2 = 0 ;
12008 PyObject * obj3 = 0 ;
12009 char *kwnames[] = {
12010 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12011 };
12012
12013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12015 if (SWIG_arg_fail(1)) SWIG_fail;
12016 {
12017 arg2 = static_cast<int >(SWIG_As_int(obj1));
12018 if (SWIG_arg_fail(2)) SWIG_fail;
12019 }
12020 {
12021 arg3 = static_cast<int >(SWIG_As_int(obj2));
12022 if (SWIG_arg_fail(3)) SWIG_fail;
12023 }
12024 {
12025 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12026 if (SWIG_arg_fail(4)) SWIG_fail;
12027 }
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 (arg1)->SetAlpha(arg2,arg3,arg4);
12031
12032 wxPyEndAllowThreads(__tstate);
12033 if (PyErr_Occurred()) SWIG_fail;
12034 }
12035 Py_INCREF(Py_None); resultobj = Py_None;
12036 return resultobj;
12037 fail:
12038 return NULL;
12039 }
12040
12041
12042 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12043 PyObject *resultobj = NULL;
12044 wxImage *arg1 = (wxImage *) 0 ;
12045 int arg2 ;
12046 int arg3 ;
12047 byte result;
12048 PyObject * obj0 = 0 ;
12049 PyObject * obj1 = 0 ;
12050 PyObject * obj2 = 0 ;
12051 char *kwnames[] = {
12052 (char *) "self",(char *) "x",(char *) "y", NULL
12053 };
12054
12055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12057 if (SWIG_arg_fail(1)) SWIG_fail;
12058 {
12059 arg2 = static_cast<int >(SWIG_As_int(obj1));
12060 if (SWIG_arg_fail(2)) SWIG_fail;
12061 }
12062 {
12063 arg3 = static_cast<int >(SWIG_As_int(obj2));
12064 if (SWIG_arg_fail(3)) SWIG_fail;
12065 }
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12069
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 {
12074 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12075 }
12076 return resultobj;
12077 fail:
12078 return NULL;
12079 }
12080
12081
12082 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12083 PyObject *resultobj = NULL;
12084 wxImage *arg1 = (wxImage *) 0 ;
12085 bool result;
12086 PyObject * obj0 = 0 ;
12087 char *kwnames[] = {
12088 (char *) "self", NULL
12089 };
12090
12091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12093 if (SWIG_arg_fail(1)) SWIG_fail;
12094 {
12095 PyThreadState* __tstate = wxPyBeginAllowThreads();
12096 result = (bool)(arg1)->HasAlpha();
12097
12098 wxPyEndAllowThreads(__tstate);
12099 if (PyErr_Occurred()) SWIG_fail;
12100 }
12101 {
12102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12103 }
12104 return resultobj;
12105 fail:
12106 return NULL;
12107 }
12108
12109
12110 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12111 PyObject *resultobj = NULL;
12112 wxImage *arg1 = (wxImage *) 0 ;
12113 PyObject * obj0 = 0 ;
12114 char *kwnames[] = {
12115 (char *) "self", NULL
12116 };
12117
12118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12120 if (SWIG_arg_fail(1)) SWIG_fail;
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 (arg1)->InitAlpha();
12124
12125 wxPyEndAllowThreads(__tstate);
12126 if (PyErr_Occurred()) SWIG_fail;
12127 }
12128 Py_INCREF(Py_None); resultobj = Py_None;
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12136 PyObject *resultobj = NULL;
12137 wxImage *arg1 = (wxImage *) 0 ;
12138 int arg2 ;
12139 int arg3 ;
12140 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12141 bool result;
12142 PyObject * obj0 = 0 ;
12143 PyObject * obj1 = 0 ;
12144 PyObject * obj2 = 0 ;
12145 PyObject * obj3 = 0 ;
12146 char *kwnames[] = {
12147 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12148 };
12149
12150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12152 if (SWIG_arg_fail(1)) SWIG_fail;
12153 {
12154 arg2 = static_cast<int >(SWIG_As_int(obj1));
12155 if (SWIG_arg_fail(2)) SWIG_fail;
12156 }
12157 {
12158 arg3 = static_cast<int >(SWIG_As_int(obj2));
12159 if (SWIG_arg_fail(3)) SWIG_fail;
12160 }
12161 if (obj3) {
12162 {
12163 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12164 if (SWIG_arg_fail(4)) SWIG_fail;
12165 }
12166 }
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12170
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 {
12175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12176 }
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj = NULL;
12185 wxImage *arg1 = (wxImage *) 0 ;
12186 byte *arg2 = (byte *) 0 ;
12187 byte *arg3 = (byte *) 0 ;
12188 byte *arg4 = (byte *) 0 ;
12189 byte arg5 = (byte) 0 ;
12190 byte arg6 = (byte) 0 ;
12191 byte arg7 = (byte) 0 ;
12192 bool result;
12193 byte temp2 ;
12194 int res2 = 0 ;
12195 byte temp3 ;
12196 int res3 = 0 ;
12197 byte temp4 ;
12198 int res4 = 0 ;
12199 PyObject * obj0 = 0 ;
12200 PyObject * obj1 = 0 ;
12201 PyObject * obj2 = 0 ;
12202 PyObject * obj3 = 0 ;
12203 char *kwnames[] = {
12204 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12205 };
12206
12207 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12208 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12209 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12212 if (SWIG_arg_fail(1)) SWIG_fail;
12213 if (obj1) {
12214 {
12215 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12216 if (SWIG_arg_fail(5)) SWIG_fail;
12217 }
12218 }
12219 if (obj2) {
12220 {
12221 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12222 if (SWIG_arg_fail(6)) SWIG_fail;
12223 }
12224 }
12225 if (obj3) {
12226 {
12227 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12228 if (SWIG_arg_fail(7)) SWIG_fail;
12229 }
12230 }
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12234
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 {
12239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12240 }
12241 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12242 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12243 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12244 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12245 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12246 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12247 return resultobj;
12248 fail:
12249 return NULL;
12250 }
12251
12252
12253 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12254 PyObject *resultobj = NULL;
12255 wxImage *arg1 = (wxImage *) 0 ;
12256 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12257 bool result;
12258 PyObject * obj0 = 0 ;
12259 PyObject * obj1 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self",(char *) "threshold", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 if (obj1) {
12268 {
12269 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12270 if (SWIG_arg_fail(2)) SWIG_fail;
12271 }
12272 }
12273 {
12274 PyThreadState* __tstate = wxPyBeginAllowThreads();
12275 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12276
12277 wxPyEndAllowThreads(__tstate);
12278 if (PyErr_Occurred()) SWIG_fail;
12279 }
12280 {
12281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12282 }
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = NULL;
12291 wxImage *arg1 = (wxImage *) 0 ;
12292 byte arg2 ;
12293 byte arg3 ;
12294 byte arg4 ;
12295 bool result;
12296 PyObject * obj0 = 0 ;
12297 PyObject * obj1 = 0 ;
12298 PyObject * obj2 = 0 ;
12299 PyObject * obj3 = 0 ;
12300 char *kwnames[] = {
12301 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12302 };
12303
12304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12306 if (SWIG_arg_fail(1)) SWIG_fail;
12307 {
12308 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12309 if (SWIG_arg_fail(2)) SWIG_fail;
12310 }
12311 {
12312 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12313 if (SWIG_arg_fail(3)) SWIG_fail;
12314 }
12315 {
12316 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12317 if (SWIG_arg_fail(4)) SWIG_fail;
12318 }
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12322
12323 wxPyEndAllowThreads(__tstate);
12324 if (PyErr_Occurred()) SWIG_fail;
12325 }
12326 {
12327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12328 }
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12336 PyObject *resultobj = NULL;
12337 wxImage *arg1 = (wxImage *) 0 ;
12338 wxImage *arg2 = 0 ;
12339 byte arg3 ;
12340 byte arg4 ;
12341 byte arg5 ;
12342 bool result;
12343 PyObject * obj0 = 0 ;
12344 PyObject * obj1 = 0 ;
12345 PyObject * obj2 = 0 ;
12346 PyObject * obj3 = 0 ;
12347 PyObject * obj4 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12357 if (SWIG_arg_fail(2)) SWIG_fail;
12358 if (arg2 == NULL) {
12359 SWIG_null_ref("wxImage");
12360 }
12361 if (SWIG_arg_fail(2)) SWIG_fail;
12362 }
12363 {
12364 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12365 if (SWIG_arg_fail(3)) SWIG_fail;
12366 }
12367 {
12368 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12369 if (SWIG_arg_fail(4)) SWIG_fail;
12370 }
12371 {
12372 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12373 if (SWIG_arg_fail(5)) SWIG_fail;
12374 }
12375 {
12376 PyThreadState* __tstate = wxPyBeginAllowThreads();
12377 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12378
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 {
12383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12384 }
12385 return resultobj;
12386 fail:
12387 return NULL;
12388 }
12389
12390
12391 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12392 PyObject *resultobj = NULL;
12393 wxString *arg1 = 0 ;
12394 bool result;
12395 bool temp1 = false ;
12396 PyObject * obj0 = 0 ;
12397 char *kwnames[] = {
12398 (char *) "filename", NULL
12399 };
12400
12401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12402 {
12403 arg1 = wxString_in_helper(obj0);
12404 if (arg1 == NULL) SWIG_fail;
12405 temp1 = true;
12406 }
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12410
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 {
12415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12416 }
12417 {
12418 if (temp1)
12419 delete arg1;
12420 }
12421 return resultobj;
12422 fail:
12423 {
12424 if (temp1)
12425 delete arg1;
12426 }
12427 return NULL;
12428 }
12429
12430
12431 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12432 PyObject *resultobj = NULL;
12433 wxString *arg1 = 0 ;
12434 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12435 int result;
12436 bool temp1 = false ;
12437 PyObject * obj0 = 0 ;
12438 PyObject * obj1 = 0 ;
12439 char *kwnames[] = {
12440 (char *) "filename",(char *) "type", NULL
12441 };
12442
12443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12444 {
12445 arg1 = wxString_in_helper(obj0);
12446 if (arg1 == NULL) SWIG_fail;
12447 temp1 = true;
12448 }
12449 if (obj1) {
12450 {
12451 arg2 = static_cast<long >(SWIG_As_long(obj1));
12452 if (SWIG_arg_fail(2)) SWIG_fail;
12453 }
12454 }
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12458
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 {
12463 resultobj = SWIG_From_int(static_cast<int >(result));
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_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj = NULL;
12481 wxImage *arg1 = (wxImage *) 0 ;
12482 wxString *arg2 = 0 ;
12483 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12484 int arg4 = (int) -1 ;
12485 bool result;
12486 bool temp2 = false ;
12487 PyObject * obj0 = 0 ;
12488 PyObject * obj1 = 0 ;
12489 PyObject * obj2 = 0 ;
12490 PyObject * obj3 = 0 ;
12491 char *kwnames[] = {
12492 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12493 };
12494
12495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12497 if (SWIG_arg_fail(1)) SWIG_fail;
12498 {
12499 arg2 = wxString_in_helper(obj1);
12500 if (arg2 == NULL) SWIG_fail;
12501 temp2 = true;
12502 }
12503 if (obj2) {
12504 {
12505 arg3 = static_cast<long >(SWIG_As_long(obj2));
12506 if (SWIG_arg_fail(3)) SWIG_fail;
12507 }
12508 }
12509 if (obj3) {
12510 {
12511 arg4 = static_cast<int >(SWIG_As_int(obj3));
12512 if (SWIG_arg_fail(4)) SWIG_fail;
12513 }
12514 }
12515 {
12516 PyThreadState* __tstate = wxPyBeginAllowThreads();
12517 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12518
12519 wxPyEndAllowThreads(__tstate);
12520 if (PyErr_Occurred()) SWIG_fail;
12521 }
12522 {
12523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12524 }
12525 {
12526 if (temp2)
12527 delete arg2;
12528 }
12529 return resultobj;
12530 fail:
12531 {
12532 if (temp2)
12533 delete arg2;
12534 }
12535 return NULL;
12536 }
12537
12538
12539 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12540 PyObject *resultobj = NULL;
12541 wxImage *arg1 = (wxImage *) 0 ;
12542 wxString *arg2 = 0 ;
12543 wxString *arg3 = 0 ;
12544 int arg4 = (int) -1 ;
12545 bool result;
12546 bool temp2 = false ;
12547 bool temp3 = false ;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 PyObject * obj2 = 0 ;
12551 PyObject * obj3 = 0 ;
12552 char *kwnames[] = {
12553 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12554 };
12555
12556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12558 if (SWIG_arg_fail(1)) SWIG_fail;
12559 {
12560 arg2 = wxString_in_helper(obj1);
12561 if (arg2 == NULL) SWIG_fail;
12562 temp2 = true;
12563 }
12564 {
12565 arg3 = wxString_in_helper(obj2);
12566 if (arg3 == NULL) SWIG_fail;
12567 temp3 = true;
12568 }
12569 if (obj3) {
12570 {
12571 arg4 = static_cast<int >(SWIG_As_int(obj3));
12572 if (SWIG_arg_fail(4)) SWIG_fail;
12573 }
12574 }
12575 {
12576 PyThreadState* __tstate = wxPyBeginAllowThreads();
12577 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12578
12579 wxPyEndAllowThreads(__tstate);
12580 if (PyErr_Occurred()) SWIG_fail;
12581 }
12582 {
12583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12584 }
12585 {
12586 if (temp2)
12587 delete arg2;
12588 }
12589 {
12590 if (temp3)
12591 delete arg3;
12592 }
12593 return resultobj;
12594 fail:
12595 {
12596 if (temp2)
12597 delete arg2;
12598 }
12599 {
12600 if (temp3)
12601 delete arg3;
12602 }
12603 return NULL;
12604 }
12605
12606
12607 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12608 PyObject *resultobj = NULL;
12609 wxImage *arg1 = (wxImage *) 0 ;
12610 wxString *arg2 = 0 ;
12611 int arg3 ;
12612 bool result;
12613 bool temp2 = false ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 PyObject * obj2 = 0 ;
12617 char *kwnames[] = {
12618 (char *) "self",(char *) "name",(char *) "type", NULL
12619 };
12620
12621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12623 if (SWIG_arg_fail(1)) SWIG_fail;
12624 {
12625 arg2 = wxString_in_helper(obj1);
12626 if (arg2 == NULL) SWIG_fail;
12627 temp2 = true;
12628 }
12629 {
12630 arg3 = static_cast<int >(SWIG_As_int(obj2));
12631 if (SWIG_arg_fail(3)) SWIG_fail;
12632 }
12633 {
12634 PyThreadState* __tstate = wxPyBeginAllowThreads();
12635 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12636
12637 wxPyEndAllowThreads(__tstate);
12638 if (PyErr_Occurred()) SWIG_fail;
12639 }
12640 {
12641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12642 }
12643 {
12644 if (temp2)
12645 delete arg2;
12646 }
12647 return resultobj;
12648 fail:
12649 {
12650 if (temp2)
12651 delete arg2;
12652 }
12653 return NULL;
12654 }
12655
12656
12657 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj = NULL;
12659 wxImage *arg1 = (wxImage *) 0 ;
12660 wxString *arg2 = 0 ;
12661 wxString *arg3 = 0 ;
12662 bool result;
12663 bool temp2 = false ;
12664 bool temp3 = false ;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 PyObject * obj2 = 0 ;
12668 char *kwnames[] = {
12669 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12670 };
12671
12672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12674 if (SWIG_arg_fail(1)) SWIG_fail;
12675 {
12676 arg2 = wxString_in_helper(obj1);
12677 if (arg2 == NULL) SWIG_fail;
12678 temp2 = true;
12679 }
12680 {
12681 arg3 = wxString_in_helper(obj2);
12682 if (arg3 == NULL) SWIG_fail;
12683 temp3 = true;
12684 }
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12688
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 {
12693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12694 }
12695 {
12696 if (temp2)
12697 delete arg2;
12698 }
12699 {
12700 if (temp3)
12701 delete arg3;
12702 }
12703 return resultobj;
12704 fail:
12705 {
12706 if (temp2)
12707 delete arg2;
12708 }
12709 {
12710 if (temp3)
12711 delete arg3;
12712 }
12713 return NULL;
12714 }
12715
12716
12717 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12718 PyObject *resultobj = NULL;
12719 wxInputStream *arg1 = 0 ;
12720 bool result;
12721 wxPyInputStream *temp1 ;
12722 bool created1 ;
12723 PyObject * obj0 = 0 ;
12724 char *kwnames[] = {
12725 (char *) "stream", NULL
12726 };
12727
12728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12729 {
12730 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12731 arg1 = temp1->m_wxis;
12732 created1 = false;
12733 } else {
12734 PyErr_Clear(); // clear the failure of the wxPyConvert above
12735 arg1 = wxPyCBInputStream_create(obj0, false);
12736 if (arg1 == NULL) {
12737 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12738 SWIG_fail;
12739 }
12740 created1 = true;
12741 }
12742 }
12743 {
12744 PyThreadState* __tstate = wxPyBeginAllowThreads();
12745 result = (bool)wxImage::CanRead(*arg1);
12746
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 {
12751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12752 }
12753 {
12754 if (created1) delete arg1;
12755 }
12756 return resultobj;
12757 fail:
12758 {
12759 if (created1) delete arg1;
12760 }
12761 return NULL;
12762 }
12763
12764
12765 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj = NULL;
12767 wxImage *arg1 = (wxImage *) 0 ;
12768 wxInputStream *arg2 = 0 ;
12769 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12770 int arg4 = (int) -1 ;
12771 bool result;
12772 wxPyInputStream *temp2 ;
12773 bool created2 ;
12774 PyObject * obj0 = 0 ;
12775 PyObject * obj1 = 0 ;
12776 PyObject * obj2 = 0 ;
12777 PyObject * obj3 = 0 ;
12778 char *kwnames[] = {
12779 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12780 };
12781
12782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12784 if (SWIG_arg_fail(1)) SWIG_fail;
12785 {
12786 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12787 arg2 = temp2->m_wxis;
12788 created2 = false;
12789 } else {
12790 PyErr_Clear(); // clear the failure of the wxPyConvert above
12791 arg2 = wxPyCBInputStream_create(obj1, false);
12792 if (arg2 == NULL) {
12793 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12794 SWIG_fail;
12795 }
12796 created2 = true;
12797 }
12798 }
12799 if (obj2) {
12800 {
12801 arg3 = static_cast<long >(SWIG_As_long(obj2));
12802 if (SWIG_arg_fail(3)) SWIG_fail;
12803 }
12804 }
12805 if (obj3) {
12806 {
12807 arg4 = static_cast<int >(SWIG_As_int(obj3));
12808 if (SWIG_arg_fail(4)) SWIG_fail;
12809 }
12810 }
12811 {
12812 PyThreadState* __tstate = wxPyBeginAllowThreads();
12813 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12814
12815 wxPyEndAllowThreads(__tstate);
12816 if (PyErr_Occurred()) SWIG_fail;
12817 }
12818 {
12819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12820 }
12821 {
12822 if (created2) delete arg2;
12823 }
12824 return resultobj;
12825 fail:
12826 {
12827 if (created2) delete arg2;
12828 }
12829 return NULL;
12830 }
12831
12832
12833 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12834 PyObject *resultobj = NULL;
12835 wxImage *arg1 = (wxImage *) 0 ;
12836 wxInputStream *arg2 = 0 ;
12837 wxString *arg3 = 0 ;
12838 int arg4 = (int) -1 ;
12839 bool result;
12840 wxPyInputStream *temp2 ;
12841 bool created2 ;
12842 bool temp3 = false ;
12843 PyObject * obj0 = 0 ;
12844 PyObject * obj1 = 0 ;
12845 PyObject * obj2 = 0 ;
12846 PyObject * obj3 = 0 ;
12847 char *kwnames[] = {
12848 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12849 };
12850
12851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12853 if (SWIG_arg_fail(1)) SWIG_fail;
12854 {
12855 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12856 arg2 = temp2->m_wxis;
12857 created2 = false;
12858 } else {
12859 PyErr_Clear(); // clear the failure of the wxPyConvert above
12860 arg2 = wxPyCBInputStream_create(obj1, false);
12861 if (arg2 == NULL) {
12862 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12863 SWIG_fail;
12864 }
12865 created2 = true;
12866 }
12867 }
12868 {
12869 arg3 = wxString_in_helper(obj2);
12870 if (arg3 == NULL) SWIG_fail;
12871 temp3 = true;
12872 }
12873 if (obj3) {
12874 {
12875 arg4 = static_cast<int >(SWIG_As_int(obj3));
12876 if (SWIG_arg_fail(4)) SWIG_fail;
12877 }
12878 }
12879 {
12880 PyThreadState* __tstate = wxPyBeginAllowThreads();
12881 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12882
12883 wxPyEndAllowThreads(__tstate);
12884 if (PyErr_Occurred()) SWIG_fail;
12885 }
12886 {
12887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12888 }
12889 {
12890 if (created2) delete arg2;
12891 }
12892 {
12893 if (temp3)
12894 delete arg3;
12895 }
12896 return resultobj;
12897 fail:
12898 {
12899 if (created2) delete arg2;
12900 }
12901 {
12902 if (temp3)
12903 delete arg3;
12904 }
12905 return NULL;
12906 }
12907
12908
12909 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12910 PyObject *resultobj = NULL;
12911 wxImage *arg1 = (wxImage *) 0 ;
12912 bool result;
12913 PyObject * obj0 = 0 ;
12914 char *kwnames[] = {
12915 (char *) "self", NULL
12916 };
12917
12918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12920 if (SWIG_arg_fail(1)) SWIG_fail;
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 result = (bool)(arg1)->Ok();
12924
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 {
12929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12930 }
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12938 PyObject *resultobj = NULL;
12939 wxImage *arg1 = (wxImage *) 0 ;
12940 int result;
12941 PyObject * obj0 = 0 ;
12942 char *kwnames[] = {
12943 (char *) "self", NULL
12944 };
12945
12946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12948 if (SWIG_arg_fail(1)) SWIG_fail;
12949 {
12950 PyThreadState* __tstate = wxPyBeginAllowThreads();
12951 result = (int)(arg1)->GetWidth();
12952
12953 wxPyEndAllowThreads(__tstate);
12954 if (PyErr_Occurred()) SWIG_fail;
12955 }
12956 {
12957 resultobj = SWIG_From_int(static_cast<int >(result));
12958 }
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj = NULL;
12967 wxImage *arg1 = (wxImage *) 0 ;
12968 int result;
12969 PyObject * obj0 = 0 ;
12970 char *kwnames[] = {
12971 (char *) "self", NULL
12972 };
12973
12974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12976 if (SWIG_arg_fail(1)) SWIG_fail;
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (int)(arg1)->GetHeight();
12980
12981 wxPyEndAllowThreads(__tstate);
12982 if (PyErr_Occurred()) SWIG_fail;
12983 }
12984 {
12985 resultobj = SWIG_From_int(static_cast<int >(result));
12986 }
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12994 PyObject *resultobj = NULL;
12995 wxImage *arg1 = (wxImage *) 0 ;
12996 wxSize result;
12997 PyObject * obj0 = 0 ;
12998 char *kwnames[] = {
12999 (char *) "self", NULL
13000 };
13001
13002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
13003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13004 if (SWIG_arg_fail(1)) SWIG_fail;
13005 {
13006 PyThreadState* __tstate = wxPyBeginAllowThreads();
13007 result = wxImage_GetSize(arg1);
13008
13009 wxPyEndAllowThreads(__tstate);
13010 if (PyErr_Occurred()) SWIG_fail;
13011 }
13012 {
13013 wxSize * resultptr;
13014 resultptr = new wxSize(static_cast<wxSize & >(result));
13015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13016 }
13017 return resultobj;
13018 fail:
13019 return NULL;
13020 }
13021
13022
13023 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13024 PyObject *resultobj = NULL;
13025 wxImage *arg1 = (wxImage *) 0 ;
13026 wxRect *arg2 = 0 ;
13027 SwigValueWrapper<wxImage > result;
13028 wxRect temp2 ;
13029 PyObject * obj0 = 0 ;
13030 PyObject * obj1 = 0 ;
13031 char *kwnames[] = {
13032 (char *) "self",(char *) "rect", NULL
13033 };
13034
13035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13037 if (SWIG_arg_fail(1)) SWIG_fail;
13038 {
13039 arg2 = &temp2;
13040 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13041 }
13042 {
13043 PyThreadState* __tstate = wxPyBeginAllowThreads();
13044 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13045
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 {
13050 wxImage * resultptr;
13051 resultptr = new wxImage(static_cast<wxImage & >(result));
13052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13053 }
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13061 PyObject *resultobj = NULL;
13062 wxImage *arg1 = (wxImage *) 0 ;
13063 wxSize *arg2 = 0 ;
13064 wxPoint *arg3 = 0 ;
13065 int arg4 = (int) -1 ;
13066 int arg5 = (int) -1 ;
13067 int arg6 = (int) -1 ;
13068 SwigValueWrapper<wxImage > result;
13069 wxSize temp2 ;
13070 wxPoint temp3 ;
13071 PyObject * obj0 = 0 ;
13072 PyObject * obj1 = 0 ;
13073 PyObject * obj2 = 0 ;
13074 PyObject * obj3 = 0 ;
13075 PyObject * obj4 = 0 ;
13076 PyObject * obj5 = 0 ;
13077 char *kwnames[] = {
13078 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13079 };
13080
13081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13083 if (SWIG_arg_fail(1)) SWIG_fail;
13084 {
13085 arg2 = &temp2;
13086 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13087 }
13088 {
13089 arg3 = &temp3;
13090 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13091 }
13092 if (obj3) {
13093 {
13094 arg4 = static_cast<int >(SWIG_As_int(obj3));
13095 if (SWIG_arg_fail(4)) SWIG_fail;
13096 }
13097 }
13098 if (obj4) {
13099 {
13100 arg5 = static_cast<int >(SWIG_As_int(obj4));
13101 if (SWIG_arg_fail(5)) SWIG_fail;
13102 }
13103 }
13104 if (obj5) {
13105 {
13106 arg6 = static_cast<int >(SWIG_As_int(obj5));
13107 if (SWIG_arg_fail(6)) SWIG_fail;
13108 }
13109 }
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13113
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 {
13118 wxImage * resultptr;
13119 resultptr = new wxImage(static_cast<wxImage & >(result));
13120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13121 }
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = NULL;
13130 wxImage *arg1 = (wxImage *) 0 ;
13131 SwigValueWrapper<wxImage > result;
13132 PyObject * obj0 = 0 ;
13133 char *kwnames[] = {
13134 (char *) "self", NULL
13135 };
13136
13137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13139 if (SWIG_arg_fail(1)) SWIG_fail;
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 result = (arg1)->Copy();
13143
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 {
13148 wxImage * resultptr;
13149 resultptr = new wxImage(static_cast<wxImage & >(result));
13150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13151 }
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj = NULL;
13160 wxImage *arg1 = (wxImage *) 0 ;
13161 wxImage *arg2 = 0 ;
13162 int arg3 ;
13163 int arg4 ;
13164 PyObject * obj0 = 0 ;
13165 PyObject * obj1 = 0 ;
13166 PyObject * obj2 = 0 ;
13167 PyObject * obj3 = 0 ;
13168 char *kwnames[] = {
13169 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13170 };
13171
13172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13174 if (SWIG_arg_fail(1)) SWIG_fail;
13175 {
13176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13177 if (SWIG_arg_fail(2)) SWIG_fail;
13178 if (arg2 == NULL) {
13179 SWIG_null_ref("wxImage");
13180 }
13181 if (SWIG_arg_fail(2)) SWIG_fail;
13182 }
13183 {
13184 arg3 = static_cast<int >(SWIG_As_int(obj2));
13185 if (SWIG_arg_fail(3)) SWIG_fail;
13186 }
13187 {
13188 arg4 = static_cast<int >(SWIG_As_int(obj3));
13189 if (SWIG_arg_fail(4)) SWIG_fail;
13190 }
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13194
13195 wxPyEndAllowThreads(__tstate);
13196 if (PyErr_Occurred()) SWIG_fail;
13197 }
13198 Py_INCREF(Py_None); resultobj = Py_None;
13199 return resultobj;
13200 fail:
13201 return NULL;
13202 }
13203
13204
13205 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj = NULL;
13207 wxImage *arg1 = (wxImage *) 0 ;
13208 PyObject *result;
13209 PyObject * obj0 = 0 ;
13210 char *kwnames[] = {
13211 (char *) "self", NULL
13212 };
13213
13214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13216 if (SWIG_arg_fail(1)) SWIG_fail;
13217 {
13218 PyThreadState* __tstate = wxPyBeginAllowThreads();
13219 result = (PyObject *)wxImage_GetData(arg1);
13220
13221 wxPyEndAllowThreads(__tstate);
13222 if (PyErr_Occurred()) SWIG_fail;
13223 }
13224 resultobj = result;
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13232 PyObject *resultobj = NULL;
13233 wxImage *arg1 = (wxImage *) 0 ;
13234 buffer arg2 ;
13235 int arg3 ;
13236 PyObject * obj0 = 0 ;
13237 PyObject * obj1 = 0 ;
13238 char *kwnames[] = {
13239 (char *) "self",(char *) "data", NULL
13240 };
13241
13242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13244 if (SWIG_arg_fail(1)) SWIG_fail;
13245 {
13246 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13247 }
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 wxImage_SetData(arg1,arg2,arg3);
13251
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 Py_INCREF(Py_None); resultobj = Py_None;
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj = NULL;
13264 wxImage *arg1 = (wxImage *) 0 ;
13265 PyObject *result;
13266 PyObject * obj0 = 0 ;
13267 char *kwnames[] = {
13268 (char *) "self", NULL
13269 };
13270
13271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13273 if (SWIG_arg_fail(1)) SWIG_fail;
13274 {
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13277
13278 wxPyEndAllowThreads(__tstate);
13279 if (PyErr_Occurred()) SWIG_fail;
13280 }
13281 resultobj = result;
13282 return resultobj;
13283 fail:
13284 return NULL;
13285 }
13286
13287
13288 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13289 PyObject *resultobj = NULL;
13290 wxImage *arg1 = (wxImage *) 0 ;
13291 buffer arg2 ;
13292 int arg3 ;
13293 PyObject * obj0 = 0 ;
13294 PyObject * obj1 = 0 ;
13295 char *kwnames[] = {
13296 (char *) "self",(char *) "data", NULL
13297 };
13298
13299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13301 if (SWIG_arg_fail(1)) SWIG_fail;
13302 {
13303 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13304 }
13305 {
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 wxImage_SetDataBuffer(arg1,arg2,arg3);
13308
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 Py_INCREF(Py_None); resultobj = Py_None;
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj = NULL;
13321 wxImage *arg1 = (wxImage *) 0 ;
13322 PyObject *result;
13323 PyObject * obj0 = 0 ;
13324 char *kwnames[] = {
13325 (char *) "self", NULL
13326 };
13327
13328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13330 if (SWIG_arg_fail(1)) SWIG_fail;
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 result = (PyObject *)wxImage_GetAlphaData(arg1);
13334
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 resultobj = result;
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13346 PyObject *resultobj = NULL;
13347 wxImage *arg1 = (wxImage *) 0 ;
13348 buffer arg2 ;
13349 int arg3 ;
13350 PyObject * obj0 = 0 ;
13351 PyObject * obj1 = 0 ;
13352 char *kwnames[] = {
13353 (char *) "self",(char *) "alpha", NULL
13354 };
13355
13356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13358 if (SWIG_arg_fail(1)) SWIG_fail;
13359 {
13360 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13361 }
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 wxImage_SetAlphaData(arg1,arg2,arg3);
13365
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 Py_INCREF(Py_None); resultobj = Py_None;
13370 return resultobj;
13371 fail:
13372 return NULL;
13373 }
13374
13375
13376 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13377 PyObject *resultobj = NULL;
13378 wxImage *arg1 = (wxImage *) 0 ;
13379 PyObject *result;
13380 PyObject * obj0 = 0 ;
13381 char *kwnames[] = {
13382 (char *) "self", NULL
13383 };
13384
13385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13387 if (SWIG_arg_fail(1)) SWIG_fail;
13388 {
13389 PyThreadState* __tstate = wxPyBeginAllowThreads();
13390 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13391
13392 wxPyEndAllowThreads(__tstate);
13393 if (PyErr_Occurred()) SWIG_fail;
13394 }
13395 resultobj = result;
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13403 PyObject *resultobj = NULL;
13404 wxImage *arg1 = (wxImage *) 0 ;
13405 buffer arg2 ;
13406 int arg3 ;
13407 PyObject * obj0 = 0 ;
13408 PyObject * obj1 = 0 ;
13409 char *kwnames[] = {
13410 (char *) "self",(char *) "alpha", NULL
13411 };
13412
13413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13415 if (SWIG_arg_fail(1)) SWIG_fail;
13416 {
13417 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13418 }
13419 {
13420 PyThreadState* __tstate = wxPyBeginAllowThreads();
13421 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13422
13423 wxPyEndAllowThreads(__tstate);
13424 if (PyErr_Occurred()) SWIG_fail;
13425 }
13426 Py_INCREF(Py_None); resultobj = Py_None;
13427 return resultobj;
13428 fail:
13429 return NULL;
13430 }
13431
13432
13433 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13434 PyObject *resultobj = NULL;
13435 wxImage *arg1 = (wxImage *) 0 ;
13436 byte arg2 ;
13437 byte arg3 ;
13438 byte arg4 ;
13439 PyObject * obj0 = 0 ;
13440 PyObject * obj1 = 0 ;
13441 PyObject * obj2 = 0 ;
13442 PyObject * obj3 = 0 ;
13443 char *kwnames[] = {
13444 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13445 };
13446
13447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13449 if (SWIG_arg_fail(1)) SWIG_fail;
13450 {
13451 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13452 if (SWIG_arg_fail(2)) SWIG_fail;
13453 }
13454 {
13455 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13456 if (SWIG_arg_fail(3)) SWIG_fail;
13457 }
13458 {
13459 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13460 if (SWIG_arg_fail(4)) SWIG_fail;
13461 }
13462 {
13463 PyThreadState* __tstate = wxPyBeginAllowThreads();
13464 (arg1)->SetMaskColour(arg2,arg3,arg4);
13465
13466 wxPyEndAllowThreads(__tstate);
13467 if (PyErr_Occurred()) SWIG_fail;
13468 }
13469 Py_INCREF(Py_None); resultobj = Py_None;
13470 return resultobj;
13471 fail:
13472 return NULL;
13473 }
13474
13475
13476 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13477 PyObject *resultobj = NULL;
13478 wxImage *arg1 = (wxImage *) 0 ;
13479 byte *arg2 = (byte *) 0 ;
13480 byte *arg3 = (byte *) 0 ;
13481 byte *arg4 = (byte *) 0 ;
13482 byte temp2 ;
13483 int res2 = 0 ;
13484 byte temp3 ;
13485 int res3 = 0 ;
13486 byte temp4 ;
13487 int res4 = 0 ;
13488 PyObject * obj0 = 0 ;
13489 char *kwnames[] = {
13490 (char *) "self", NULL
13491 };
13492
13493 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13494 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13495 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13498 if (SWIG_arg_fail(1)) SWIG_fail;
13499 {
13500 PyThreadState* __tstate = wxPyBeginAllowThreads();
13501 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13502
13503 wxPyEndAllowThreads(__tstate);
13504 if (PyErr_Occurred()) SWIG_fail;
13505 }
13506 Py_INCREF(Py_None); resultobj = Py_None;
13507 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13508 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13509 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13510 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13511 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13512 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13513 return resultobj;
13514 fail:
13515 return NULL;
13516 }
13517
13518
13519 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13520 PyObject *resultobj = NULL;
13521 wxImage *arg1 = (wxImage *) 0 ;
13522 byte result;
13523 PyObject * obj0 = 0 ;
13524 char *kwnames[] = {
13525 (char *) "self", NULL
13526 };
13527
13528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13530 if (SWIG_arg_fail(1)) SWIG_fail;
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 result = (byte)(arg1)->GetMaskRed();
13534
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 {
13539 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13540 }
13541 return resultobj;
13542 fail:
13543 return NULL;
13544 }
13545
13546
13547 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13548 PyObject *resultobj = NULL;
13549 wxImage *arg1 = (wxImage *) 0 ;
13550 byte result;
13551 PyObject * obj0 = 0 ;
13552 char *kwnames[] = {
13553 (char *) "self", NULL
13554 };
13555
13556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13558 if (SWIG_arg_fail(1)) SWIG_fail;
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 result = (byte)(arg1)->GetMaskGreen();
13562
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 {
13567 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13568 }
13569 return resultobj;
13570 fail:
13571 return NULL;
13572 }
13573
13574
13575 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13576 PyObject *resultobj = NULL;
13577 wxImage *arg1 = (wxImage *) 0 ;
13578 byte result;
13579 PyObject * obj0 = 0 ;
13580 char *kwnames[] = {
13581 (char *) "self", NULL
13582 };
13583
13584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13586 if (SWIG_arg_fail(1)) SWIG_fail;
13587 {
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 result = (byte)(arg1)->GetMaskBlue();
13590
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 {
13595 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13596 }
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13604 PyObject *resultobj = NULL;
13605 wxImage *arg1 = (wxImage *) 0 ;
13606 bool arg2 = (bool) true ;
13607 PyObject * obj0 = 0 ;
13608 PyObject * obj1 = 0 ;
13609 char *kwnames[] = {
13610 (char *) "self",(char *) "mask", NULL
13611 };
13612
13613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13615 if (SWIG_arg_fail(1)) SWIG_fail;
13616 if (obj1) {
13617 {
13618 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13619 if (SWIG_arg_fail(2)) SWIG_fail;
13620 }
13621 }
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 (arg1)->SetMask(arg2);
13625
13626 wxPyEndAllowThreads(__tstate);
13627 if (PyErr_Occurred()) SWIG_fail;
13628 }
13629 Py_INCREF(Py_None); resultobj = Py_None;
13630 return resultobj;
13631 fail:
13632 return NULL;
13633 }
13634
13635
13636 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13637 PyObject *resultobj = NULL;
13638 wxImage *arg1 = (wxImage *) 0 ;
13639 bool result;
13640 PyObject * obj0 = 0 ;
13641 char *kwnames[] = {
13642 (char *) "self", NULL
13643 };
13644
13645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13647 if (SWIG_arg_fail(1)) SWIG_fail;
13648 {
13649 PyThreadState* __tstate = wxPyBeginAllowThreads();
13650 result = (bool)(arg1)->HasMask();
13651
13652 wxPyEndAllowThreads(__tstate);
13653 if (PyErr_Occurred()) SWIG_fail;
13654 }
13655 {
13656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13657 }
13658 return resultobj;
13659 fail:
13660 return NULL;
13661 }
13662
13663
13664 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13665 PyObject *resultobj = NULL;
13666 wxImage *arg1 = (wxImage *) 0 ;
13667 double arg2 ;
13668 wxPoint *arg3 = 0 ;
13669 bool arg4 = (bool) true ;
13670 wxPoint *arg5 = (wxPoint *) NULL ;
13671 SwigValueWrapper<wxImage > result;
13672 wxPoint temp3 ;
13673 PyObject * obj0 = 0 ;
13674 PyObject * obj1 = 0 ;
13675 PyObject * obj2 = 0 ;
13676 PyObject * obj3 = 0 ;
13677 PyObject * obj4 = 0 ;
13678 char *kwnames[] = {
13679 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13680 };
13681
13682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13684 if (SWIG_arg_fail(1)) SWIG_fail;
13685 {
13686 arg2 = static_cast<double >(SWIG_As_double(obj1));
13687 if (SWIG_arg_fail(2)) SWIG_fail;
13688 }
13689 {
13690 arg3 = &temp3;
13691 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13692 }
13693 if (obj3) {
13694 {
13695 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13696 if (SWIG_arg_fail(4)) SWIG_fail;
13697 }
13698 }
13699 if (obj4) {
13700 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13701 if (SWIG_arg_fail(5)) SWIG_fail;
13702 }
13703 {
13704 PyThreadState* __tstate = wxPyBeginAllowThreads();
13705 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13706
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 {
13711 wxImage * resultptr;
13712 resultptr = new wxImage(static_cast<wxImage & >(result));
13713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13714 }
13715 return resultobj;
13716 fail:
13717 return NULL;
13718 }
13719
13720
13721 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj = NULL;
13723 wxImage *arg1 = (wxImage *) 0 ;
13724 bool arg2 = (bool) true ;
13725 SwigValueWrapper<wxImage > result;
13726 PyObject * obj0 = 0 ;
13727 PyObject * obj1 = 0 ;
13728 char *kwnames[] = {
13729 (char *) "self",(char *) "clockwise", NULL
13730 };
13731
13732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13734 if (SWIG_arg_fail(1)) SWIG_fail;
13735 if (obj1) {
13736 {
13737 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13738 if (SWIG_arg_fail(2)) SWIG_fail;
13739 }
13740 }
13741 {
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 result = (arg1)->Rotate90(arg2);
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 {
13749 wxImage * resultptr;
13750 resultptr = new wxImage(static_cast<wxImage & >(result));
13751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13752 }
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = NULL;
13761 wxImage *arg1 = (wxImage *) 0 ;
13762 bool arg2 = (bool) true ;
13763 SwigValueWrapper<wxImage > result;
13764 PyObject * obj0 = 0 ;
13765 PyObject * obj1 = 0 ;
13766 char *kwnames[] = {
13767 (char *) "self",(char *) "horizontally", NULL
13768 };
13769
13770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13772 if (SWIG_arg_fail(1)) SWIG_fail;
13773 if (obj1) {
13774 {
13775 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13776 if (SWIG_arg_fail(2)) SWIG_fail;
13777 }
13778 }
13779 {
13780 PyThreadState* __tstate = wxPyBeginAllowThreads();
13781 result = (arg1)->Mirror(arg2);
13782
13783 wxPyEndAllowThreads(__tstate);
13784 if (PyErr_Occurred()) SWIG_fail;
13785 }
13786 {
13787 wxImage * resultptr;
13788 resultptr = new wxImage(static_cast<wxImage & >(result));
13789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13790 }
13791 return resultobj;
13792 fail:
13793 return NULL;
13794 }
13795
13796
13797 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj = NULL;
13799 wxImage *arg1 = (wxImage *) 0 ;
13800 byte arg2 ;
13801 byte arg3 ;
13802 byte arg4 ;
13803 byte arg5 ;
13804 byte arg6 ;
13805 byte arg7 ;
13806 PyObject * obj0 = 0 ;
13807 PyObject * obj1 = 0 ;
13808 PyObject * obj2 = 0 ;
13809 PyObject * obj3 = 0 ;
13810 PyObject * obj4 = 0 ;
13811 PyObject * obj5 = 0 ;
13812 PyObject * obj6 = 0 ;
13813 char *kwnames[] = {
13814 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13815 };
13816
13817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13819 if (SWIG_arg_fail(1)) SWIG_fail;
13820 {
13821 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13822 if (SWIG_arg_fail(2)) SWIG_fail;
13823 }
13824 {
13825 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13826 if (SWIG_arg_fail(3)) SWIG_fail;
13827 }
13828 {
13829 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13830 if (SWIG_arg_fail(4)) SWIG_fail;
13831 }
13832 {
13833 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13834 if (SWIG_arg_fail(5)) SWIG_fail;
13835 }
13836 {
13837 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13838 if (SWIG_arg_fail(6)) SWIG_fail;
13839 }
13840 {
13841 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13842 if (SWIG_arg_fail(7)) SWIG_fail;
13843 }
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13847
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 Py_INCREF(Py_None); resultobj = Py_None;
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj = NULL;
13860 wxImage *arg1 = (wxImage *) 0 ;
13861 double arg2 = (double) 0.299 ;
13862 double arg3 = (double) 0.587 ;
13863 double arg4 = (double) 0.114 ;
13864 SwigValueWrapper<wxImage > result;
13865 PyObject * obj0 = 0 ;
13866 PyObject * obj1 = 0 ;
13867 PyObject * obj2 = 0 ;
13868 PyObject * obj3 = 0 ;
13869 char *kwnames[] = {
13870 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13871 };
13872
13873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13875 if (SWIG_arg_fail(1)) SWIG_fail;
13876 if (obj1) {
13877 {
13878 arg2 = static_cast<double >(SWIG_As_double(obj1));
13879 if (SWIG_arg_fail(2)) SWIG_fail;
13880 }
13881 }
13882 if (obj2) {
13883 {
13884 arg3 = static_cast<double >(SWIG_As_double(obj2));
13885 if (SWIG_arg_fail(3)) SWIG_fail;
13886 }
13887 }
13888 if (obj3) {
13889 {
13890 arg4 = static_cast<double >(SWIG_As_double(obj3));
13891 if (SWIG_arg_fail(4)) SWIG_fail;
13892 }
13893 }
13894 {
13895 PyThreadState* __tstate = wxPyBeginAllowThreads();
13896 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13897
13898 wxPyEndAllowThreads(__tstate);
13899 if (PyErr_Occurred()) SWIG_fail;
13900 }
13901 {
13902 wxImage * resultptr;
13903 resultptr = new wxImage(static_cast<wxImage & >(result));
13904 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13905 }
13906 return resultobj;
13907 fail:
13908 return NULL;
13909 }
13910
13911
13912 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj = NULL;
13914 wxImage *arg1 = (wxImage *) 0 ;
13915 byte arg2 ;
13916 byte arg3 ;
13917 byte arg4 ;
13918 SwigValueWrapper<wxImage > result;
13919 PyObject * obj0 = 0 ;
13920 PyObject * obj1 = 0 ;
13921 PyObject * obj2 = 0 ;
13922 PyObject * obj3 = 0 ;
13923 char *kwnames[] = {
13924 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13929 if (SWIG_arg_fail(1)) SWIG_fail;
13930 {
13931 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13932 if (SWIG_arg_fail(2)) SWIG_fail;
13933 }
13934 {
13935 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13936 if (SWIG_arg_fail(3)) SWIG_fail;
13937 }
13938 {
13939 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13940 if (SWIG_arg_fail(4)) SWIG_fail;
13941 }
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 result = ((wxImage const *)arg1)->ConvertToMono(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_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj = NULL;
13962 wxImage *arg1 = (wxImage *) 0 ;
13963 wxString *arg2 = 0 ;
13964 wxString *arg3 = 0 ;
13965 bool temp2 = false ;
13966 bool temp3 = false ;
13967 PyObject * obj0 = 0 ;
13968 PyObject * obj1 = 0 ;
13969 PyObject * obj2 = 0 ;
13970 char *kwnames[] = {
13971 (char *) "self",(char *) "name",(char *) "value", NULL
13972 };
13973
13974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13976 if (SWIG_arg_fail(1)) SWIG_fail;
13977 {
13978 arg2 = wxString_in_helper(obj1);
13979 if (arg2 == NULL) SWIG_fail;
13980 temp2 = true;
13981 }
13982 {
13983 arg3 = wxString_in_helper(obj2);
13984 if (arg3 == NULL) SWIG_fail;
13985 temp3 = true;
13986 }
13987 {
13988 PyThreadState* __tstate = wxPyBeginAllowThreads();
13989 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13990
13991 wxPyEndAllowThreads(__tstate);
13992 if (PyErr_Occurred()) SWIG_fail;
13993 }
13994 Py_INCREF(Py_None); resultobj = Py_None;
13995 {
13996 if (temp2)
13997 delete arg2;
13998 }
13999 {
14000 if (temp3)
14001 delete arg3;
14002 }
14003 return resultobj;
14004 fail:
14005 {
14006 if (temp2)
14007 delete arg2;
14008 }
14009 {
14010 if (temp3)
14011 delete arg3;
14012 }
14013 return NULL;
14014 }
14015
14016
14017 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14018 PyObject *resultobj = NULL;
14019 wxImage *arg1 = (wxImage *) 0 ;
14020 wxString *arg2 = 0 ;
14021 int arg3 ;
14022 bool temp2 = false ;
14023 PyObject * obj0 = 0 ;
14024 PyObject * obj1 = 0 ;
14025 PyObject * obj2 = 0 ;
14026 char *kwnames[] = {
14027 (char *) "self",(char *) "name",(char *) "value", NULL
14028 };
14029
14030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14032 if (SWIG_arg_fail(1)) SWIG_fail;
14033 {
14034 arg2 = wxString_in_helper(obj1);
14035 if (arg2 == NULL) SWIG_fail;
14036 temp2 = true;
14037 }
14038 {
14039 arg3 = static_cast<int >(SWIG_As_int(obj2));
14040 if (SWIG_arg_fail(3)) SWIG_fail;
14041 }
14042 {
14043 PyThreadState* __tstate = wxPyBeginAllowThreads();
14044 (arg1)->SetOption((wxString const &)*arg2,arg3);
14045
14046 wxPyEndAllowThreads(__tstate);
14047 if (PyErr_Occurred()) SWIG_fail;
14048 }
14049 Py_INCREF(Py_None); resultobj = Py_None;
14050 {
14051 if (temp2)
14052 delete arg2;
14053 }
14054 return resultobj;
14055 fail:
14056 {
14057 if (temp2)
14058 delete arg2;
14059 }
14060 return NULL;
14061 }
14062
14063
14064 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14065 PyObject *resultobj = NULL;
14066 wxImage *arg1 = (wxImage *) 0 ;
14067 wxString *arg2 = 0 ;
14068 wxString result;
14069 bool temp2 = false ;
14070 PyObject * obj0 = 0 ;
14071 PyObject * obj1 = 0 ;
14072 char *kwnames[] = {
14073 (char *) "self",(char *) "name", NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14078 if (SWIG_arg_fail(1)) SWIG_fail;
14079 {
14080 arg2 = wxString_in_helper(obj1);
14081 if (arg2 == NULL) SWIG_fail;
14082 temp2 = true;
14083 }
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14087
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 {
14092 #if wxUSE_UNICODE
14093 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14094 #else
14095 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14096 #endif
14097 }
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_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj = NULL;
14114 wxImage *arg1 = (wxImage *) 0 ;
14115 wxString *arg2 = 0 ;
14116 int 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_GetOptionInt",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 = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14135
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 {
14140 resultobj = SWIG_From_int(static_cast<int >(result));
14141 }
14142 {
14143 if (temp2)
14144 delete arg2;
14145 }
14146 return resultobj;
14147 fail:
14148 {
14149 if (temp2)
14150 delete arg2;
14151 }
14152 return NULL;
14153 }
14154
14155
14156 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14157 PyObject *resultobj = NULL;
14158 wxImage *arg1 = (wxImage *) 0 ;
14159 wxString *arg2 = 0 ;
14160 bool result;
14161 bool temp2 = false ;
14162 PyObject * obj0 = 0 ;
14163 PyObject * obj1 = 0 ;
14164 char *kwnames[] = {
14165 (char *) "self",(char *) "name", NULL
14166 };
14167
14168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14170 if (SWIG_arg_fail(1)) SWIG_fail;
14171 {
14172 arg2 = wxString_in_helper(obj1);
14173 if (arg2 == NULL) SWIG_fail;
14174 temp2 = true;
14175 }
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 {
14184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14185 }
14186 {
14187 if (temp2)
14188 delete arg2;
14189 }
14190 return resultobj;
14191 fail:
14192 {
14193 if (temp2)
14194 delete arg2;
14195 }
14196 return NULL;
14197 }
14198
14199
14200 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14201 PyObject *resultobj = NULL;
14202 wxImage *arg1 = (wxImage *) 0 ;
14203 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14204 unsigned long result;
14205 PyObject * obj0 = 0 ;
14206 PyObject * obj1 = 0 ;
14207 char *kwnames[] = {
14208 (char *) "self",(char *) "stopafter", NULL
14209 };
14210
14211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14213 if (SWIG_arg_fail(1)) SWIG_fail;
14214 if (obj1) {
14215 {
14216 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14217 if (SWIG_arg_fail(2)) SWIG_fail;
14218 }
14219 }
14220 {
14221 PyThreadState* __tstate = wxPyBeginAllowThreads();
14222 result = (unsigned long)(arg1)->CountColours(arg2);
14223
14224 wxPyEndAllowThreads(__tstate);
14225 if (PyErr_Occurred()) SWIG_fail;
14226 }
14227 {
14228 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14229 }
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj = NULL;
14238 wxImage *arg1 = (wxImage *) 0 ;
14239 wxImageHistogram *arg2 = 0 ;
14240 unsigned long result;
14241 PyObject * obj0 = 0 ;
14242 PyObject * obj1 = 0 ;
14243 char *kwnames[] = {
14244 (char *) "self",(char *) "h", NULL
14245 };
14246
14247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14249 if (SWIG_arg_fail(1)) SWIG_fail;
14250 {
14251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14252 if (SWIG_arg_fail(2)) SWIG_fail;
14253 if (arg2 == NULL) {
14254 SWIG_null_ref("wxImageHistogram");
14255 }
14256 if (SWIG_arg_fail(2)) SWIG_fail;
14257 }
14258 {
14259 PyThreadState* __tstate = wxPyBeginAllowThreads();
14260 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14261
14262 wxPyEndAllowThreads(__tstate);
14263 if (PyErr_Occurred()) SWIG_fail;
14264 }
14265 {
14266 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14267 }
14268 return resultobj;
14269 fail:
14270 return NULL;
14271 }
14272
14273
14274 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14275 PyObject *resultobj = NULL;
14276 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14277 PyObject * obj0 = 0 ;
14278 char *kwnames[] = {
14279 (char *) "handler", NULL
14280 };
14281
14282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14284 if (SWIG_arg_fail(1)) SWIG_fail;
14285 {
14286 PyThreadState* __tstate = wxPyBeginAllowThreads();
14287 wxImage::AddHandler(arg1);
14288
14289 wxPyEndAllowThreads(__tstate);
14290 if (PyErr_Occurred()) SWIG_fail;
14291 }
14292 Py_INCREF(Py_None); resultobj = Py_None;
14293 return resultobj;
14294 fail:
14295 return NULL;
14296 }
14297
14298
14299 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14300 PyObject *resultobj = NULL;
14301 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14302 PyObject * obj0 = 0 ;
14303 char *kwnames[] = {
14304 (char *) "handler", NULL
14305 };
14306
14307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14309 if (SWIG_arg_fail(1)) SWIG_fail;
14310 {
14311 PyThreadState* __tstate = wxPyBeginAllowThreads();
14312 wxImage::InsertHandler(arg1);
14313
14314 wxPyEndAllowThreads(__tstate);
14315 if (PyErr_Occurred()) SWIG_fail;
14316 }
14317 Py_INCREF(Py_None); resultobj = Py_None;
14318 return resultobj;
14319 fail:
14320 return NULL;
14321 }
14322
14323
14324 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14325 PyObject *resultobj = NULL;
14326 wxString *arg1 = 0 ;
14327 bool result;
14328 bool temp1 = false ;
14329 PyObject * obj0 = 0 ;
14330 char *kwnames[] = {
14331 (char *) "name", NULL
14332 };
14333
14334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14335 {
14336 arg1 = wxString_in_helper(obj0);
14337 if (arg1 == NULL) SWIG_fail;
14338 temp1 = true;
14339 }
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14343
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 {
14348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14349 }
14350 {
14351 if (temp1)
14352 delete arg1;
14353 }
14354 return resultobj;
14355 fail:
14356 {
14357 if (temp1)
14358 delete arg1;
14359 }
14360 return NULL;
14361 }
14362
14363
14364 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14365 PyObject *resultobj = NULL;
14366 wxString result;
14367 char *kwnames[] = {
14368 NULL
14369 };
14370
14371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = wxImage::GetImageExtWildcard();
14375
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 {
14380 #if wxUSE_UNICODE
14381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14382 #else
14383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14384 #endif
14385 }
14386 return resultobj;
14387 fail:
14388 return NULL;
14389 }
14390
14391
14392 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14393 PyObject *resultobj = NULL;
14394 wxImage *arg1 = (wxImage *) 0 ;
14395 int arg2 = (int) -1 ;
14396 wxBitmap result;
14397 PyObject * obj0 = 0 ;
14398 PyObject * obj1 = 0 ;
14399 char *kwnames[] = {
14400 (char *) "self",(char *) "depth", NULL
14401 };
14402
14403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14405 if (SWIG_arg_fail(1)) SWIG_fail;
14406 if (obj1) {
14407 {
14408 arg2 = static_cast<int >(SWIG_As_int(obj1));
14409 if (SWIG_arg_fail(2)) SWIG_fail;
14410 }
14411 }
14412 {
14413 if (!wxPyCheckForApp()) SWIG_fail;
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = wxImage_ConvertToBitmap(arg1,arg2);
14416
14417 wxPyEndAllowThreads(__tstate);
14418 if (PyErr_Occurred()) SWIG_fail;
14419 }
14420 {
14421 wxBitmap * resultptr;
14422 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14424 }
14425 return resultobj;
14426 fail:
14427 return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj = NULL;
14433 wxImage *arg1 = (wxImage *) 0 ;
14434 byte arg2 ;
14435 byte arg3 ;
14436 byte arg4 ;
14437 wxBitmap result;
14438 PyObject * obj0 = 0 ;
14439 PyObject * obj1 = 0 ;
14440 PyObject * obj2 = 0 ;
14441 PyObject * obj3 = 0 ;
14442 char *kwnames[] = {
14443 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14444 };
14445
14446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14448 if (SWIG_arg_fail(1)) SWIG_fail;
14449 {
14450 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14451 if (SWIG_arg_fail(2)) SWIG_fail;
14452 }
14453 {
14454 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14455 if (SWIG_arg_fail(3)) SWIG_fail;
14456 }
14457 {
14458 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14459 if (SWIG_arg_fail(4)) SWIG_fail;
14460 }
14461 {
14462 if (!wxPyCheckForApp()) SWIG_fail;
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14465
14466 wxPyEndAllowThreads(__tstate);
14467 if (PyErr_Occurred()) SWIG_fail;
14468 }
14469 {
14470 wxBitmap * resultptr;
14471 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14473 }
14474 return resultobj;
14475 fail:
14476 return NULL;
14477 }
14478
14479
14480 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj = NULL;
14482 wxImage *arg1 = (wxImage *) 0 ;
14483 double arg2 ;
14484 PyObject * obj0 = 0 ;
14485 PyObject * obj1 = 0 ;
14486 char *kwnames[] = {
14487 (char *) "self",(char *) "angle", NULL
14488 };
14489
14490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14492 if (SWIG_arg_fail(1)) SWIG_fail;
14493 {
14494 arg2 = static_cast<double >(SWIG_As_double(obj1));
14495 if (SWIG_arg_fail(2)) SWIG_fail;
14496 }
14497 {
14498 PyThreadState* __tstate = wxPyBeginAllowThreads();
14499 (arg1)->RotateHue(arg2);
14500
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 Py_INCREF(Py_None); resultobj = Py_None;
14505 return resultobj;
14506 fail:
14507 return NULL;
14508 }
14509
14510
14511 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14512 PyObject *resultobj = NULL;
14513 wxImage_RGBValue arg1 ;
14514 wxImage_HSVValue result;
14515 PyObject * obj0 = 0 ;
14516 char *kwnames[] = {
14517 (char *) "rgb", NULL
14518 };
14519
14520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14521 {
14522 wxImage_RGBValue * argp;
14523 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14524 if (SWIG_arg_fail(1)) SWIG_fail;
14525 if (argp == NULL) {
14526 SWIG_null_ref("wxImage_RGBValue");
14527 }
14528 if (SWIG_arg_fail(1)) SWIG_fail;
14529 arg1 = *argp;
14530 }
14531 {
14532 PyThreadState* __tstate = wxPyBeginAllowThreads();
14533 result = wxImage::RGBtoHSV(arg1);
14534
14535 wxPyEndAllowThreads(__tstate);
14536 if (PyErr_Occurred()) SWIG_fail;
14537 }
14538 {
14539 wxImage_HSVValue * resultptr;
14540 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14542 }
14543 return resultobj;
14544 fail:
14545 return NULL;
14546 }
14547
14548
14549 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14550 PyObject *resultobj = NULL;
14551 wxImage_HSVValue arg1 ;
14552 wxImage_RGBValue result;
14553 PyObject * obj0 = 0 ;
14554 char *kwnames[] = {
14555 (char *) "hsv", NULL
14556 };
14557
14558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14559 {
14560 wxImage_HSVValue * argp;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 if (argp == NULL) {
14564 SWIG_null_ref("wxImage_HSVValue");
14565 }
14566 if (SWIG_arg_fail(1)) SWIG_fail;
14567 arg1 = *argp;
14568 }
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = wxImage::HSVtoRGB(arg1);
14572
14573 wxPyEndAllowThreads(__tstate);
14574 if (PyErr_Occurred()) SWIG_fail;
14575 }
14576 {
14577 wxImage_RGBValue * resultptr;
14578 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14580 }
14581 return resultobj;
14582 fail:
14583 return NULL;
14584 }
14585
14586
14587 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14588 PyObject *obj;
14589 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14590 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14591 Py_INCREF(obj);
14592 return Py_BuildValue((char *)"");
14593 }
14594 static int _wrap_NullImage_set(PyObject *) {
14595 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14596 return 1;
14597 }
14598
14599
14600 static PyObject *_wrap_NullImage_get(void) {
14601 PyObject *pyobj = NULL;
14602
14603 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14604 return pyobj;
14605 }
14606
14607
14608 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14609 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14610 return 1;
14611 }
14612
14613
14614 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14615 PyObject *pyobj = NULL;
14616
14617 {
14618 #if wxUSE_UNICODE
14619 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14620 #else
14621 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14622 #endif
14623 }
14624 return pyobj;
14625 }
14626
14627
14628 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14629 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14630 return 1;
14631 }
14632
14633
14634 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14635 PyObject *pyobj = NULL;
14636
14637 {
14638 #if wxUSE_UNICODE
14639 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14640 #else
14641 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14642 #endif
14643 }
14644 return pyobj;
14645 }
14646
14647
14648 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14649 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14650 return 1;
14651 }
14652
14653
14654 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14655 PyObject *pyobj = NULL;
14656
14657 {
14658 #if wxUSE_UNICODE
14659 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14660 #else
14661 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14662 #endif
14663 }
14664 return pyobj;
14665 }
14666
14667
14668 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14669 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14670 return 1;
14671 }
14672
14673
14674 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14675 PyObject *pyobj = NULL;
14676
14677 {
14678 #if wxUSE_UNICODE
14679 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14680 #else
14681 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14682 #endif
14683 }
14684 return pyobj;
14685 }
14686
14687
14688 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14689 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14690 return 1;
14691 }
14692
14693
14694 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14695 PyObject *pyobj = NULL;
14696
14697 {
14698 #if wxUSE_UNICODE
14699 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14700 #else
14701 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14702 #endif
14703 }
14704 return pyobj;
14705 }
14706
14707
14708 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14709 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14710 return 1;
14711 }
14712
14713
14714 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14715 PyObject *pyobj = NULL;
14716
14717 {
14718 #if wxUSE_UNICODE
14719 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14720 #else
14721 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14722 #endif
14723 }
14724 return pyobj;
14725 }
14726
14727
14728 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14729 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14730 return 1;
14731 }
14732
14733
14734 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14735 PyObject *pyobj = NULL;
14736
14737 {
14738 #if wxUSE_UNICODE
14739 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14740 #else
14741 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14742 #endif
14743 }
14744 return pyobj;
14745 }
14746
14747
14748 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14749 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14750 return 1;
14751 }
14752
14753
14754 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14755 PyObject *pyobj = NULL;
14756
14757 {
14758 #if wxUSE_UNICODE
14759 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14760 #else
14761 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14762 #endif
14763 }
14764 return pyobj;
14765 }
14766
14767
14768 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14769 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14770 return 1;
14771 }
14772
14773
14774 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14775 PyObject *pyobj = NULL;
14776
14777 {
14778 #if wxUSE_UNICODE
14779 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14780 #else
14781 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14782 #endif
14783 }
14784 return pyobj;
14785 }
14786
14787
14788 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14789 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14790 return 1;
14791 }
14792
14793
14794 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14795 PyObject *pyobj = NULL;
14796
14797 {
14798 #if wxUSE_UNICODE
14799 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14800 #else
14801 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14802 #endif
14803 }
14804 return pyobj;
14805 }
14806
14807
14808 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14809 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14810 return 1;
14811 }
14812
14813
14814 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14815 PyObject *pyobj = NULL;
14816
14817 {
14818 #if wxUSE_UNICODE
14819 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14820 #else
14821 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14822 #endif
14823 }
14824 return pyobj;
14825 }
14826
14827
14828 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14829 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14830 return 1;
14831 }
14832
14833
14834 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14835 PyObject *pyobj = NULL;
14836
14837 {
14838 #if wxUSE_UNICODE
14839 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14840 #else
14841 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14842 #endif
14843 }
14844 return pyobj;
14845 }
14846
14847
14848 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14849 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14850 return 1;
14851 }
14852
14853
14854 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14855 PyObject *pyobj = NULL;
14856
14857 {
14858 #if wxUSE_UNICODE
14859 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14860 #else
14861 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14862 #endif
14863 }
14864 return pyobj;
14865 }
14866
14867
14868 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14869 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14870 return 1;
14871 }
14872
14873
14874 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14875 PyObject *pyobj = NULL;
14876
14877 {
14878 #if wxUSE_UNICODE
14879 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14880 #else
14881 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14882 #endif
14883 }
14884 return pyobj;
14885 }
14886
14887
14888 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14889 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14890 return 1;
14891 }
14892
14893
14894 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14895 PyObject *pyobj = NULL;
14896
14897 {
14898 #if wxUSE_UNICODE
14899 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14900 #else
14901 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14902 #endif
14903 }
14904 return pyobj;
14905 }
14906
14907
14908 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14909 PyObject *resultobj = NULL;
14910 wxBMPHandler *result;
14911 char *kwnames[] = {
14912 NULL
14913 };
14914
14915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (wxBMPHandler *)new wxBMPHandler();
14919
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14931 PyObject *obj;
14932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14933 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14934 Py_INCREF(obj);
14935 return Py_BuildValue((char *)"");
14936 }
14937 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14938 PyObject *resultobj = NULL;
14939 wxICOHandler *result;
14940 char *kwnames[] = {
14941 NULL
14942 };
14943
14944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14945 {
14946 PyThreadState* __tstate = wxPyBeginAllowThreads();
14947 result = (wxICOHandler *)new wxICOHandler();
14948
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14953 return resultobj;
14954 fail:
14955 return NULL;
14956 }
14957
14958
14959 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14960 PyObject *obj;
14961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14962 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14963 Py_INCREF(obj);
14964 return Py_BuildValue((char *)"");
14965 }
14966 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14967 PyObject *resultobj = NULL;
14968 wxCURHandler *result;
14969 char *kwnames[] = {
14970 NULL
14971 };
14972
14973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 result = (wxCURHandler *)new wxCURHandler();
14977
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14989 PyObject *obj;
14990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14991 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14992 Py_INCREF(obj);
14993 return Py_BuildValue((char *)"");
14994 }
14995 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14996 PyObject *resultobj = NULL;
14997 wxANIHandler *result;
14998 char *kwnames[] = {
14999 NULL
15000 };
15001
15002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
15003 {
15004 PyThreadState* __tstate = wxPyBeginAllowThreads();
15005 result = (wxANIHandler *)new wxANIHandler();
15006
15007 wxPyEndAllowThreads(__tstate);
15008 if (PyErr_Occurred()) SWIG_fail;
15009 }
15010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15011 return resultobj;
15012 fail:
15013 return NULL;
15014 }
15015
15016
15017 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15018 PyObject *obj;
15019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15020 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15021 Py_INCREF(obj);
15022 return Py_BuildValue((char *)"");
15023 }
15024 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15025 PyObject *resultobj = NULL;
15026 wxPNGHandler *result;
15027 char *kwnames[] = {
15028 NULL
15029 };
15030
15031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (wxPNGHandler *)new wxPNGHandler();
15035
15036 wxPyEndAllowThreads(__tstate);
15037 if (PyErr_Occurred()) SWIG_fail;
15038 }
15039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15040 return resultobj;
15041 fail:
15042 return NULL;
15043 }
15044
15045
15046 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15047 PyObject *obj;
15048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15049 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15050 Py_INCREF(obj);
15051 return Py_BuildValue((char *)"");
15052 }
15053 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15054 PyObject *resultobj = NULL;
15055 wxGIFHandler *result;
15056 char *kwnames[] = {
15057 NULL
15058 };
15059
15060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 result = (wxGIFHandler *)new wxGIFHandler();
15064
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15076 PyObject *obj;
15077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15078 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15079 Py_INCREF(obj);
15080 return Py_BuildValue((char *)"");
15081 }
15082 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15083 PyObject *resultobj = NULL;
15084 wxPCXHandler *result;
15085 char *kwnames[] = {
15086 NULL
15087 };
15088
15089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (wxPCXHandler *)new wxPCXHandler();
15093
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15105 PyObject *obj;
15106 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15107 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15108 Py_INCREF(obj);
15109 return Py_BuildValue((char *)"");
15110 }
15111 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15112 PyObject *resultobj = NULL;
15113 wxJPEGHandler *result;
15114 char *kwnames[] = {
15115 NULL
15116 };
15117
15118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 result = (wxJPEGHandler *)new wxJPEGHandler();
15122
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15134 PyObject *obj;
15135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15136 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15137 Py_INCREF(obj);
15138 return Py_BuildValue((char *)"");
15139 }
15140 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15141 PyObject *resultobj = NULL;
15142 wxPNMHandler *result;
15143 char *kwnames[] = {
15144 NULL
15145 };
15146
15147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 result = (wxPNMHandler *)new wxPNMHandler();
15151
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15163 PyObject *obj;
15164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15165 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15166 Py_INCREF(obj);
15167 return Py_BuildValue((char *)"");
15168 }
15169 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15170 PyObject *resultobj = NULL;
15171 wxXPMHandler *result;
15172 char *kwnames[] = {
15173 NULL
15174 };
15175
15176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15177 {
15178 PyThreadState* __tstate = wxPyBeginAllowThreads();
15179 result = (wxXPMHandler *)new wxXPMHandler();
15180
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15185 return resultobj;
15186 fail:
15187 return NULL;
15188 }
15189
15190
15191 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15192 PyObject *obj;
15193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15194 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15195 Py_INCREF(obj);
15196 return Py_BuildValue((char *)"");
15197 }
15198 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj = NULL;
15200 wxTIFFHandler *result;
15201 char *kwnames[] = {
15202 NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 result = (wxTIFFHandler *)new wxTIFFHandler();
15209
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15221 PyObject *obj;
15222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15223 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15224 Py_INCREF(obj);
15225 return Py_BuildValue((char *)"");
15226 }
15227 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj = NULL;
15229 wxImage *arg1 = 0 ;
15230 wxImage *arg2 = 0 ;
15231 int arg3 = (int) 236 ;
15232 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15233 bool result;
15234 PyObject * obj0 = 0 ;
15235 PyObject * obj1 = 0 ;
15236 PyObject * obj2 = 0 ;
15237 PyObject * obj3 = 0 ;
15238 char *kwnames[] = {
15239 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15240 };
15241
15242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15243 {
15244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15245 if (SWIG_arg_fail(1)) SWIG_fail;
15246 if (arg1 == NULL) {
15247 SWIG_null_ref("wxImage");
15248 }
15249 if (SWIG_arg_fail(1)) SWIG_fail;
15250 }
15251 {
15252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15253 if (SWIG_arg_fail(2)) SWIG_fail;
15254 if (arg2 == NULL) {
15255 SWIG_null_ref("wxImage");
15256 }
15257 if (SWIG_arg_fail(2)) SWIG_fail;
15258 }
15259 if (obj2) {
15260 {
15261 arg3 = static_cast<int >(SWIG_As_int(obj2));
15262 if (SWIG_arg_fail(3)) SWIG_fail;
15263 }
15264 }
15265 if (obj3) {
15266 {
15267 arg4 = static_cast<int >(SWIG_As_int(obj3));
15268 if (SWIG_arg_fail(4)) SWIG_fail;
15269 }
15270 }
15271 {
15272 PyThreadState* __tstate = wxPyBeginAllowThreads();
15273 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15274
15275 wxPyEndAllowThreads(__tstate);
15276 if (PyErr_Occurred()) SWIG_fail;
15277 }
15278 {
15279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15280 }
15281 return resultobj;
15282 fail:
15283 return NULL;
15284 }
15285
15286
15287 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15288 PyObject *obj;
15289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15290 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15291 Py_INCREF(obj);
15292 return Py_BuildValue((char *)"");
15293 }
15294 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15295 PyObject *resultobj = NULL;
15296 wxEvtHandler *result;
15297 char *kwnames[] = {
15298 NULL
15299 };
15300
15301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (wxEvtHandler *)new wxEvtHandler();
15305
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15317 PyObject *resultobj = NULL;
15318 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15319 wxEvtHandler *result;
15320 PyObject * obj0 = 0 ;
15321 char *kwnames[] = {
15322 (char *) "self", NULL
15323 };
15324
15325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15327 if (SWIG_arg_fail(1)) SWIG_fail;
15328 {
15329 PyThreadState* __tstate = wxPyBeginAllowThreads();
15330 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15331
15332 wxPyEndAllowThreads(__tstate);
15333 if (PyErr_Occurred()) SWIG_fail;
15334 }
15335 {
15336 resultobj = wxPyMake_wxObject(result, 0);
15337 }
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15345 PyObject *resultobj = NULL;
15346 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15347 wxEvtHandler *result;
15348 PyObject * obj0 = 0 ;
15349 char *kwnames[] = {
15350 (char *) "self", NULL
15351 };
15352
15353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15355 if (SWIG_arg_fail(1)) SWIG_fail;
15356 {
15357 PyThreadState* __tstate = wxPyBeginAllowThreads();
15358 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15359
15360 wxPyEndAllowThreads(__tstate);
15361 if (PyErr_Occurred()) SWIG_fail;
15362 }
15363 {
15364 resultobj = wxPyMake_wxObject(result, 0);
15365 }
15366 return resultobj;
15367 fail:
15368 return NULL;
15369 }
15370
15371
15372 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15373 PyObject *resultobj = NULL;
15374 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15375 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15376 PyObject * obj0 = 0 ;
15377 PyObject * obj1 = 0 ;
15378 char *kwnames[] = {
15379 (char *) "self",(char *) "handler", NULL
15380 };
15381
15382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15384 if (SWIG_arg_fail(1)) SWIG_fail;
15385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15386 if (SWIG_arg_fail(2)) SWIG_fail;
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 (arg1)->SetNextHandler(arg2);
15390
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 Py_INCREF(Py_None); resultobj = Py_None;
15395 return resultobj;
15396 fail:
15397 return NULL;
15398 }
15399
15400
15401 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj = NULL;
15403 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15404 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15405 PyObject * obj0 = 0 ;
15406 PyObject * obj1 = 0 ;
15407 char *kwnames[] = {
15408 (char *) "self",(char *) "handler", NULL
15409 };
15410
15411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(1)) SWIG_fail;
15414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15415 if (SWIG_arg_fail(2)) SWIG_fail;
15416 {
15417 PyThreadState* __tstate = wxPyBeginAllowThreads();
15418 (arg1)->SetPreviousHandler(arg2);
15419
15420 wxPyEndAllowThreads(__tstate);
15421 if (PyErr_Occurred()) SWIG_fail;
15422 }
15423 Py_INCREF(Py_None); resultobj = Py_None;
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj = NULL;
15432 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15433 bool result;
15434 PyObject * obj0 = 0 ;
15435 char *kwnames[] = {
15436 (char *) "self", NULL
15437 };
15438
15439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15441 if (SWIG_arg_fail(1)) SWIG_fail;
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 result = (bool)(arg1)->GetEvtHandlerEnabled();
15445
15446 wxPyEndAllowThreads(__tstate);
15447 if (PyErr_Occurred()) SWIG_fail;
15448 }
15449 {
15450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15451 }
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15459 PyObject *resultobj = NULL;
15460 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15461 bool arg2 ;
15462 PyObject * obj0 = 0 ;
15463 PyObject * obj1 = 0 ;
15464 char *kwnames[] = {
15465 (char *) "self",(char *) "enabled", NULL
15466 };
15467
15468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15470 if (SWIG_arg_fail(1)) SWIG_fail;
15471 {
15472 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15473 if (SWIG_arg_fail(2)) SWIG_fail;
15474 }
15475 {
15476 PyThreadState* __tstate = wxPyBeginAllowThreads();
15477 (arg1)->SetEvtHandlerEnabled(arg2);
15478
15479 wxPyEndAllowThreads(__tstate);
15480 if (PyErr_Occurred()) SWIG_fail;
15481 }
15482 Py_INCREF(Py_None); resultobj = Py_None;
15483 return resultobj;
15484 fail:
15485 return NULL;
15486 }
15487
15488
15489 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15490 PyObject *resultobj = NULL;
15491 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15492 wxEvent *arg2 = 0 ;
15493 bool result;
15494 PyObject * obj0 = 0 ;
15495 PyObject * obj1 = 0 ;
15496 char *kwnames[] = {
15497 (char *) "self",(char *) "event", NULL
15498 };
15499
15500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15502 if (SWIG_arg_fail(1)) SWIG_fail;
15503 {
15504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15505 if (SWIG_arg_fail(2)) SWIG_fail;
15506 if (arg2 == NULL) {
15507 SWIG_null_ref("wxEvent");
15508 }
15509 if (SWIG_arg_fail(2)) SWIG_fail;
15510 }
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 result = (bool)(arg1)->ProcessEvent(*arg2);
15514
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 {
15519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15520 }
15521 return resultobj;
15522 fail:
15523 return NULL;
15524 }
15525
15526
15527 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15528 PyObject *resultobj = NULL;
15529 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15530 wxEvent *arg2 = 0 ;
15531 PyObject * obj0 = 0 ;
15532 PyObject * obj1 = 0 ;
15533 char *kwnames[] = {
15534 (char *) "self",(char *) "event", NULL
15535 };
15536
15537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15539 if (SWIG_arg_fail(1)) SWIG_fail;
15540 {
15541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15542 if (SWIG_arg_fail(2)) SWIG_fail;
15543 if (arg2 == NULL) {
15544 SWIG_null_ref("wxEvent");
15545 }
15546 if (SWIG_arg_fail(2)) SWIG_fail;
15547 }
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 (arg1)->AddPendingEvent(*arg2);
15551
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 Py_INCREF(Py_None); resultobj = Py_None;
15556 return resultobj;
15557 fail:
15558 return NULL;
15559 }
15560
15561
15562 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15563 PyObject *resultobj = NULL;
15564 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15565 PyObject * obj0 = 0 ;
15566 char *kwnames[] = {
15567 (char *) "self", NULL
15568 };
15569
15570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15572 if (SWIG_arg_fail(1)) SWIG_fail;
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 (arg1)->ProcessPendingEvents();
15576
15577 wxPyEndAllowThreads(__tstate);
15578 if (PyErr_Occurred()) SWIG_fail;
15579 }
15580 Py_INCREF(Py_None); resultobj = Py_None;
15581 return resultobj;
15582 fail:
15583 return NULL;
15584 }
15585
15586
15587 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15588 PyObject *resultobj = NULL;
15589 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15590 int arg2 ;
15591 int arg3 ;
15592 int arg4 ;
15593 PyObject *arg5 = (PyObject *) 0 ;
15594 PyObject * obj0 = 0 ;
15595 PyObject * obj1 = 0 ;
15596 PyObject * obj2 = 0 ;
15597 PyObject * obj3 = 0 ;
15598 PyObject * obj4 = 0 ;
15599 char *kwnames[] = {
15600 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15601 };
15602
15603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15605 if (SWIG_arg_fail(1)) SWIG_fail;
15606 {
15607 arg2 = static_cast<int >(SWIG_As_int(obj1));
15608 if (SWIG_arg_fail(2)) SWIG_fail;
15609 }
15610 {
15611 arg3 = static_cast<int >(SWIG_As_int(obj2));
15612 if (SWIG_arg_fail(3)) SWIG_fail;
15613 }
15614 {
15615 arg4 = static_cast<int >(SWIG_As_int(obj3));
15616 if (SWIG_arg_fail(4)) SWIG_fail;
15617 }
15618 arg5 = obj4;
15619 {
15620 PyThreadState* __tstate = wxPyBeginAllowThreads();
15621 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15622
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 Py_INCREF(Py_None); resultobj = Py_None;
15627 return resultobj;
15628 fail:
15629 return NULL;
15630 }
15631
15632
15633 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15634 PyObject *resultobj = NULL;
15635 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15636 int arg2 ;
15637 int arg3 = (int) -1 ;
15638 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15639 bool result;
15640 PyObject * obj0 = 0 ;
15641 PyObject * obj1 = 0 ;
15642 PyObject * obj2 = 0 ;
15643 PyObject * obj3 = 0 ;
15644 char *kwnames[] = {
15645 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15646 };
15647
15648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15650 if (SWIG_arg_fail(1)) SWIG_fail;
15651 {
15652 arg2 = static_cast<int >(SWIG_As_int(obj1));
15653 if (SWIG_arg_fail(2)) SWIG_fail;
15654 }
15655 if (obj2) {
15656 {
15657 arg3 = static_cast<int >(SWIG_As_int(obj2));
15658 if (SWIG_arg_fail(3)) SWIG_fail;
15659 }
15660 }
15661 if (obj3) {
15662 {
15663 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15664 if (SWIG_arg_fail(4)) SWIG_fail;
15665 }
15666 }
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15670
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 {
15675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15676 }
15677 return resultobj;
15678 fail:
15679 return NULL;
15680 }
15681
15682
15683 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15684 PyObject *resultobj = NULL;
15685 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15686 PyObject *arg2 = (PyObject *) 0 ;
15687 bool arg3 = (bool) true ;
15688 PyObject * obj0 = 0 ;
15689 PyObject * obj1 = 0 ;
15690 PyObject * obj2 = 0 ;
15691 char *kwnames[] = {
15692 (char *) "self",(char *) "_self",(char *) "incref", NULL
15693 };
15694
15695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15697 if (SWIG_arg_fail(1)) SWIG_fail;
15698 arg2 = obj1;
15699 if (obj2) {
15700 {
15701 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15702 if (SWIG_arg_fail(3)) SWIG_fail;
15703 }
15704 }
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15708
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 Py_INCREF(Py_None); resultobj = Py_None;
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15720 PyObject *obj;
15721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15722 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15723 Py_INCREF(obj);
15724 return Py_BuildValue((char *)"");
15725 }
15726 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15727 PyObject *resultobj = NULL;
15728 wxEventType result;
15729 char *kwnames[] = {
15730 NULL
15731 };
15732
15733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 result = (wxEventType)wxNewEventType();
15737
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 {
15742 resultobj = SWIG_From_int(static_cast<int >(result));
15743 }
15744 return resultobj;
15745 fail:
15746 return NULL;
15747 }
15748
15749
15750 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15751 PyObject *resultobj = NULL;
15752 wxEvent *arg1 = (wxEvent *) 0 ;
15753 PyObject * obj0 = 0 ;
15754 char *kwnames[] = {
15755 (char *) "self", NULL
15756 };
15757
15758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15760 if (SWIG_arg_fail(1)) SWIG_fail;
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 delete arg1;
15764
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 Py_INCREF(Py_None); resultobj = Py_None;
15769 return resultobj;
15770 fail:
15771 return NULL;
15772 }
15773
15774
15775 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj = NULL;
15777 wxEvent *arg1 = (wxEvent *) 0 ;
15778 wxEventType arg2 ;
15779 PyObject * obj0 = 0 ;
15780 PyObject * obj1 = 0 ;
15781 char *kwnames[] = {
15782 (char *) "self",(char *) "typ", NULL
15783 };
15784
15785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15787 if (SWIG_arg_fail(1)) SWIG_fail;
15788 {
15789 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15790 if (SWIG_arg_fail(2)) SWIG_fail;
15791 }
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 (arg1)->SetEventType(arg2);
15795
15796 wxPyEndAllowThreads(__tstate);
15797 if (PyErr_Occurred()) SWIG_fail;
15798 }
15799 Py_INCREF(Py_None); resultobj = Py_None;
15800 return resultobj;
15801 fail:
15802 return NULL;
15803 }
15804
15805
15806 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15807 PyObject *resultobj = NULL;
15808 wxEvent *arg1 = (wxEvent *) 0 ;
15809 wxEventType result;
15810 PyObject * obj0 = 0 ;
15811 char *kwnames[] = {
15812 (char *) "self", NULL
15813 };
15814
15815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15817 if (SWIG_arg_fail(1)) SWIG_fail;
15818 {
15819 PyThreadState* __tstate = wxPyBeginAllowThreads();
15820 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15821
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 {
15826 resultobj = SWIG_From_int(static_cast<int >(result));
15827 }
15828 return resultobj;
15829 fail:
15830 return NULL;
15831 }
15832
15833
15834 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15835 PyObject *resultobj = NULL;
15836 wxEvent *arg1 = (wxEvent *) 0 ;
15837 wxObject *result;
15838 PyObject * obj0 = 0 ;
15839 char *kwnames[] = {
15840 (char *) "self", NULL
15841 };
15842
15843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15845 if (SWIG_arg_fail(1)) SWIG_fail;
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15849
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 {
15854 resultobj = wxPyMake_wxObject(result, 0);
15855 }
15856 return resultobj;
15857 fail:
15858 return NULL;
15859 }
15860
15861
15862 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj = NULL;
15864 wxEvent *arg1 = (wxEvent *) 0 ;
15865 wxObject *arg2 = (wxObject *) 0 ;
15866 PyObject * obj0 = 0 ;
15867 PyObject * obj1 = 0 ;
15868 char *kwnames[] = {
15869 (char *) "self",(char *) "obj", NULL
15870 };
15871
15872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15874 if (SWIG_arg_fail(1)) SWIG_fail;
15875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15876 if (SWIG_arg_fail(2)) SWIG_fail;
15877 {
15878 PyThreadState* __tstate = wxPyBeginAllowThreads();
15879 (arg1)->SetEventObject(arg2);
15880
15881 wxPyEndAllowThreads(__tstate);
15882 if (PyErr_Occurred()) SWIG_fail;
15883 }
15884 Py_INCREF(Py_None); resultobj = Py_None;
15885 return resultobj;
15886 fail:
15887 return NULL;
15888 }
15889
15890
15891 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15892 PyObject *resultobj = NULL;
15893 wxEvent *arg1 = (wxEvent *) 0 ;
15894 long result;
15895 PyObject * obj0 = 0 ;
15896 char *kwnames[] = {
15897 (char *) "self", NULL
15898 };
15899
15900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15902 if (SWIG_arg_fail(1)) SWIG_fail;
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15906
15907 wxPyEndAllowThreads(__tstate);
15908 if (PyErr_Occurred()) SWIG_fail;
15909 }
15910 {
15911 resultobj = SWIG_From_long(static_cast<long >(result));
15912 }
15913 return resultobj;
15914 fail:
15915 return NULL;
15916 }
15917
15918
15919 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15920 PyObject *resultobj = NULL;
15921 wxEvent *arg1 = (wxEvent *) 0 ;
15922 long arg2 = (long) 0 ;
15923 PyObject * obj0 = 0 ;
15924 PyObject * obj1 = 0 ;
15925 char *kwnames[] = {
15926 (char *) "self",(char *) "ts", NULL
15927 };
15928
15929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15931 if (SWIG_arg_fail(1)) SWIG_fail;
15932 if (obj1) {
15933 {
15934 arg2 = static_cast<long >(SWIG_As_long(obj1));
15935 if (SWIG_arg_fail(2)) SWIG_fail;
15936 }
15937 }
15938 {
15939 PyThreadState* __tstate = wxPyBeginAllowThreads();
15940 (arg1)->SetTimestamp(arg2);
15941
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 Py_INCREF(Py_None); resultobj = Py_None;
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15953 PyObject *resultobj = NULL;
15954 wxEvent *arg1 = (wxEvent *) 0 ;
15955 int result;
15956 PyObject * obj0 = 0 ;
15957 char *kwnames[] = {
15958 (char *) "self", NULL
15959 };
15960
15961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15963 if (SWIG_arg_fail(1)) SWIG_fail;
15964 {
15965 PyThreadState* __tstate = wxPyBeginAllowThreads();
15966 result = (int)((wxEvent const *)arg1)->GetId();
15967
15968 wxPyEndAllowThreads(__tstate);
15969 if (PyErr_Occurred()) SWIG_fail;
15970 }
15971 {
15972 resultobj = SWIG_From_int(static_cast<int >(result));
15973 }
15974 return resultobj;
15975 fail:
15976 return NULL;
15977 }
15978
15979
15980 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15981 PyObject *resultobj = NULL;
15982 wxEvent *arg1 = (wxEvent *) 0 ;
15983 int arg2 ;
15984 PyObject * obj0 = 0 ;
15985 PyObject * obj1 = 0 ;
15986 char *kwnames[] = {
15987 (char *) "self",(char *) "Id", NULL
15988 };
15989
15990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15992 if (SWIG_arg_fail(1)) SWIG_fail;
15993 {
15994 arg2 = static_cast<int >(SWIG_As_int(obj1));
15995 if (SWIG_arg_fail(2)) SWIG_fail;
15996 }
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->SetId(arg2);
16000
16001 wxPyEndAllowThreads(__tstate);
16002 if (PyErr_Occurred()) SWIG_fail;
16003 }
16004 Py_INCREF(Py_None); resultobj = Py_None;
16005 return resultobj;
16006 fail:
16007 return NULL;
16008 }
16009
16010
16011 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16012 PyObject *resultobj = NULL;
16013 wxEvent *arg1 = (wxEvent *) 0 ;
16014 bool result;
16015 PyObject * obj0 = 0 ;
16016 char *kwnames[] = {
16017 (char *) "self", NULL
16018 };
16019
16020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16022 if (SWIG_arg_fail(1)) SWIG_fail;
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16026
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 {
16031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16032 }
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj = NULL;
16041 wxEvent *arg1 = (wxEvent *) 0 ;
16042 bool arg2 = (bool) true ;
16043 PyObject * obj0 = 0 ;
16044 PyObject * obj1 = 0 ;
16045 char *kwnames[] = {
16046 (char *) "self",(char *) "skip", NULL
16047 };
16048
16049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16051 if (SWIG_arg_fail(1)) SWIG_fail;
16052 if (obj1) {
16053 {
16054 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16055 if (SWIG_arg_fail(2)) SWIG_fail;
16056 }
16057 }
16058 {
16059 PyThreadState* __tstate = wxPyBeginAllowThreads();
16060 (arg1)->Skip(arg2);
16061
16062 wxPyEndAllowThreads(__tstate);
16063 if (PyErr_Occurred()) SWIG_fail;
16064 }
16065 Py_INCREF(Py_None); resultobj = Py_None;
16066 return resultobj;
16067 fail:
16068 return NULL;
16069 }
16070
16071
16072 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16073 PyObject *resultobj = NULL;
16074 wxEvent *arg1 = (wxEvent *) 0 ;
16075 bool result;
16076 PyObject * obj0 = 0 ;
16077 char *kwnames[] = {
16078 (char *) "self", NULL
16079 };
16080
16081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16083 if (SWIG_arg_fail(1)) SWIG_fail;
16084 {
16085 PyThreadState* __tstate = wxPyBeginAllowThreads();
16086 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16087
16088 wxPyEndAllowThreads(__tstate);
16089 if (PyErr_Occurred()) SWIG_fail;
16090 }
16091 {
16092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16093 }
16094 return resultobj;
16095 fail:
16096 return NULL;
16097 }
16098
16099
16100 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16101 PyObject *resultobj = NULL;
16102 wxEvent *arg1 = (wxEvent *) 0 ;
16103 bool result;
16104 PyObject * obj0 = 0 ;
16105 char *kwnames[] = {
16106 (char *) "self", NULL
16107 };
16108
16109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16111 if (SWIG_arg_fail(1)) SWIG_fail;
16112 {
16113 PyThreadState* __tstate = wxPyBeginAllowThreads();
16114 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16115
16116 wxPyEndAllowThreads(__tstate);
16117 if (PyErr_Occurred()) SWIG_fail;
16118 }
16119 {
16120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16121 }
16122 return resultobj;
16123 fail:
16124 return NULL;
16125 }
16126
16127
16128 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16129 PyObject *resultobj = NULL;
16130 wxEvent *arg1 = (wxEvent *) 0 ;
16131 int result;
16132 PyObject * obj0 = 0 ;
16133 char *kwnames[] = {
16134 (char *) "self", NULL
16135 };
16136
16137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16139 if (SWIG_arg_fail(1)) SWIG_fail;
16140 {
16141 PyThreadState* __tstate = wxPyBeginAllowThreads();
16142 result = (int)(arg1)->StopPropagation();
16143
16144 wxPyEndAllowThreads(__tstate);
16145 if (PyErr_Occurred()) SWIG_fail;
16146 }
16147 {
16148 resultobj = SWIG_From_int(static_cast<int >(result));
16149 }
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16157 PyObject *resultobj = NULL;
16158 wxEvent *arg1 = (wxEvent *) 0 ;
16159 int arg2 ;
16160 PyObject * obj0 = 0 ;
16161 PyObject * obj1 = 0 ;
16162 char *kwnames[] = {
16163 (char *) "self",(char *) "propagationLevel", NULL
16164 };
16165
16166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16168 if (SWIG_arg_fail(1)) SWIG_fail;
16169 {
16170 arg2 = static_cast<int >(SWIG_As_int(obj1));
16171 if (SWIG_arg_fail(2)) SWIG_fail;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->ResumePropagation(arg2);
16176
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 Py_INCREF(Py_None); resultobj = Py_None;
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj = NULL;
16189 wxEvent *arg1 = (wxEvent *) 0 ;
16190 wxEvent *result;
16191 PyObject * obj0 = 0 ;
16192 char *kwnames[] = {
16193 (char *) "self", NULL
16194 };
16195
16196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16198 if (SWIG_arg_fail(1)) SWIG_fail;
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 result = (wxEvent *)(arg1)->Clone();
16202
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16207 return resultobj;
16208 fail:
16209 return NULL;
16210 }
16211
16212
16213 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16214 PyObject *obj;
16215 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16216 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16217 Py_INCREF(obj);
16218 return Py_BuildValue((char *)"");
16219 }
16220 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16221 PyObject *resultobj = NULL;
16222 wxEvent *arg1 = 0 ;
16223 wxPropagationDisabler *result;
16224 PyObject * obj0 = 0 ;
16225 char *kwnames[] = {
16226 (char *) "event", NULL
16227 };
16228
16229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16230 {
16231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16232 if (SWIG_arg_fail(1)) SWIG_fail;
16233 if (arg1 == NULL) {
16234 SWIG_null_ref("wxEvent");
16235 }
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 }
16238 {
16239 PyThreadState* __tstate = wxPyBeginAllowThreads();
16240 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16241
16242 wxPyEndAllowThreads(__tstate);
16243 if (PyErr_Occurred()) SWIG_fail;
16244 }
16245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16246 return resultobj;
16247 fail:
16248 return NULL;
16249 }
16250
16251
16252 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16253 PyObject *resultobj = NULL;
16254 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16255 PyObject * obj0 = 0 ;
16256 char *kwnames[] = {
16257 (char *) "self", NULL
16258 };
16259
16260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16262 if (SWIG_arg_fail(1)) SWIG_fail;
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 delete arg1;
16266
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 Py_INCREF(Py_None); resultobj = Py_None;
16271 return resultobj;
16272 fail:
16273 return NULL;
16274 }
16275
16276
16277 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16278 PyObject *obj;
16279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16280 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16281 Py_INCREF(obj);
16282 return Py_BuildValue((char *)"");
16283 }
16284 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16285 PyObject *resultobj = NULL;
16286 wxEvent *arg1 = 0 ;
16287 wxPropagateOnce *result;
16288 PyObject * obj0 = 0 ;
16289 char *kwnames[] = {
16290 (char *) "event", NULL
16291 };
16292
16293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16294 {
16295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16296 if (SWIG_arg_fail(1)) SWIG_fail;
16297 if (arg1 == NULL) {
16298 SWIG_null_ref("wxEvent");
16299 }
16300 if (SWIG_arg_fail(1)) SWIG_fail;
16301 }
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16305
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16310 return resultobj;
16311 fail:
16312 return NULL;
16313 }
16314
16315
16316 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16317 PyObject *resultobj = NULL;
16318 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16319 PyObject * obj0 = 0 ;
16320 char *kwnames[] = {
16321 (char *) "self", NULL
16322 };
16323
16324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16326 if (SWIG_arg_fail(1)) SWIG_fail;
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 delete arg1;
16330
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 Py_INCREF(Py_None); resultobj = Py_None;
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16342 PyObject *obj;
16343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16344 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16345 Py_INCREF(obj);
16346 return Py_BuildValue((char *)"");
16347 }
16348 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj = NULL;
16350 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16351 int arg2 = (int) 0 ;
16352 wxCommandEvent *result;
16353 PyObject * obj0 = 0 ;
16354 PyObject * obj1 = 0 ;
16355 char *kwnames[] = {
16356 (char *) "commandType",(char *) "winid", NULL
16357 };
16358
16359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16360 if (obj0) {
16361 {
16362 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16363 if (SWIG_arg_fail(1)) SWIG_fail;
16364 }
16365 }
16366 if (obj1) {
16367 {
16368 arg2 = static_cast<int >(SWIG_As_int(obj1));
16369 if (SWIG_arg_fail(2)) SWIG_fail;
16370 }
16371 }
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16375
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16380 return resultobj;
16381 fail:
16382 return NULL;
16383 }
16384
16385
16386 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj = NULL;
16388 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16389 int result;
16390 PyObject * obj0 = 0 ;
16391 char *kwnames[] = {
16392 (char *) "self", NULL
16393 };
16394
16395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16397 if (SWIG_arg_fail(1)) SWIG_fail;
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16401
16402 wxPyEndAllowThreads(__tstate);
16403 if (PyErr_Occurred()) SWIG_fail;
16404 }
16405 {
16406 resultobj = SWIG_From_int(static_cast<int >(result));
16407 }
16408 return resultobj;
16409 fail:
16410 return NULL;
16411 }
16412
16413
16414 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16415 PyObject *resultobj = NULL;
16416 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16417 wxString *arg2 = 0 ;
16418 bool temp2 = false ;
16419 PyObject * obj0 = 0 ;
16420 PyObject * obj1 = 0 ;
16421 char *kwnames[] = {
16422 (char *) "self",(char *) "s", NULL
16423 };
16424
16425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16427 if (SWIG_arg_fail(1)) SWIG_fail;
16428 {
16429 arg2 = wxString_in_helper(obj1);
16430 if (arg2 == NULL) SWIG_fail;
16431 temp2 = true;
16432 }
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 (arg1)->SetString((wxString const &)*arg2);
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 Py_INCREF(Py_None); resultobj = Py_None;
16441 {
16442 if (temp2)
16443 delete arg2;
16444 }
16445 return resultobj;
16446 fail:
16447 {
16448 if (temp2)
16449 delete arg2;
16450 }
16451 return NULL;
16452 }
16453
16454
16455 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16456 PyObject *resultobj = NULL;
16457 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16458 wxString result;
16459 PyObject * obj0 = 0 ;
16460 char *kwnames[] = {
16461 (char *) "self", NULL
16462 };
16463
16464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16466 if (SWIG_arg_fail(1)) SWIG_fail;
16467 {
16468 PyThreadState* __tstate = wxPyBeginAllowThreads();
16469 result = ((wxCommandEvent const *)arg1)->GetString();
16470
16471 wxPyEndAllowThreads(__tstate);
16472 if (PyErr_Occurred()) SWIG_fail;
16473 }
16474 {
16475 #if wxUSE_UNICODE
16476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16477 #else
16478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16479 #endif
16480 }
16481 return resultobj;
16482 fail:
16483 return NULL;
16484 }
16485
16486
16487 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16488 PyObject *resultobj = NULL;
16489 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16490 bool result;
16491 PyObject * obj0 = 0 ;
16492 char *kwnames[] = {
16493 (char *) "self", NULL
16494 };
16495
16496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16498 if (SWIG_arg_fail(1)) SWIG_fail;
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16502
16503 wxPyEndAllowThreads(__tstate);
16504 if (PyErr_Occurred()) SWIG_fail;
16505 }
16506 {
16507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16508 }
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16516 PyObject *resultobj = NULL;
16517 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16518 bool result;
16519 PyObject * obj0 = 0 ;
16520 char *kwnames[] = {
16521 (char *) "self", NULL
16522 };
16523
16524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16526 if (SWIG_arg_fail(1)) SWIG_fail;
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16530
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 {
16535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16536 }
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj = NULL;
16545 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16546 long arg2 ;
16547 PyObject * obj0 = 0 ;
16548 PyObject * obj1 = 0 ;
16549 char *kwnames[] = {
16550 (char *) "self",(char *) "extraLong", NULL
16551 };
16552
16553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16555 if (SWIG_arg_fail(1)) SWIG_fail;
16556 {
16557 arg2 = static_cast<long >(SWIG_As_long(obj1));
16558 if (SWIG_arg_fail(2)) SWIG_fail;
16559 }
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->SetExtraLong(arg2);
16563
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 Py_INCREF(Py_None); resultobj = Py_None;
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = NULL;
16576 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16577 long result;
16578 PyObject * obj0 = 0 ;
16579 char *kwnames[] = {
16580 (char *) "self", NULL
16581 };
16582
16583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16585 if (SWIG_arg_fail(1)) SWIG_fail;
16586 {
16587 PyThreadState* __tstate = wxPyBeginAllowThreads();
16588 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16589
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 {
16594 resultobj = SWIG_From_long(static_cast<long >(result));
16595 }
16596 return resultobj;
16597 fail:
16598 return NULL;
16599 }
16600
16601
16602 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16603 PyObject *resultobj = NULL;
16604 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16605 int arg2 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 char *kwnames[] = {
16609 (char *) "self",(char *) "i", NULL
16610 };
16611
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 {
16616 arg2 = static_cast<int >(SWIG_As_int(obj1));
16617 if (SWIG_arg_fail(2)) SWIG_fail;
16618 }
16619 {
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 (arg1)->SetInt(arg2);
16622
16623 wxPyEndAllowThreads(__tstate);
16624 if (PyErr_Occurred()) SWIG_fail;
16625 }
16626 Py_INCREF(Py_None); resultobj = Py_None;
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj = NULL;
16635 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16636 long result;
16637 PyObject * obj0 = 0 ;
16638 char *kwnames[] = {
16639 (char *) "self", NULL
16640 };
16641
16642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(1)) SWIG_fail;
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16648
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 {
16653 resultobj = SWIG_From_long(static_cast<long >(result));
16654 }
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj = NULL;
16663 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16664 wxEvent *result;
16665 PyObject * obj0 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "self", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16672 if (SWIG_arg_fail(1)) SWIG_fail;
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16676
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16688 PyObject *obj;
16689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16690 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16691 Py_INCREF(obj);
16692 return Py_BuildValue((char *)"");
16693 }
16694 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj = NULL;
16696 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16697 int arg2 = (int) 0 ;
16698 wxNotifyEvent *result;
16699 PyObject * obj0 = 0 ;
16700 PyObject * obj1 = 0 ;
16701 char *kwnames[] = {
16702 (char *) "commandType",(char *) "winid", NULL
16703 };
16704
16705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16706 if (obj0) {
16707 {
16708 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16709 if (SWIG_arg_fail(1)) SWIG_fail;
16710 }
16711 }
16712 if (obj1) {
16713 {
16714 arg2 = static_cast<int >(SWIG_As_int(obj1));
16715 if (SWIG_arg_fail(2)) SWIG_fail;
16716 }
16717 }
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16726 return resultobj;
16727 fail:
16728 return NULL;
16729 }
16730
16731
16732 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj = NULL;
16734 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16735 PyObject * obj0 = 0 ;
16736 char *kwnames[] = {
16737 (char *) "self", NULL
16738 };
16739
16740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16742 if (SWIG_arg_fail(1)) SWIG_fail;
16743 {
16744 PyThreadState* __tstate = wxPyBeginAllowThreads();
16745 (arg1)->Veto();
16746
16747 wxPyEndAllowThreads(__tstate);
16748 if (PyErr_Occurred()) SWIG_fail;
16749 }
16750 Py_INCREF(Py_None); resultobj = Py_None;
16751 return resultobj;
16752 fail:
16753 return NULL;
16754 }
16755
16756
16757 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16758 PyObject *resultobj = NULL;
16759 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16760 PyObject * obj0 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "self", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16767 if (SWIG_arg_fail(1)) SWIG_fail;
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 (arg1)->Allow();
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 Py_INCREF(Py_None); resultobj = Py_None;
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj = NULL;
16784 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16785 bool result;
16786 PyObject * obj0 = 0 ;
16787 char *kwnames[] = {
16788 (char *) "self", NULL
16789 };
16790
16791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16793 if (SWIG_arg_fail(1)) SWIG_fail;
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = (bool)(arg1)->IsAllowed();
16797
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 {
16802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16803 }
16804 return resultobj;
16805 fail:
16806 return NULL;
16807 }
16808
16809
16810 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16811 PyObject *obj;
16812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16813 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16814 Py_INCREF(obj);
16815 return Py_BuildValue((char *)"");
16816 }
16817 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj = NULL;
16819 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16820 int arg2 = (int) 0 ;
16821 int arg3 = (int) 0 ;
16822 int arg4 = (int) 0 ;
16823 wxScrollEvent *result;
16824 PyObject * obj0 = 0 ;
16825 PyObject * obj1 = 0 ;
16826 PyObject * obj2 = 0 ;
16827 PyObject * obj3 = 0 ;
16828 char *kwnames[] = {
16829 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16830 };
16831
16832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16833 if (obj0) {
16834 {
16835 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16836 if (SWIG_arg_fail(1)) SWIG_fail;
16837 }
16838 }
16839 if (obj1) {
16840 {
16841 arg2 = static_cast<int >(SWIG_As_int(obj1));
16842 if (SWIG_arg_fail(2)) SWIG_fail;
16843 }
16844 }
16845 if (obj2) {
16846 {
16847 arg3 = static_cast<int >(SWIG_As_int(obj2));
16848 if (SWIG_arg_fail(3)) SWIG_fail;
16849 }
16850 }
16851 if (obj3) {
16852 {
16853 arg4 = static_cast<int >(SWIG_As_int(obj3));
16854 if (SWIG_arg_fail(4)) SWIG_fail;
16855 }
16856 }
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16860
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16872 PyObject *resultobj = NULL;
16873 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16874 int result;
16875 PyObject * obj0 = 0 ;
16876 char *kwnames[] = {
16877 (char *) "self", NULL
16878 };
16879
16880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16882 if (SWIG_arg_fail(1)) SWIG_fail;
16883 {
16884 PyThreadState* __tstate = wxPyBeginAllowThreads();
16885 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16886
16887 wxPyEndAllowThreads(__tstate);
16888 if (PyErr_Occurred()) SWIG_fail;
16889 }
16890 {
16891 resultobj = SWIG_From_int(static_cast<int >(result));
16892 }
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16900 PyObject *resultobj = NULL;
16901 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16902 int result;
16903 PyObject * obj0 = 0 ;
16904 char *kwnames[] = {
16905 (char *) "self", NULL
16906 };
16907
16908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16910 if (SWIG_arg_fail(1)) SWIG_fail;
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16914
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 {
16919 resultobj = SWIG_From_int(static_cast<int >(result));
16920 }
16921 return resultobj;
16922 fail:
16923 return NULL;
16924 }
16925
16926
16927 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16928 PyObject *resultobj = NULL;
16929 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16930 int arg2 ;
16931 PyObject * obj0 = 0 ;
16932 PyObject * obj1 = 0 ;
16933 char *kwnames[] = {
16934 (char *) "self",(char *) "orient", NULL
16935 };
16936
16937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16939 if (SWIG_arg_fail(1)) SWIG_fail;
16940 {
16941 arg2 = static_cast<int >(SWIG_As_int(obj1));
16942 if (SWIG_arg_fail(2)) SWIG_fail;
16943 }
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 (arg1)->SetOrientation(arg2);
16947
16948 wxPyEndAllowThreads(__tstate);
16949 if (PyErr_Occurred()) SWIG_fail;
16950 }
16951 Py_INCREF(Py_None); resultobj = Py_None;
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj = NULL;
16960 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16961 int arg2 ;
16962 PyObject * obj0 = 0 ;
16963 PyObject * obj1 = 0 ;
16964 char *kwnames[] = {
16965 (char *) "self",(char *) "pos", NULL
16966 };
16967
16968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16970 if (SWIG_arg_fail(1)) SWIG_fail;
16971 {
16972 arg2 = static_cast<int >(SWIG_As_int(obj1));
16973 if (SWIG_arg_fail(2)) SWIG_fail;
16974 }
16975 {
16976 PyThreadState* __tstate = wxPyBeginAllowThreads();
16977 (arg1)->SetPosition(arg2);
16978
16979 wxPyEndAllowThreads(__tstate);
16980 if (PyErr_Occurred()) SWIG_fail;
16981 }
16982 Py_INCREF(Py_None); resultobj = Py_None;
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16990 PyObject *obj;
16991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16992 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16993 Py_INCREF(obj);
16994 return Py_BuildValue((char *)"");
16995 }
16996 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16997 PyObject *resultobj = NULL;
16998 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16999 int arg2 = (int) 0 ;
17000 int arg3 = (int) 0 ;
17001 wxScrollWinEvent *result;
17002 PyObject * obj0 = 0 ;
17003 PyObject * obj1 = 0 ;
17004 PyObject * obj2 = 0 ;
17005 char *kwnames[] = {
17006 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17007 };
17008
17009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17010 if (obj0) {
17011 {
17012 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17013 if (SWIG_arg_fail(1)) SWIG_fail;
17014 }
17015 }
17016 if (obj1) {
17017 {
17018 arg2 = static_cast<int >(SWIG_As_int(obj1));
17019 if (SWIG_arg_fail(2)) SWIG_fail;
17020 }
17021 }
17022 if (obj2) {
17023 {
17024 arg3 = static_cast<int >(SWIG_As_int(obj2));
17025 if (SWIG_arg_fail(3)) SWIG_fail;
17026 }
17027 }
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17031
17032 wxPyEndAllowThreads(__tstate);
17033 if (PyErr_Occurred()) SWIG_fail;
17034 }
17035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj = NULL;
17044 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17045 int result;
17046 PyObject * obj0 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17057
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = SWIG_From_int(static_cast<int >(result));
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj = NULL;
17072 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17073 int result;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17085
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 {
17090 resultobj = SWIG_From_int(static_cast<int >(result));
17091 }
17092 return resultobj;
17093 fail:
17094 return NULL;
17095 }
17096
17097
17098 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17099 PyObject *resultobj = NULL;
17100 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17101 int arg2 ;
17102 PyObject * obj0 = 0 ;
17103 PyObject * obj1 = 0 ;
17104 char *kwnames[] = {
17105 (char *) "self",(char *) "orient", NULL
17106 };
17107
17108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17110 if (SWIG_arg_fail(1)) SWIG_fail;
17111 {
17112 arg2 = static_cast<int >(SWIG_As_int(obj1));
17113 if (SWIG_arg_fail(2)) SWIG_fail;
17114 }
17115 {
17116 PyThreadState* __tstate = wxPyBeginAllowThreads();
17117 (arg1)->SetOrientation(arg2);
17118
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 Py_INCREF(Py_None); resultobj = Py_None;
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj = NULL;
17131 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17132 int arg2 ;
17133 PyObject * obj0 = 0 ;
17134 PyObject * obj1 = 0 ;
17135 char *kwnames[] = {
17136 (char *) "self",(char *) "pos", NULL
17137 };
17138
17139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17141 if (SWIG_arg_fail(1)) SWIG_fail;
17142 {
17143 arg2 = static_cast<int >(SWIG_As_int(obj1));
17144 if (SWIG_arg_fail(2)) SWIG_fail;
17145 }
17146 {
17147 PyThreadState* __tstate = wxPyBeginAllowThreads();
17148 (arg1)->SetPosition(arg2);
17149
17150 wxPyEndAllowThreads(__tstate);
17151 if (PyErr_Occurred()) SWIG_fail;
17152 }
17153 Py_INCREF(Py_None); resultobj = Py_None;
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17161 PyObject *obj;
17162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17163 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17164 Py_INCREF(obj);
17165 return Py_BuildValue((char *)"");
17166 }
17167 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17168 PyObject *resultobj = NULL;
17169 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17170 wxMouseEvent *result;
17171 PyObject * obj0 = 0 ;
17172 char *kwnames[] = {
17173 (char *) "mouseType", NULL
17174 };
17175
17176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17177 if (obj0) {
17178 {
17179 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17180 if (SWIG_arg_fail(1)) SWIG_fail;
17181 }
17182 }
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17186
17187 wxPyEndAllowThreads(__tstate);
17188 if (PyErr_Occurred()) SWIG_fail;
17189 }
17190 {
17191 resultobj = wxPyMake_wxObject(result, 1);
17192 }
17193 return resultobj;
17194 fail:
17195 return NULL;
17196 }
17197
17198
17199 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17200 PyObject *resultobj = NULL;
17201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17202 bool result;
17203 PyObject * obj0 = 0 ;
17204 char *kwnames[] = {
17205 (char *) "self", NULL
17206 };
17207
17208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17210 if (SWIG_arg_fail(1)) SWIG_fail;
17211 {
17212 PyThreadState* __tstate = wxPyBeginAllowThreads();
17213 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17214
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 {
17219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17220 }
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj = NULL;
17229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17230 int arg2 = (int) wxMOUSE_BTN_ANY ;
17231 bool result;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 char *kwnames[] = {
17235 (char *) "self",(char *) "but", NULL
17236 };
17237
17238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17240 if (SWIG_arg_fail(1)) SWIG_fail;
17241 if (obj1) {
17242 {
17243 arg2 = static_cast<int >(SWIG_As_int(obj1));
17244 if (SWIG_arg_fail(2)) SWIG_fail;
17245 }
17246 }
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17250
17251 wxPyEndAllowThreads(__tstate);
17252 if (PyErr_Occurred()) SWIG_fail;
17253 }
17254 {
17255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17256 }
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17264 PyObject *resultobj = NULL;
17265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17266 int arg2 = (int) wxMOUSE_BTN_ANY ;
17267 bool result;
17268 PyObject * obj0 = 0 ;
17269 PyObject * obj1 = 0 ;
17270 char *kwnames[] = {
17271 (char *) "self",(char *) "but", NULL
17272 };
17273
17274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17276 if (SWIG_arg_fail(1)) SWIG_fail;
17277 if (obj1) {
17278 {
17279 arg2 = static_cast<int >(SWIG_As_int(obj1));
17280 if (SWIG_arg_fail(2)) SWIG_fail;
17281 }
17282 }
17283 {
17284 PyThreadState* __tstate = wxPyBeginAllowThreads();
17285 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17286
17287 wxPyEndAllowThreads(__tstate);
17288 if (PyErr_Occurred()) SWIG_fail;
17289 }
17290 {
17291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17292 }
17293 return resultobj;
17294 fail:
17295 return NULL;
17296 }
17297
17298
17299 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17300 PyObject *resultobj = NULL;
17301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17302 int arg2 = (int) wxMOUSE_BTN_ANY ;
17303 bool result;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self",(char *) "but", NULL
17308 };
17309
17310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17312 if (SWIG_arg_fail(1)) SWIG_fail;
17313 if (obj1) {
17314 {
17315 arg2 = static_cast<int >(SWIG_As_int(obj1));
17316 if (SWIG_arg_fail(2)) SWIG_fail;
17317 }
17318 }
17319 {
17320 PyThreadState* __tstate = wxPyBeginAllowThreads();
17321 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17322
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 {
17327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17328 }
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj = NULL;
17337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17338 int arg2 ;
17339 bool result;
17340 PyObject * obj0 = 0 ;
17341 PyObject * obj1 = 0 ;
17342 char *kwnames[] = {
17343 (char *) "self",(char *) "button", NULL
17344 };
17345
17346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17348 if (SWIG_arg_fail(1)) SWIG_fail;
17349 {
17350 arg2 = static_cast<int >(SWIG_As_int(obj1));
17351 if (SWIG_arg_fail(2)) SWIG_fail;
17352 }
17353 {
17354 PyThreadState* __tstate = wxPyBeginAllowThreads();
17355 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17356
17357 wxPyEndAllowThreads(__tstate);
17358 if (PyErr_Occurred()) SWIG_fail;
17359 }
17360 {
17361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17362 }
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17370 PyObject *resultobj = NULL;
17371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17372 int arg2 ;
17373 bool result;
17374 PyObject * obj0 = 0 ;
17375 PyObject * obj1 = 0 ;
17376 char *kwnames[] = {
17377 (char *) "self",(char *) "but", NULL
17378 };
17379
17380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17382 if (SWIG_arg_fail(1)) SWIG_fail;
17383 {
17384 arg2 = static_cast<int >(SWIG_As_int(obj1));
17385 if (SWIG_arg_fail(2)) SWIG_fail;
17386 }
17387 {
17388 PyThreadState* __tstate = wxPyBeginAllowThreads();
17389 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17390
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 {
17395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17396 }
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj = NULL;
17405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17406 int result;
17407 PyObject * obj0 = 0 ;
17408 char *kwnames[] = {
17409 (char *) "self", NULL
17410 };
17411
17412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17414 if (SWIG_arg_fail(1)) SWIG_fail;
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17418
17419 wxPyEndAllowThreads(__tstate);
17420 if (PyErr_Occurred()) SWIG_fail;
17421 }
17422 {
17423 resultobj = SWIG_From_int(static_cast<int >(result));
17424 }
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj = NULL;
17433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17434 bool result;
17435 PyObject * obj0 = 0 ;
17436 char *kwnames[] = {
17437 (char *) "self", NULL
17438 };
17439
17440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17442 if (SWIG_arg_fail(1)) SWIG_fail;
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17446
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 {
17451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17452 }
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj = NULL;
17461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17462 bool result;
17463 PyObject * obj0 = 0 ;
17464 char *kwnames[] = {
17465 (char *) "self", NULL
17466 };
17467
17468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17470 if (SWIG_arg_fail(1)) SWIG_fail;
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17474
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 {
17479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17480 }
17481 return resultobj;
17482 fail:
17483 return NULL;
17484 }
17485
17486
17487 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17488 PyObject *resultobj = NULL;
17489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17490 bool result;
17491 PyObject * obj0 = 0 ;
17492 char *kwnames[] = {
17493 (char *) "self", NULL
17494 };
17495
17496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17498 if (SWIG_arg_fail(1)) SWIG_fail;
17499 {
17500 PyThreadState* __tstate = wxPyBeginAllowThreads();
17501 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17502
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 {
17507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17508 }
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj = NULL;
17517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17518 bool result;
17519 PyObject * obj0 = 0 ;
17520 char *kwnames[] = {
17521 (char *) "self", NULL
17522 };
17523
17524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17526 if (SWIG_arg_fail(1)) SWIG_fail;
17527 {
17528 PyThreadState* __tstate = wxPyBeginAllowThreads();
17529 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17530
17531 wxPyEndAllowThreads(__tstate);
17532 if (PyErr_Occurred()) SWIG_fail;
17533 }
17534 {
17535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17536 }
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17544 PyObject *resultobj = NULL;
17545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17546 bool result;
17547 PyObject * obj0 = 0 ;
17548 char *kwnames[] = {
17549 (char *) "self", NULL
17550 };
17551
17552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17554 if (SWIG_arg_fail(1)) SWIG_fail;
17555 {
17556 PyThreadState* __tstate = wxPyBeginAllowThreads();
17557 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17558
17559 wxPyEndAllowThreads(__tstate);
17560 if (PyErr_Occurred()) SWIG_fail;
17561 }
17562 {
17563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17564 }
17565 return resultobj;
17566 fail:
17567 return NULL;
17568 }
17569
17570
17571 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj = NULL;
17573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17574 bool result;
17575 PyObject * obj0 = 0 ;
17576 char *kwnames[] = {
17577 (char *) "self", NULL
17578 };
17579
17580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17582 if (SWIG_arg_fail(1)) SWIG_fail;
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17586
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 {
17591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17592 }
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj = NULL;
17601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17602 bool result;
17603 PyObject * obj0 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17614
17615 wxPyEndAllowThreads(__tstate);
17616 if (PyErr_Occurred()) SWIG_fail;
17617 }
17618 {
17619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17620 }
17621 return resultobj;
17622 fail:
17623 return NULL;
17624 }
17625
17626
17627 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj = NULL;
17629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17630 bool result;
17631 PyObject * obj0 = 0 ;
17632 char *kwnames[] = {
17633 (char *) "self", NULL
17634 };
17635
17636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17638 if (SWIG_arg_fail(1)) SWIG_fail;
17639 {
17640 PyThreadState* __tstate = wxPyBeginAllowThreads();
17641 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17642
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 {
17647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17648 }
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj = NULL;
17657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17658 bool result;
17659 PyObject * obj0 = 0 ;
17660 char *kwnames[] = {
17661 (char *) "self", NULL
17662 };
17663
17664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17666 if (SWIG_arg_fail(1)) SWIG_fail;
17667 {
17668 PyThreadState* __tstate = wxPyBeginAllowThreads();
17669 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17670
17671 wxPyEndAllowThreads(__tstate);
17672 if (PyErr_Occurred()) SWIG_fail;
17673 }
17674 {
17675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17676 }
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17684 PyObject *resultobj = NULL;
17685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17686 bool result;
17687 PyObject * obj0 = 0 ;
17688 char *kwnames[] = {
17689 (char *) "self", NULL
17690 };
17691
17692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17694 if (SWIG_arg_fail(1)) SWIG_fail;
17695 {
17696 PyThreadState* __tstate = wxPyBeginAllowThreads();
17697 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17698
17699 wxPyEndAllowThreads(__tstate);
17700 if (PyErr_Occurred()) SWIG_fail;
17701 }
17702 {
17703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17704 }
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17712 PyObject *resultobj = NULL;
17713 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17714 bool result;
17715 PyObject * obj0 = 0 ;
17716 char *kwnames[] = {
17717 (char *) "self", NULL
17718 };
17719
17720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17722 if (SWIG_arg_fail(1)) SWIG_fail;
17723 {
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17726
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 {
17731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17732 }
17733 return resultobj;
17734 fail:
17735 return NULL;
17736 }
17737
17738
17739 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17740 PyObject *resultobj = NULL;
17741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17742 bool result;
17743 PyObject * obj0 = 0 ;
17744 char *kwnames[] = {
17745 (char *) "self", NULL
17746 };
17747
17748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17750 if (SWIG_arg_fail(1)) SWIG_fail;
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17754
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 {
17759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17760 }
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj = NULL;
17769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17770 bool result;
17771 PyObject * obj0 = 0 ;
17772 char *kwnames[] = {
17773 (char *) "self", NULL
17774 };
17775
17776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(1)) SWIG_fail;
17779 {
17780 PyThreadState* __tstate = wxPyBeginAllowThreads();
17781 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17782
17783 wxPyEndAllowThreads(__tstate);
17784 if (PyErr_Occurred()) SWIG_fail;
17785 }
17786 {
17787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17788 }
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj = NULL;
17797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17798 bool result;
17799 PyObject * obj0 = 0 ;
17800 char *kwnames[] = {
17801 (char *) "self", NULL
17802 };
17803
17804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17806 if (SWIG_arg_fail(1)) SWIG_fail;
17807 {
17808 PyThreadState* __tstate = wxPyBeginAllowThreads();
17809 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17810
17811 wxPyEndAllowThreads(__tstate);
17812 if (PyErr_Occurred()) SWIG_fail;
17813 }
17814 {
17815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17816 }
17817 return resultobj;
17818 fail:
17819 return NULL;
17820 }
17821
17822
17823 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj = NULL;
17825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17826 bool result;
17827 PyObject * obj0 = 0 ;
17828 char *kwnames[] = {
17829 (char *) "self", NULL
17830 };
17831
17832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17834 if (SWIG_arg_fail(1)) SWIG_fail;
17835 {
17836 PyThreadState* __tstate = wxPyBeginAllowThreads();
17837 result = (bool)(arg1)->LeftIsDown();
17838
17839 wxPyEndAllowThreads(__tstate);
17840 if (PyErr_Occurred()) SWIG_fail;
17841 }
17842 {
17843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17844 }
17845 return resultobj;
17846 fail:
17847 return NULL;
17848 }
17849
17850
17851 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17852 PyObject *resultobj = NULL;
17853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17854 bool result;
17855 PyObject * obj0 = 0 ;
17856 char *kwnames[] = {
17857 (char *) "self", NULL
17858 };
17859
17860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17862 if (SWIG_arg_fail(1)) SWIG_fail;
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)(arg1)->MiddleIsDown();
17866
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 {
17871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17872 }
17873 return resultobj;
17874 fail:
17875 return NULL;
17876 }
17877
17878
17879 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17880 PyObject *resultobj = NULL;
17881 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17882 bool result;
17883 PyObject * obj0 = 0 ;
17884 char *kwnames[] = {
17885 (char *) "self", NULL
17886 };
17887
17888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17890 if (SWIG_arg_fail(1)) SWIG_fail;
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (bool)(arg1)->RightIsDown();
17894
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 {
17899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17900 }
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj = NULL;
17909 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17910 bool result;
17911 PyObject * obj0 = 0 ;
17912 char *kwnames[] = {
17913 (char *) "self", NULL
17914 };
17915
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17918 if (SWIG_arg_fail(1)) SWIG_fail;
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17922
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 {
17927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17928 }
17929 return resultobj;
17930 fail:
17931 return NULL;
17932 }
17933
17934
17935 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj = NULL;
17937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17938 bool result;
17939 PyObject * obj0 = 0 ;
17940 char *kwnames[] = {
17941 (char *) "self", NULL
17942 };
17943
17944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17946 if (SWIG_arg_fail(1)) SWIG_fail;
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17950
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 {
17955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17956 }
17957 return resultobj;
17958 fail:
17959 return NULL;
17960 }
17961
17962
17963 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17964 PyObject *resultobj = NULL;
17965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17966 bool result;
17967 PyObject * obj0 = 0 ;
17968 char *kwnames[] = {
17969 (char *) "self", NULL
17970 };
17971
17972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17974 if (SWIG_arg_fail(1)) SWIG_fail;
17975 {
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17978
17979 wxPyEndAllowThreads(__tstate);
17980 if (PyErr_Occurred()) SWIG_fail;
17981 }
17982 {
17983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17984 }
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj = NULL;
17993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17994 bool result;
17995 PyObject * obj0 = 0 ;
17996 char *kwnames[] = {
17997 (char *) "self", NULL
17998 };
17999
18000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
18001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18002 if (SWIG_arg_fail(1)) SWIG_fail;
18003 {
18004 PyThreadState* __tstate = wxPyBeginAllowThreads();
18005 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18006
18007 wxPyEndAllowThreads(__tstate);
18008 if (PyErr_Occurred()) SWIG_fail;
18009 }
18010 {
18011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18012 }
18013 return resultobj;
18014 fail:
18015 return NULL;
18016 }
18017
18018
18019 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18020 PyObject *resultobj = NULL;
18021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18022 wxPoint result;
18023 PyObject * obj0 = 0 ;
18024 char *kwnames[] = {
18025 (char *) "self", NULL
18026 };
18027
18028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18030 if (SWIG_arg_fail(1)) SWIG_fail;
18031 {
18032 PyThreadState* __tstate = wxPyBeginAllowThreads();
18033 result = (arg1)->GetPosition();
18034
18035 wxPyEndAllowThreads(__tstate);
18036 if (PyErr_Occurred()) SWIG_fail;
18037 }
18038 {
18039 wxPoint * resultptr;
18040 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18042 }
18043 return resultobj;
18044 fail:
18045 return NULL;
18046 }
18047
18048
18049 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18050 PyObject *resultobj = NULL;
18051 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18052 long *arg2 = (long *) 0 ;
18053 long *arg3 = (long *) 0 ;
18054 long temp2 ;
18055 int res2 = 0 ;
18056 long temp3 ;
18057 int res3 = 0 ;
18058 PyObject * obj0 = 0 ;
18059 char *kwnames[] = {
18060 (char *) "self", NULL
18061 };
18062
18063 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18064 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18067 if (SWIG_arg_fail(1)) SWIG_fail;
18068 {
18069 PyThreadState* __tstate = wxPyBeginAllowThreads();
18070 (arg1)->GetPosition(arg2,arg3);
18071
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 Py_INCREF(Py_None); resultobj = Py_None;
18076 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18077 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18078 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18079 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj = NULL;
18088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18089 wxDC *arg2 = 0 ;
18090 wxPoint result;
18091 PyObject * obj0 = 0 ;
18092 PyObject * obj1 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "self",(char *) "dc", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 {
18101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18102 if (SWIG_arg_fail(2)) SWIG_fail;
18103 if (arg2 == NULL) {
18104 SWIG_null_ref("wxDC");
18105 }
18106 if (SWIG_arg_fail(2)) SWIG_fail;
18107 }
18108 {
18109 PyThreadState* __tstate = wxPyBeginAllowThreads();
18110 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18111
18112 wxPyEndAllowThreads(__tstate);
18113 if (PyErr_Occurred()) SWIG_fail;
18114 }
18115 {
18116 wxPoint * resultptr;
18117 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18119 }
18120 return resultobj;
18121 fail:
18122 return NULL;
18123 }
18124
18125
18126 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18127 PyObject *resultobj = NULL;
18128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18129 int result;
18130 PyObject * obj0 = 0 ;
18131 char *kwnames[] = {
18132 (char *) "self", NULL
18133 };
18134
18135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18137 if (SWIG_arg_fail(1)) SWIG_fail;
18138 {
18139 PyThreadState* __tstate = wxPyBeginAllowThreads();
18140 result = (int)((wxMouseEvent const *)arg1)->GetX();
18141
18142 wxPyEndAllowThreads(__tstate);
18143 if (PyErr_Occurred()) SWIG_fail;
18144 }
18145 {
18146 resultobj = SWIG_From_int(static_cast<int >(result));
18147 }
18148 return resultobj;
18149 fail:
18150 return NULL;
18151 }
18152
18153
18154 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18155 PyObject *resultobj = NULL;
18156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18157 int result;
18158 PyObject * obj0 = 0 ;
18159 char *kwnames[] = {
18160 (char *) "self", NULL
18161 };
18162
18163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18165 if (SWIG_arg_fail(1)) SWIG_fail;
18166 {
18167 PyThreadState* __tstate = wxPyBeginAllowThreads();
18168 result = (int)((wxMouseEvent const *)arg1)->GetY();
18169
18170 wxPyEndAllowThreads(__tstate);
18171 if (PyErr_Occurred()) SWIG_fail;
18172 }
18173 {
18174 resultobj = SWIG_From_int(static_cast<int >(result));
18175 }
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18183 PyObject *resultobj = NULL;
18184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18185 int result;
18186 PyObject * obj0 = 0 ;
18187 char *kwnames[] = {
18188 (char *) "self", NULL
18189 };
18190
18191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18193 if (SWIG_arg_fail(1)) SWIG_fail;
18194 {
18195 PyThreadState* __tstate = wxPyBeginAllowThreads();
18196 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18197
18198 wxPyEndAllowThreads(__tstate);
18199 if (PyErr_Occurred()) SWIG_fail;
18200 }
18201 {
18202 resultobj = SWIG_From_int(static_cast<int >(result));
18203 }
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj = NULL;
18212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18213 int result;
18214 PyObject * obj0 = 0 ;
18215 char *kwnames[] = {
18216 (char *) "self", NULL
18217 };
18218
18219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18221 if (SWIG_arg_fail(1)) SWIG_fail;
18222 {
18223 PyThreadState* __tstate = wxPyBeginAllowThreads();
18224 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18225
18226 wxPyEndAllowThreads(__tstate);
18227 if (PyErr_Occurred()) SWIG_fail;
18228 }
18229 {
18230 resultobj = SWIG_From_int(static_cast<int >(result));
18231 }
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18239 PyObject *resultobj = NULL;
18240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18241 int result;
18242 PyObject * obj0 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(1)) SWIG_fail;
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18253
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 {
18258 resultobj = SWIG_From_int(static_cast<int >(result));
18259 }
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj = NULL;
18268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18269 bool result;
18270 PyObject * obj0 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "self", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18277 if (SWIG_arg_fail(1)) SWIG_fail;
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18281
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 {
18286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18287 }
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj = NULL;
18296 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18297 int arg2 ;
18298 PyObject * obj0 = 0 ;
18299 PyObject * obj1 = 0 ;
18300 char *kwnames[] = {
18301 (char *) "self",(char *) "m_x", NULL
18302 };
18303
18304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18306 if (SWIG_arg_fail(1)) SWIG_fail;
18307 {
18308 arg2 = static_cast<int >(SWIG_As_int(obj1));
18309 if (SWIG_arg_fail(2)) SWIG_fail;
18310 }
18311 if (arg1) (arg1)->m_x = arg2;
18312
18313 Py_INCREF(Py_None); resultobj = Py_None;
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj = NULL;
18322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18323 int result;
18324 PyObject * obj0 = 0 ;
18325 char *kwnames[] = {
18326 (char *) "self", NULL
18327 };
18328
18329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18331 if (SWIG_arg_fail(1)) SWIG_fail;
18332 result = (int) ((arg1)->m_x);
18333
18334 {
18335 resultobj = SWIG_From_int(static_cast<int >(result));
18336 }
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18344 PyObject *resultobj = NULL;
18345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18346 int arg2 ;
18347 PyObject * obj0 = 0 ;
18348 PyObject * obj1 = 0 ;
18349 char *kwnames[] = {
18350 (char *) "self",(char *) "m_y", NULL
18351 };
18352
18353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18355 if (SWIG_arg_fail(1)) SWIG_fail;
18356 {
18357 arg2 = static_cast<int >(SWIG_As_int(obj1));
18358 if (SWIG_arg_fail(2)) SWIG_fail;
18359 }
18360 if (arg1) (arg1)->m_y = arg2;
18361
18362 Py_INCREF(Py_None); resultobj = Py_None;
18363 return resultobj;
18364 fail:
18365 return NULL;
18366 }
18367
18368
18369 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18370 PyObject *resultobj = NULL;
18371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18372 int result;
18373 PyObject * obj0 = 0 ;
18374 char *kwnames[] = {
18375 (char *) "self", NULL
18376 };
18377
18378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18380 if (SWIG_arg_fail(1)) SWIG_fail;
18381 result = (int) ((arg1)->m_y);
18382
18383 {
18384 resultobj = SWIG_From_int(static_cast<int >(result));
18385 }
18386 return resultobj;
18387 fail:
18388 return NULL;
18389 }
18390
18391
18392 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18393 PyObject *resultobj = NULL;
18394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18395 bool arg2 ;
18396 PyObject * obj0 = 0 ;
18397 PyObject * obj1 = 0 ;
18398 char *kwnames[] = {
18399 (char *) "self",(char *) "m_leftDown", NULL
18400 };
18401
18402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18404 if (SWIG_arg_fail(1)) SWIG_fail;
18405 {
18406 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18407 if (SWIG_arg_fail(2)) SWIG_fail;
18408 }
18409 if (arg1) (arg1)->m_leftDown = arg2;
18410
18411 Py_INCREF(Py_None); resultobj = Py_None;
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj = NULL;
18420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18421 bool result;
18422 PyObject * obj0 = 0 ;
18423 char *kwnames[] = {
18424 (char *) "self", NULL
18425 };
18426
18427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18429 if (SWIG_arg_fail(1)) SWIG_fail;
18430 result = (bool) ((arg1)->m_leftDown);
18431
18432 {
18433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18434 }
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj = NULL;
18443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18444 bool arg2 ;
18445 PyObject * obj0 = 0 ;
18446 PyObject * obj1 = 0 ;
18447 char *kwnames[] = {
18448 (char *) "self",(char *) "m_middleDown", NULL
18449 };
18450
18451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18453 if (SWIG_arg_fail(1)) SWIG_fail;
18454 {
18455 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18456 if (SWIG_arg_fail(2)) SWIG_fail;
18457 }
18458 if (arg1) (arg1)->m_middleDown = arg2;
18459
18460 Py_INCREF(Py_None); resultobj = Py_None;
18461 return resultobj;
18462 fail:
18463 return NULL;
18464 }
18465
18466
18467 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18468 PyObject *resultobj = NULL;
18469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18470 bool result;
18471 PyObject * obj0 = 0 ;
18472 char *kwnames[] = {
18473 (char *) "self", NULL
18474 };
18475
18476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18478 if (SWIG_arg_fail(1)) SWIG_fail;
18479 result = (bool) ((arg1)->m_middleDown);
18480
18481 {
18482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18483 }
18484 return resultobj;
18485 fail:
18486 return NULL;
18487 }
18488
18489
18490 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18491 PyObject *resultobj = NULL;
18492 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18493 bool arg2 ;
18494 PyObject * obj0 = 0 ;
18495 PyObject * obj1 = 0 ;
18496 char *kwnames[] = {
18497 (char *) "self",(char *) "m_rightDown", NULL
18498 };
18499
18500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18502 if (SWIG_arg_fail(1)) SWIG_fail;
18503 {
18504 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18505 if (SWIG_arg_fail(2)) SWIG_fail;
18506 }
18507 if (arg1) (arg1)->m_rightDown = arg2;
18508
18509 Py_INCREF(Py_None); resultobj = Py_None;
18510 return resultobj;
18511 fail:
18512 return NULL;
18513 }
18514
18515
18516 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18517 PyObject *resultobj = NULL;
18518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18519 bool result;
18520 PyObject * obj0 = 0 ;
18521 char *kwnames[] = {
18522 (char *) "self", NULL
18523 };
18524
18525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18527 if (SWIG_arg_fail(1)) SWIG_fail;
18528 result = (bool) ((arg1)->m_rightDown);
18529
18530 {
18531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18532 }
18533 return resultobj;
18534 fail:
18535 return NULL;
18536 }
18537
18538
18539 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18540 PyObject *resultobj = NULL;
18541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18542 bool arg2 ;
18543 PyObject * obj0 = 0 ;
18544 PyObject * obj1 = 0 ;
18545 char *kwnames[] = {
18546 (char *) "self",(char *) "m_controlDown", NULL
18547 };
18548
18549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18551 if (SWIG_arg_fail(1)) SWIG_fail;
18552 {
18553 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18554 if (SWIG_arg_fail(2)) SWIG_fail;
18555 }
18556 if (arg1) (arg1)->m_controlDown = arg2;
18557
18558 Py_INCREF(Py_None); resultobj = Py_None;
18559 return resultobj;
18560 fail:
18561 return NULL;
18562 }
18563
18564
18565 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18566 PyObject *resultobj = NULL;
18567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18568 bool result;
18569 PyObject * obj0 = 0 ;
18570 char *kwnames[] = {
18571 (char *) "self", NULL
18572 };
18573
18574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18576 if (SWIG_arg_fail(1)) SWIG_fail;
18577 result = (bool) ((arg1)->m_controlDown);
18578
18579 {
18580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18581 }
18582 return resultobj;
18583 fail:
18584 return NULL;
18585 }
18586
18587
18588 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj = NULL;
18590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18591 bool arg2 ;
18592 PyObject * obj0 = 0 ;
18593 PyObject * obj1 = 0 ;
18594 char *kwnames[] = {
18595 (char *) "self",(char *) "m_shiftDown", NULL
18596 };
18597
18598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18600 if (SWIG_arg_fail(1)) SWIG_fail;
18601 {
18602 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18603 if (SWIG_arg_fail(2)) SWIG_fail;
18604 }
18605 if (arg1) (arg1)->m_shiftDown = arg2;
18606
18607 Py_INCREF(Py_None); resultobj = Py_None;
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj = NULL;
18616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18617 bool result;
18618 PyObject * obj0 = 0 ;
18619 char *kwnames[] = {
18620 (char *) "self", NULL
18621 };
18622
18623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18625 if (SWIG_arg_fail(1)) SWIG_fail;
18626 result = (bool) ((arg1)->m_shiftDown);
18627
18628 {
18629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18630 }
18631 return resultobj;
18632 fail:
18633 return NULL;
18634 }
18635
18636
18637 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18638 PyObject *resultobj = NULL;
18639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18640 bool arg2 ;
18641 PyObject * obj0 = 0 ;
18642 PyObject * obj1 = 0 ;
18643 char *kwnames[] = {
18644 (char *) "self",(char *) "m_altDown", NULL
18645 };
18646
18647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18649 if (SWIG_arg_fail(1)) SWIG_fail;
18650 {
18651 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18652 if (SWIG_arg_fail(2)) SWIG_fail;
18653 }
18654 if (arg1) (arg1)->m_altDown = arg2;
18655
18656 Py_INCREF(Py_None); resultobj = Py_None;
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18664 PyObject *resultobj = NULL;
18665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18666 bool result;
18667 PyObject * obj0 = 0 ;
18668 char *kwnames[] = {
18669 (char *) "self", NULL
18670 };
18671
18672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18674 if (SWIG_arg_fail(1)) SWIG_fail;
18675 result = (bool) ((arg1)->m_altDown);
18676
18677 {
18678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18679 }
18680 return resultobj;
18681 fail:
18682 return NULL;
18683 }
18684
18685
18686 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18687 PyObject *resultobj = NULL;
18688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18689 bool arg2 ;
18690 PyObject * obj0 = 0 ;
18691 PyObject * obj1 = 0 ;
18692 char *kwnames[] = {
18693 (char *) "self",(char *) "m_metaDown", NULL
18694 };
18695
18696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18698 if (SWIG_arg_fail(1)) SWIG_fail;
18699 {
18700 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18701 if (SWIG_arg_fail(2)) SWIG_fail;
18702 }
18703 if (arg1) (arg1)->m_metaDown = arg2;
18704
18705 Py_INCREF(Py_None); resultobj = Py_None;
18706 return resultobj;
18707 fail:
18708 return NULL;
18709 }
18710
18711
18712 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18713 PyObject *resultobj = NULL;
18714 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18715 bool result;
18716 PyObject * obj0 = 0 ;
18717 char *kwnames[] = {
18718 (char *) "self", NULL
18719 };
18720
18721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18723 if (SWIG_arg_fail(1)) SWIG_fail;
18724 result = (bool) ((arg1)->m_metaDown);
18725
18726 {
18727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18728 }
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj = NULL;
18737 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18738 int arg2 ;
18739 PyObject * obj0 = 0 ;
18740 PyObject * obj1 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "self",(char *) "m_wheelRotation", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(1)) SWIG_fail;
18748 {
18749 arg2 = static_cast<int >(SWIG_As_int(obj1));
18750 if (SWIG_arg_fail(2)) SWIG_fail;
18751 }
18752 if (arg1) (arg1)->m_wheelRotation = arg2;
18753
18754 Py_INCREF(Py_None); resultobj = Py_None;
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj = NULL;
18763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18764 int result;
18765 PyObject * obj0 = 0 ;
18766 char *kwnames[] = {
18767 (char *) "self", NULL
18768 };
18769
18770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18772 if (SWIG_arg_fail(1)) SWIG_fail;
18773 result = (int) ((arg1)->m_wheelRotation);
18774
18775 {
18776 resultobj = SWIG_From_int(static_cast<int >(result));
18777 }
18778 return resultobj;
18779 fail:
18780 return NULL;
18781 }
18782
18783
18784 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18785 PyObject *resultobj = NULL;
18786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18787 int arg2 ;
18788 PyObject * obj0 = 0 ;
18789 PyObject * obj1 = 0 ;
18790 char *kwnames[] = {
18791 (char *) "self",(char *) "m_wheelDelta", NULL
18792 };
18793
18794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18796 if (SWIG_arg_fail(1)) SWIG_fail;
18797 {
18798 arg2 = static_cast<int >(SWIG_As_int(obj1));
18799 if (SWIG_arg_fail(2)) SWIG_fail;
18800 }
18801 if (arg1) (arg1)->m_wheelDelta = arg2;
18802
18803 Py_INCREF(Py_None); resultobj = Py_None;
18804 return resultobj;
18805 fail:
18806 return NULL;
18807 }
18808
18809
18810 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18811 PyObject *resultobj = NULL;
18812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18813 int result;
18814 PyObject * obj0 = 0 ;
18815 char *kwnames[] = {
18816 (char *) "self", NULL
18817 };
18818
18819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18821 if (SWIG_arg_fail(1)) SWIG_fail;
18822 result = (int) ((arg1)->m_wheelDelta);
18823
18824 {
18825 resultobj = SWIG_From_int(static_cast<int >(result));
18826 }
18827 return resultobj;
18828 fail:
18829 return NULL;
18830 }
18831
18832
18833 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18834 PyObject *resultobj = NULL;
18835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18836 int arg2 ;
18837 PyObject * obj0 = 0 ;
18838 PyObject * obj1 = 0 ;
18839 char *kwnames[] = {
18840 (char *) "self",(char *) "m_linesPerAction", NULL
18841 };
18842
18843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18845 if (SWIG_arg_fail(1)) SWIG_fail;
18846 {
18847 arg2 = static_cast<int >(SWIG_As_int(obj1));
18848 if (SWIG_arg_fail(2)) SWIG_fail;
18849 }
18850 if (arg1) (arg1)->m_linesPerAction = arg2;
18851
18852 Py_INCREF(Py_None); resultobj = Py_None;
18853 return resultobj;
18854 fail:
18855 return NULL;
18856 }
18857
18858
18859 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18860 PyObject *resultobj = NULL;
18861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18862 int result;
18863 PyObject * obj0 = 0 ;
18864 char *kwnames[] = {
18865 (char *) "self", NULL
18866 };
18867
18868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18870 if (SWIG_arg_fail(1)) SWIG_fail;
18871 result = (int) ((arg1)->m_linesPerAction);
18872
18873 {
18874 resultobj = SWIG_From_int(static_cast<int >(result));
18875 }
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18883 PyObject *obj;
18884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18885 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18886 Py_INCREF(obj);
18887 return Py_BuildValue((char *)"");
18888 }
18889 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj = NULL;
18891 int arg1 = (int) 0 ;
18892 int arg2 = (int) 0 ;
18893 wxSetCursorEvent *result;
18894 PyObject * obj0 = 0 ;
18895 PyObject * obj1 = 0 ;
18896 char *kwnames[] = {
18897 (char *) "x",(char *) "y", NULL
18898 };
18899
18900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18901 if (obj0) {
18902 {
18903 arg1 = static_cast<int >(SWIG_As_int(obj0));
18904 if (SWIG_arg_fail(1)) SWIG_fail;
18905 }
18906 }
18907 if (obj1) {
18908 {
18909 arg2 = static_cast<int >(SWIG_As_int(obj1));
18910 if (SWIG_arg_fail(2)) SWIG_fail;
18911 }
18912 }
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18916
18917 wxPyEndAllowThreads(__tstate);
18918 if (PyErr_Occurred()) SWIG_fail;
18919 }
18920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18921 return resultobj;
18922 fail:
18923 return NULL;
18924 }
18925
18926
18927 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18928 PyObject *resultobj = NULL;
18929 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18930 int result;
18931 PyObject * obj0 = 0 ;
18932 char *kwnames[] = {
18933 (char *) "self", NULL
18934 };
18935
18936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18938 if (SWIG_arg_fail(1)) SWIG_fail;
18939 {
18940 PyThreadState* __tstate = wxPyBeginAllowThreads();
18941 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18942
18943 wxPyEndAllowThreads(__tstate);
18944 if (PyErr_Occurred()) SWIG_fail;
18945 }
18946 {
18947 resultobj = SWIG_From_int(static_cast<int >(result));
18948 }
18949 return resultobj;
18950 fail:
18951 return NULL;
18952 }
18953
18954
18955 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18956 PyObject *resultobj = NULL;
18957 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18958 int result;
18959 PyObject * obj0 = 0 ;
18960 char *kwnames[] = {
18961 (char *) "self", NULL
18962 };
18963
18964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18966 if (SWIG_arg_fail(1)) SWIG_fail;
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18970
18971 wxPyEndAllowThreads(__tstate);
18972 if (PyErr_Occurred()) SWIG_fail;
18973 }
18974 {
18975 resultobj = SWIG_From_int(static_cast<int >(result));
18976 }
18977 return resultobj;
18978 fail:
18979 return NULL;
18980 }
18981
18982
18983 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18984 PyObject *resultobj = NULL;
18985 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18986 wxCursor *arg2 = 0 ;
18987 PyObject * obj0 = 0 ;
18988 PyObject * obj1 = 0 ;
18989 char *kwnames[] = {
18990 (char *) "self",(char *) "cursor", NULL
18991 };
18992
18993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18995 if (SWIG_arg_fail(1)) SWIG_fail;
18996 {
18997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18998 if (SWIG_arg_fail(2)) SWIG_fail;
18999 if (arg2 == NULL) {
19000 SWIG_null_ref("wxCursor");
19001 }
19002 if (SWIG_arg_fail(2)) SWIG_fail;
19003 }
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 (arg1)->SetCursor((wxCursor const &)*arg2);
19007
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 Py_INCREF(Py_None); resultobj = Py_None;
19012 return resultobj;
19013 fail:
19014 return NULL;
19015 }
19016
19017
19018 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj = NULL;
19020 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19021 wxCursor *result;
19022 PyObject * obj0 = 0 ;
19023 char *kwnames[] = {
19024 (char *) "self", NULL
19025 };
19026
19027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19029 if (SWIG_arg_fail(1)) SWIG_fail;
19030 {
19031 PyThreadState* __tstate = wxPyBeginAllowThreads();
19032 {
19033 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19034 result = (wxCursor *) &_result_ref;
19035 }
19036
19037 wxPyEndAllowThreads(__tstate);
19038 if (PyErr_Occurred()) SWIG_fail;
19039 }
19040 {
19041 wxCursor* resultptr = new wxCursor(*result);
19042 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19043 }
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj = NULL;
19052 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19053 bool result;
19054 PyObject * obj0 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "self", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19065
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 {
19070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19071 }
19072 return resultobj;
19073 fail:
19074 return NULL;
19075 }
19076
19077
19078 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19079 PyObject *obj;
19080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19081 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19082 Py_INCREF(obj);
19083 return Py_BuildValue((char *)"");
19084 }
19085 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj = NULL;
19087 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19088 wxKeyEvent *result;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "eventType", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19095 if (obj0) {
19096 {
19097 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19098 if (SWIG_arg_fail(1)) SWIG_fail;
19099 }
19100 }
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19104
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19109 return resultobj;
19110 fail:
19111 return NULL;
19112 }
19113
19114
19115 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19116 PyObject *resultobj = NULL;
19117 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19118 bool result;
19119 PyObject * obj0 = 0 ;
19120 char *kwnames[] = {
19121 (char *) "self", NULL
19122 };
19123
19124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19126 if (SWIG_arg_fail(1)) SWIG_fail;
19127 {
19128 PyThreadState* __tstate = wxPyBeginAllowThreads();
19129 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19130
19131 wxPyEndAllowThreads(__tstate);
19132 if (PyErr_Occurred()) SWIG_fail;
19133 }
19134 {
19135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19136 }
19137 return resultobj;
19138 fail:
19139 return NULL;
19140 }
19141
19142
19143 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19144 PyObject *resultobj = NULL;
19145 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19146 bool result;
19147 PyObject * obj0 = 0 ;
19148 char *kwnames[] = {
19149 (char *) "self", NULL
19150 };
19151
19152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19154 if (SWIG_arg_fail(1)) SWIG_fail;
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19158
19159 wxPyEndAllowThreads(__tstate);
19160 if (PyErr_Occurred()) SWIG_fail;
19161 }
19162 {
19163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19164 }
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj = NULL;
19173 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19174 bool result;
19175 PyObject * obj0 = 0 ;
19176 char *kwnames[] = {
19177 (char *) "self", NULL
19178 };
19179
19180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19182 if (SWIG_arg_fail(1)) SWIG_fail;
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19186
19187 wxPyEndAllowThreads(__tstate);
19188 if (PyErr_Occurred()) SWIG_fail;
19189 }
19190 {
19191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19192 }
19193 return resultobj;
19194 fail:
19195 return NULL;
19196 }
19197
19198
19199 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19200 PyObject *resultobj = NULL;
19201 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19202 bool result;
19203 PyObject * obj0 = 0 ;
19204 char *kwnames[] = {
19205 (char *) "self", NULL
19206 };
19207
19208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19210 if (SWIG_arg_fail(1)) SWIG_fail;
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19214
19215 wxPyEndAllowThreads(__tstate);
19216 if (PyErr_Occurred()) SWIG_fail;
19217 }
19218 {
19219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19220 }
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19228 PyObject *resultobj = NULL;
19229 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19230 bool result;
19231 PyObject * obj0 = 0 ;
19232 char *kwnames[] = {
19233 (char *) "self", NULL
19234 };
19235
19236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19238 if (SWIG_arg_fail(1)) SWIG_fail;
19239 {
19240 PyThreadState* __tstate = wxPyBeginAllowThreads();
19241 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19242
19243 wxPyEndAllowThreads(__tstate);
19244 if (PyErr_Occurred()) SWIG_fail;
19245 }
19246 {
19247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19248 }
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj = NULL;
19257 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19258 bool result;
19259 PyObject * obj0 = 0 ;
19260 char *kwnames[] = {
19261 (char *) "self", NULL
19262 };
19263
19264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19266 if (SWIG_arg_fail(1)) SWIG_fail;
19267 {
19268 PyThreadState* __tstate = wxPyBeginAllowThreads();
19269 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19270
19271 wxPyEndAllowThreads(__tstate);
19272 if (PyErr_Occurred()) SWIG_fail;
19273 }
19274 {
19275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19276 }
19277 return resultobj;
19278 fail:
19279 return NULL;
19280 }
19281
19282
19283 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19284 PyObject *resultobj = NULL;
19285 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19286 int result;
19287 PyObject * obj0 = 0 ;
19288 char *kwnames[] = {
19289 (char *) "self", NULL
19290 };
19291
19292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19294 if (SWIG_arg_fail(1)) SWIG_fail;
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19298
19299 wxPyEndAllowThreads(__tstate);
19300 if (PyErr_Occurred()) SWIG_fail;
19301 }
19302 {
19303 resultobj = SWIG_From_int(static_cast<int >(result));
19304 }
19305 return resultobj;
19306 fail:
19307 return NULL;
19308 }
19309
19310
19311 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19312 PyObject *resultobj = NULL;
19313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19314 int result;
19315 PyObject * obj0 = 0 ;
19316 char *kwnames[] = {
19317 (char *) "self", NULL
19318 };
19319
19320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19322 if (SWIG_arg_fail(1)) SWIG_fail;
19323 {
19324 PyThreadState* __tstate = wxPyBeginAllowThreads();
19325 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19326
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 {
19331 resultobj = SWIG_From_int(static_cast<int >(result));
19332 }
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19340 PyObject *resultobj = NULL;
19341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19342 unsigned int result;
19343 PyObject * obj0 = 0 ;
19344 char *kwnames[] = {
19345 (char *) "self", NULL
19346 };
19347
19348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19350 if (SWIG_arg_fail(1)) SWIG_fail;
19351 {
19352 PyThreadState* __tstate = wxPyBeginAllowThreads();
19353 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19354
19355 wxPyEndAllowThreads(__tstate);
19356 if (PyErr_Occurred()) SWIG_fail;
19357 }
19358 {
19359 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19360 }
19361 return resultobj;
19362 fail:
19363 return NULL;
19364 }
19365
19366
19367 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19368 PyObject *resultobj = NULL;
19369 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19370 unsigned int result;
19371 PyObject * obj0 = 0 ;
19372 char *kwnames[] = {
19373 (char *) "self", NULL
19374 };
19375
19376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19378 if (SWIG_arg_fail(1)) SWIG_fail;
19379 {
19380 PyThreadState* __tstate = wxPyBeginAllowThreads();
19381 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19382
19383 wxPyEndAllowThreads(__tstate);
19384 if (PyErr_Occurred()) SWIG_fail;
19385 }
19386 {
19387 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19388 }
19389 return resultobj;
19390 fail:
19391 return NULL;
19392 }
19393
19394
19395 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19396 PyObject *resultobj = NULL;
19397 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19398 wxPoint result;
19399 PyObject * obj0 = 0 ;
19400 char *kwnames[] = {
19401 (char *) "self", NULL
19402 };
19403
19404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19406 if (SWIG_arg_fail(1)) SWIG_fail;
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 result = (arg1)->GetPosition();
19410
19411 wxPyEndAllowThreads(__tstate);
19412 if (PyErr_Occurred()) SWIG_fail;
19413 }
19414 {
19415 wxPoint * resultptr;
19416 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19418 }
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19426 PyObject *resultobj = NULL;
19427 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19428 long *arg2 = (long *) 0 ;
19429 long *arg3 = (long *) 0 ;
19430 long temp2 ;
19431 int res2 = 0 ;
19432 long temp3 ;
19433 int res3 = 0 ;
19434 PyObject * obj0 = 0 ;
19435 char *kwnames[] = {
19436 (char *) "self", NULL
19437 };
19438
19439 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19440 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19443 if (SWIG_arg_fail(1)) SWIG_fail;
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 (arg1)->GetPosition(arg2,arg3);
19447
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 Py_INCREF(Py_None); resultobj = Py_None;
19452 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19453 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19454 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19455 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19456 return resultobj;
19457 fail:
19458 return NULL;
19459 }
19460
19461
19462 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19463 PyObject *resultobj = NULL;
19464 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19465 int result;
19466 PyObject * obj0 = 0 ;
19467 char *kwnames[] = {
19468 (char *) "self", NULL
19469 };
19470
19471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19473 if (SWIG_arg_fail(1)) SWIG_fail;
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 result = (int)((wxKeyEvent const *)arg1)->GetX();
19477
19478 wxPyEndAllowThreads(__tstate);
19479 if (PyErr_Occurred()) SWIG_fail;
19480 }
19481 {
19482 resultobj = SWIG_From_int(static_cast<int >(result));
19483 }
19484 return resultobj;
19485 fail:
19486 return NULL;
19487 }
19488
19489
19490 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19491 PyObject *resultobj = NULL;
19492 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19493 int result;
19494 PyObject * obj0 = 0 ;
19495 char *kwnames[] = {
19496 (char *) "self", NULL
19497 };
19498
19499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19501 if (SWIG_arg_fail(1)) SWIG_fail;
19502 {
19503 PyThreadState* __tstate = wxPyBeginAllowThreads();
19504 result = (int)((wxKeyEvent const *)arg1)->GetY();
19505
19506 wxPyEndAllowThreads(__tstate);
19507 if (PyErr_Occurred()) SWIG_fail;
19508 }
19509 {
19510 resultobj = SWIG_From_int(static_cast<int >(result));
19511 }
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj = NULL;
19520 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19521 int arg2 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 char *kwnames[] = {
19525 (char *) "self",(char *) "m_x", NULL
19526 };
19527
19528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19530 if (SWIG_arg_fail(1)) SWIG_fail;
19531 {
19532 arg2 = static_cast<int >(SWIG_As_int(obj1));
19533 if (SWIG_arg_fail(2)) SWIG_fail;
19534 }
19535 if (arg1) (arg1)->m_x = arg2;
19536
19537 Py_INCREF(Py_None); resultobj = Py_None;
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19545 PyObject *resultobj = NULL;
19546 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19547 int result;
19548 PyObject * obj0 = 0 ;
19549 char *kwnames[] = {
19550 (char *) "self", NULL
19551 };
19552
19553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19555 if (SWIG_arg_fail(1)) SWIG_fail;
19556 result = (int) ((arg1)->m_x);
19557
19558 {
19559 resultobj = SWIG_From_int(static_cast<int >(result));
19560 }
19561 return resultobj;
19562 fail:
19563 return NULL;
19564 }
19565
19566
19567 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj = NULL;
19569 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19570 int arg2 ;
19571 PyObject * obj0 = 0 ;
19572 PyObject * obj1 = 0 ;
19573 char *kwnames[] = {
19574 (char *) "self",(char *) "m_y", NULL
19575 };
19576
19577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19579 if (SWIG_arg_fail(1)) SWIG_fail;
19580 {
19581 arg2 = static_cast<int >(SWIG_As_int(obj1));
19582 if (SWIG_arg_fail(2)) SWIG_fail;
19583 }
19584 if (arg1) (arg1)->m_y = arg2;
19585
19586 Py_INCREF(Py_None); resultobj = Py_None;
19587 return resultobj;
19588 fail:
19589 return NULL;
19590 }
19591
19592
19593 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19594 PyObject *resultobj = NULL;
19595 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19596 int result;
19597 PyObject * obj0 = 0 ;
19598 char *kwnames[] = {
19599 (char *) "self", NULL
19600 };
19601
19602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19604 if (SWIG_arg_fail(1)) SWIG_fail;
19605 result = (int) ((arg1)->m_y);
19606
19607 {
19608 resultobj = SWIG_From_int(static_cast<int >(result));
19609 }
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19617 PyObject *resultobj = NULL;
19618 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19619 long arg2 ;
19620 PyObject * obj0 = 0 ;
19621 PyObject * obj1 = 0 ;
19622 char *kwnames[] = {
19623 (char *) "self",(char *) "m_keyCode", NULL
19624 };
19625
19626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19628 if (SWIG_arg_fail(1)) SWIG_fail;
19629 {
19630 arg2 = static_cast<long >(SWIG_As_long(obj1));
19631 if (SWIG_arg_fail(2)) SWIG_fail;
19632 }
19633 if (arg1) (arg1)->m_keyCode = arg2;
19634
19635 Py_INCREF(Py_None); resultobj = Py_None;
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19643 PyObject *resultobj = NULL;
19644 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19645 long result;
19646 PyObject * obj0 = 0 ;
19647 char *kwnames[] = {
19648 (char *) "self", NULL
19649 };
19650
19651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19653 if (SWIG_arg_fail(1)) SWIG_fail;
19654 result = (long) ((arg1)->m_keyCode);
19655
19656 {
19657 resultobj = SWIG_From_long(static_cast<long >(result));
19658 }
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj = NULL;
19667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19668 bool arg2 ;
19669 PyObject * obj0 = 0 ;
19670 PyObject * obj1 = 0 ;
19671 char *kwnames[] = {
19672 (char *) "self",(char *) "m_controlDown", NULL
19673 };
19674
19675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19677 if (SWIG_arg_fail(1)) SWIG_fail;
19678 {
19679 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19680 if (SWIG_arg_fail(2)) SWIG_fail;
19681 }
19682 if (arg1) (arg1)->m_controlDown = arg2;
19683
19684 Py_INCREF(Py_None); resultobj = Py_None;
19685 return resultobj;
19686 fail:
19687 return NULL;
19688 }
19689
19690
19691 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19692 PyObject *resultobj = NULL;
19693 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19694 bool result;
19695 PyObject * obj0 = 0 ;
19696 char *kwnames[] = {
19697 (char *) "self", NULL
19698 };
19699
19700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19702 if (SWIG_arg_fail(1)) SWIG_fail;
19703 result = (bool) ((arg1)->m_controlDown);
19704
19705 {
19706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19707 }
19708 return resultobj;
19709 fail:
19710 return NULL;
19711 }
19712
19713
19714 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19715 PyObject *resultobj = NULL;
19716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19717 bool arg2 ;
19718 PyObject * obj0 = 0 ;
19719 PyObject * obj1 = 0 ;
19720 char *kwnames[] = {
19721 (char *) "self",(char *) "m_shiftDown", NULL
19722 };
19723
19724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19726 if (SWIG_arg_fail(1)) SWIG_fail;
19727 {
19728 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19729 if (SWIG_arg_fail(2)) SWIG_fail;
19730 }
19731 if (arg1) (arg1)->m_shiftDown = arg2;
19732
19733 Py_INCREF(Py_None); resultobj = Py_None;
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19741 PyObject *resultobj = NULL;
19742 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19743 bool result;
19744 PyObject * obj0 = 0 ;
19745 char *kwnames[] = {
19746 (char *) "self", NULL
19747 };
19748
19749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19751 if (SWIG_arg_fail(1)) SWIG_fail;
19752 result = (bool) ((arg1)->m_shiftDown);
19753
19754 {
19755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19756 }
19757 return resultobj;
19758 fail:
19759 return NULL;
19760 }
19761
19762
19763 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19764 PyObject *resultobj = NULL;
19765 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19766 bool arg2 ;
19767 PyObject * obj0 = 0 ;
19768 PyObject * obj1 = 0 ;
19769 char *kwnames[] = {
19770 (char *) "self",(char *) "m_altDown", NULL
19771 };
19772
19773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19775 if (SWIG_arg_fail(1)) SWIG_fail;
19776 {
19777 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19778 if (SWIG_arg_fail(2)) SWIG_fail;
19779 }
19780 if (arg1) (arg1)->m_altDown = arg2;
19781
19782 Py_INCREF(Py_None); resultobj = Py_None;
19783 return resultobj;
19784 fail:
19785 return NULL;
19786 }
19787
19788
19789 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19790 PyObject *resultobj = NULL;
19791 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19792 bool result;
19793 PyObject * obj0 = 0 ;
19794 char *kwnames[] = {
19795 (char *) "self", NULL
19796 };
19797
19798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19800 if (SWIG_arg_fail(1)) SWIG_fail;
19801 result = (bool) ((arg1)->m_altDown);
19802
19803 {
19804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19805 }
19806 return resultobj;
19807 fail:
19808 return NULL;
19809 }
19810
19811
19812 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19813 PyObject *resultobj = NULL;
19814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19815 bool arg2 ;
19816 PyObject * obj0 = 0 ;
19817 PyObject * obj1 = 0 ;
19818 char *kwnames[] = {
19819 (char *) "self",(char *) "m_metaDown", NULL
19820 };
19821
19822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19824 if (SWIG_arg_fail(1)) SWIG_fail;
19825 {
19826 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19827 if (SWIG_arg_fail(2)) SWIG_fail;
19828 }
19829 if (arg1) (arg1)->m_metaDown = arg2;
19830
19831 Py_INCREF(Py_None); resultobj = Py_None;
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19839 PyObject *resultobj = NULL;
19840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19841 bool result;
19842 PyObject * obj0 = 0 ;
19843 char *kwnames[] = {
19844 (char *) "self", NULL
19845 };
19846
19847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19849 if (SWIG_arg_fail(1)) SWIG_fail;
19850 result = (bool) ((arg1)->m_metaDown);
19851
19852 {
19853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19854 }
19855 return resultobj;
19856 fail:
19857 return NULL;
19858 }
19859
19860
19861 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19862 PyObject *resultobj = NULL;
19863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19864 bool arg2 ;
19865 PyObject * obj0 = 0 ;
19866 PyObject * obj1 = 0 ;
19867 char *kwnames[] = {
19868 (char *) "self",(char *) "m_scanCode", NULL
19869 };
19870
19871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19873 if (SWIG_arg_fail(1)) SWIG_fail;
19874 {
19875 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19876 if (SWIG_arg_fail(2)) SWIG_fail;
19877 }
19878 if (arg1) (arg1)->m_scanCode = arg2;
19879
19880 Py_INCREF(Py_None); resultobj = Py_None;
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj = NULL;
19889 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19890 bool result;
19891 PyObject * obj0 = 0 ;
19892 char *kwnames[] = {
19893 (char *) "self", NULL
19894 };
19895
19896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19898 if (SWIG_arg_fail(1)) SWIG_fail;
19899 result = (bool) ((arg1)->m_scanCode);
19900
19901 {
19902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19903 }
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj = NULL;
19912 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19913 unsigned int arg2 ;
19914 PyObject * obj0 = 0 ;
19915 PyObject * obj1 = 0 ;
19916 char *kwnames[] = {
19917 (char *) "self",(char *) "m_rawCode", NULL
19918 };
19919
19920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19922 if (SWIG_arg_fail(1)) SWIG_fail;
19923 {
19924 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19925 if (SWIG_arg_fail(2)) SWIG_fail;
19926 }
19927 if (arg1) (arg1)->m_rawCode = arg2;
19928
19929 Py_INCREF(Py_None); resultobj = Py_None;
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj = NULL;
19938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19939 unsigned int result;
19940 PyObject * obj0 = 0 ;
19941 char *kwnames[] = {
19942 (char *) "self", NULL
19943 };
19944
19945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19947 if (SWIG_arg_fail(1)) SWIG_fail;
19948 result = (unsigned int) ((arg1)->m_rawCode);
19949
19950 {
19951 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19952 }
19953 return resultobj;
19954 fail:
19955 return NULL;
19956 }
19957
19958
19959 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19960 PyObject *resultobj = NULL;
19961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19962 unsigned int arg2 ;
19963 PyObject * obj0 = 0 ;
19964 PyObject * obj1 = 0 ;
19965 char *kwnames[] = {
19966 (char *) "self",(char *) "m_rawFlags", NULL
19967 };
19968
19969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19971 if (SWIG_arg_fail(1)) SWIG_fail;
19972 {
19973 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19974 if (SWIG_arg_fail(2)) SWIG_fail;
19975 }
19976 if (arg1) (arg1)->m_rawFlags = arg2;
19977
19978 Py_INCREF(Py_None); resultobj = Py_None;
19979 return resultobj;
19980 fail:
19981 return NULL;
19982 }
19983
19984
19985 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19986 PyObject *resultobj = NULL;
19987 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19988 unsigned int result;
19989 PyObject * obj0 = 0 ;
19990 char *kwnames[] = {
19991 (char *) "self", NULL
19992 };
19993
19994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19996 if (SWIG_arg_fail(1)) SWIG_fail;
19997 result = (unsigned int) ((arg1)->m_rawFlags);
19998
19999 {
20000 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20001 }
20002 return resultobj;
20003 fail:
20004 return NULL;
20005 }
20006
20007
20008 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20009 PyObject *obj;
20010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20011 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20012 Py_INCREF(obj);
20013 return Py_BuildValue((char *)"");
20014 }
20015 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20016 PyObject *resultobj = NULL;
20017 wxSize const &arg1_defvalue = wxDefaultSize ;
20018 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20019 int arg2 = (int) 0 ;
20020 wxSizeEvent *result;
20021 wxSize temp1 ;
20022 PyObject * obj0 = 0 ;
20023 PyObject * obj1 = 0 ;
20024 char *kwnames[] = {
20025 (char *) "sz",(char *) "winid", NULL
20026 };
20027
20028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20029 if (obj0) {
20030 {
20031 arg1 = &temp1;
20032 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20033 }
20034 }
20035 if (obj1) {
20036 {
20037 arg2 = static_cast<int >(SWIG_As_int(obj1));
20038 if (SWIG_arg_fail(2)) SWIG_fail;
20039 }
20040 }
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20044
20045 wxPyEndAllowThreads(__tstate);
20046 if (PyErr_Occurred()) SWIG_fail;
20047 }
20048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20049 return resultobj;
20050 fail:
20051 return NULL;
20052 }
20053
20054
20055 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20056 PyObject *resultobj = NULL;
20057 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20058 wxSize result;
20059 PyObject * obj0 = 0 ;
20060 char *kwnames[] = {
20061 (char *) "self", NULL
20062 };
20063
20064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20066 if (SWIG_arg_fail(1)) SWIG_fail;
20067 {
20068 PyThreadState* __tstate = wxPyBeginAllowThreads();
20069 result = ((wxSizeEvent const *)arg1)->GetSize();
20070
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 {
20075 wxSize * resultptr;
20076 resultptr = new wxSize(static_cast<wxSize & >(result));
20077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20078 }
20079 return resultobj;
20080 fail:
20081 return NULL;
20082 }
20083
20084
20085 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20086 PyObject *resultobj = NULL;
20087 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20088 wxRect result;
20089 PyObject * obj0 = 0 ;
20090 char *kwnames[] = {
20091 (char *) "self", NULL
20092 };
20093
20094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20096 if (SWIG_arg_fail(1)) SWIG_fail;
20097 {
20098 PyThreadState* __tstate = wxPyBeginAllowThreads();
20099 result = ((wxSizeEvent const *)arg1)->GetRect();
20100
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 {
20105 wxRect * resultptr;
20106 resultptr = new wxRect(static_cast<wxRect & >(result));
20107 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20108 }
20109 return resultobj;
20110 fail:
20111 return NULL;
20112 }
20113
20114
20115 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj = NULL;
20117 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20118 wxRect arg2 ;
20119 PyObject * obj0 = 0 ;
20120 PyObject * obj1 = 0 ;
20121 char *kwnames[] = {
20122 (char *) "self",(char *) "rect", NULL
20123 };
20124
20125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20127 if (SWIG_arg_fail(1)) SWIG_fail;
20128 {
20129 wxRect * argp;
20130 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20131 if (SWIG_arg_fail(2)) SWIG_fail;
20132 if (argp == NULL) {
20133 SWIG_null_ref("wxRect");
20134 }
20135 if (SWIG_arg_fail(2)) SWIG_fail;
20136 arg2 = *argp;
20137 }
20138 {
20139 PyThreadState* __tstate = wxPyBeginAllowThreads();
20140 (arg1)->SetRect(arg2);
20141
20142 wxPyEndAllowThreads(__tstate);
20143 if (PyErr_Occurred()) SWIG_fail;
20144 }
20145 Py_INCREF(Py_None); resultobj = Py_None;
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20153 PyObject *resultobj = NULL;
20154 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20155 wxSize arg2 ;
20156 PyObject * obj0 = 0 ;
20157 PyObject * obj1 = 0 ;
20158 char *kwnames[] = {
20159 (char *) "self",(char *) "size", NULL
20160 };
20161
20162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20164 if (SWIG_arg_fail(1)) SWIG_fail;
20165 {
20166 wxSize * argp;
20167 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20168 if (SWIG_arg_fail(2)) SWIG_fail;
20169 if (argp == NULL) {
20170 SWIG_null_ref("wxSize");
20171 }
20172 if (SWIG_arg_fail(2)) SWIG_fail;
20173 arg2 = *argp;
20174 }
20175 {
20176 PyThreadState* __tstate = wxPyBeginAllowThreads();
20177 wxSizeEvent_SetSize(arg1,arg2);
20178
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 Py_INCREF(Py_None); resultobj = Py_None;
20183 return resultobj;
20184 fail:
20185 return NULL;
20186 }
20187
20188
20189 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20190 PyObject *resultobj = NULL;
20191 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20192 wxSize *arg2 = (wxSize *) 0 ;
20193 PyObject * obj0 = 0 ;
20194 PyObject * obj1 = 0 ;
20195 char *kwnames[] = {
20196 (char *) "self",(char *) "m_size", NULL
20197 };
20198
20199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20201 if (SWIG_arg_fail(1)) SWIG_fail;
20202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20203 if (SWIG_arg_fail(2)) SWIG_fail;
20204 if (arg1) (arg1)->m_size = *arg2;
20205
20206 Py_INCREF(Py_None); resultobj = Py_None;
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20214 PyObject *resultobj = NULL;
20215 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20216 wxSize *result;
20217 PyObject * obj0 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "self", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20224 if (SWIG_arg_fail(1)) SWIG_fail;
20225 result = (wxSize *)& ((arg1)->m_size);
20226
20227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20235 PyObject *resultobj = NULL;
20236 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20237 wxRect *arg2 = (wxRect *) 0 ;
20238 PyObject * obj0 = 0 ;
20239 PyObject * obj1 = 0 ;
20240 char *kwnames[] = {
20241 (char *) "self",(char *) "m_rect", NULL
20242 };
20243
20244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20246 if (SWIG_arg_fail(1)) SWIG_fail;
20247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20248 if (SWIG_arg_fail(2)) SWIG_fail;
20249 if (arg1) (arg1)->m_rect = *arg2;
20250
20251 Py_INCREF(Py_None); resultobj = Py_None;
20252 return resultobj;
20253 fail:
20254 return NULL;
20255 }
20256
20257
20258 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20259 PyObject *resultobj = NULL;
20260 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20261 wxRect *result;
20262 PyObject * obj0 = 0 ;
20263 char *kwnames[] = {
20264 (char *) "self", NULL
20265 };
20266
20267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20269 if (SWIG_arg_fail(1)) SWIG_fail;
20270 result = (wxRect *)& ((arg1)->m_rect);
20271
20272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20280 PyObject *obj;
20281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20282 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20283 Py_INCREF(obj);
20284 return Py_BuildValue((char *)"");
20285 }
20286 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20287 PyObject *resultobj = NULL;
20288 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20289 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20290 int arg2 = (int) 0 ;
20291 wxMoveEvent *result;
20292 wxPoint temp1 ;
20293 PyObject * obj0 = 0 ;
20294 PyObject * obj1 = 0 ;
20295 char *kwnames[] = {
20296 (char *) "pos",(char *) "winid", NULL
20297 };
20298
20299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20300 if (obj0) {
20301 {
20302 arg1 = &temp1;
20303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20304 }
20305 }
20306 if (obj1) {
20307 {
20308 arg2 = static_cast<int >(SWIG_As_int(obj1));
20309 if (SWIG_arg_fail(2)) SWIG_fail;
20310 }
20311 }
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20315
20316 wxPyEndAllowThreads(__tstate);
20317 if (PyErr_Occurred()) SWIG_fail;
20318 }
20319 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20320 return resultobj;
20321 fail:
20322 return NULL;
20323 }
20324
20325
20326 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20327 PyObject *resultobj = NULL;
20328 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20329 wxPoint result;
20330 PyObject * obj0 = 0 ;
20331 char *kwnames[] = {
20332 (char *) "self", NULL
20333 };
20334
20335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20337 if (SWIG_arg_fail(1)) SWIG_fail;
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = ((wxMoveEvent const *)arg1)->GetPosition();
20341
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 {
20346 wxPoint * resultptr;
20347 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20349 }
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20357 PyObject *resultobj = NULL;
20358 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20359 wxRect result;
20360 PyObject * obj0 = 0 ;
20361 char *kwnames[] = {
20362 (char *) "self", NULL
20363 };
20364
20365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20367 if (SWIG_arg_fail(1)) SWIG_fail;
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 result = ((wxMoveEvent const *)arg1)->GetRect();
20371
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 {
20376 wxRect * resultptr;
20377 resultptr = new wxRect(static_cast<wxRect & >(result));
20378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20379 }
20380 return resultobj;
20381 fail:
20382 return NULL;
20383 }
20384
20385
20386 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20387 PyObject *resultobj = NULL;
20388 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20389 wxRect *arg2 = 0 ;
20390 wxRect temp2 ;
20391 PyObject * obj0 = 0 ;
20392 PyObject * obj1 = 0 ;
20393 char *kwnames[] = {
20394 (char *) "self",(char *) "rect", NULL
20395 };
20396
20397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20399 if (SWIG_arg_fail(1)) SWIG_fail;
20400 {
20401 arg2 = &temp2;
20402 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20403 }
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 (arg1)->SetRect((wxRect const &)*arg2);
20407
20408 wxPyEndAllowThreads(__tstate);
20409 if (PyErr_Occurred()) SWIG_fail;
20410 }
20411 Py_INCREF(Py_None); resultobj = Py_None;
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20419 PyObject *resultobj = NULL;
20420 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20421 wxPoint *arg2 = 0 ;
20422 wxPoint temp2 ;
20423 PyObject * obj0 = 0 ;
20424 PyObject * obj1 = 0 ;
20425 char *kwnames[] = {
20426 (char *) "self",(char *) "pos", NULL
20427 };
20428
20429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20431 if (SWIG_arg_fail(1)) SWIG_fail;
20432 {
20433 arg2 = &temp2;
20434 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20435 }
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 (arg1)->SetPosition((wxPoint const &)*arg2);
20439
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 Py_INCREF(Py_None); resultobj = Py_None;
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20451 PyObject *obj;
20452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20453 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20454 Py_INCREF(obj);
20455 return Py_BuildValue((char *)"");
20456 }
20457 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj = NULL;
20459 int arg1 = (int) 0 ;
20460 wxPaintEvent *result;
20461 PyObject * obj0 = 0 ;
20462 char *kwnames[] = {
20463 (char *) "Id", NULL
20464 };
20465
20466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20467 if (obj0) {
20468 {
20469 arg1 = static_cast<int >(SWIG_As_int(obj0));
20470 if (SWIG_arg_fail(1)) SWIG_fail;
20471 }
20472 }
20473 {
20474 PyThreadState* __tstate = wxPyBeginAllowThreads();
20475 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20476
20477 wxPyEndAllowThreads(__tstate);
20478 if (PyErr_Occurred()) SWIG_fail;
20479 }
20480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20481 return resultobj;
20482 fail:
20483 return NULL;
20484 }
20485
20486
20487 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20488 PyObject *obj;
20489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20490 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20491 Py_INCREF(obj);
20492 return Py_BuildValue((char *)"");
20493 }
20494 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj = NULL;
20496 int arg1 = (int) 0 ;
20497 wxNcPaintEvent *result;
20498 PyObject * obj0 = 0 ;
20499 char *kwnames[] = {
20500 (char *) "winid", NULL
20501 };
20502
20503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20504 if (obj0) {
20505 {
20506 arg1 = static_cast<int >(SWIG_As_int(obj0));
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 }
20509 }
20510 {
20511 PyThreadState* __tstate = wxPyBeginAllowThreads();
20512 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20513
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20525 PyObject *obj;
20526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20527 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20528 Py_INCREF(obj);
20529 return Py_BuildValue((char *)"");
20530 }
20531 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj = NULL;
20533 int arg1 = (int) 0 ;
20534 wxDC *arg2 = (wxDC *) NULL ;
20535 wxEraseEvent *result;
20536 PyObject * obj0 = 0 ;
20537 PyObject * obj1 = 0 ;
20538 char *kwnames[] = {
20539 (char *) "Id",(char *) "dc", NULL
20540 };
20541
20542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) 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 if (obj1) {
20550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20551 if (SWIG_arg_fail(2)) SWIG_fail;
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20556
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj = NULL;
20569 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20570 wxDC *result;
20571 PyObject * obj0 = 0 ;
20572 char *kwnames[] = {
20573 (char *) "self", NULL
20574 };
20575
20576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20582
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = wxPyMake_wxObject(result, 0);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20596 PyObject *obj;
20597 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20598 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20599 Py_INCREF(obj);
20600 return Py_BuildValue((char *)"");
20601 }
20602 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20603 PyObject *resultobj = NULL;
20604 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20605 int arg2 = (int) 0 ;
20606 wxFocusEvent *result;
20607 PyObject * obj0 = 0 ;
20608 PyObject * obj1 = 0 ;
20609 char *kwnames[] = {
20610 (char *) "type",(char *) "winid", NULL
20611 };
20612
20613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20614 if (obj0) {
20615 {
20616 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20617 if (SWIG_arg_fail(1)) SWIG_fail;
20618 }
20619 }
20620 if (obj1) {
20621 {
20622 arg2 = static_cast<int >(SWIG_As_int(obj1));
20623 if (SWIG_arg_fail(2)) SWIG_fail;
20624 }
20625 }
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20629
20630 wxPyEndAllowThreads(__tstate);
20631 if (PyErr_Occurred()) SWIG_fail;
20632 }
20633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20634 return resultobj;
20635 fail:
20636 return NULL;
20637 }
20638
20639
20640 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20641 PyObject *resultobj = NULL;
20642 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20643 wxWindow *result;
20644 PyObject * obj0 = 0 ;
20645 char *kwnames[] = {
20646 (char *) "self", NULL
20647 };
20648
20649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20651 if (SWIG_arg_fail(1)) SWIG_fail;
20652 {
20653 PyThreadState* __tstate = wxPyBeginAllowThreads();
20654 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20655
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 {
20660 resultobj = wxPyMake_wxObject(result, 0);
20661 }
20662 return resultobj;
20663 fail:
20664 return NULL;
20665 }
20666
20667
20668 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj = NULL;
20670 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20671 wxWindow *arg2 = (wxWindow *) 0 ;
20672 PyObject * obj0 = 0 ;
20673 PyObject * obj1 = 0 ;
20674 char *kwnames[] = {
20675 (char *) "self",(char *) "win", NULL
20676 };
20677
20678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20680 if (SWIG_arg_fail(1)) SWIG_fail;
20681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20682 if (SWIG_arg_fail(2)) SWIG_fail;
20683 {
20684 PyThreadState* __tstate = wxPyBeginAllowThreads();
20685 (arg1)->SetWindow(arg2);
20686
20687 wxPyEndAllowThreads(__tstate);
20688 if (PyErr_Occurred()) SWIG_fail;
20689 }
20690 Py_INCREF(Py_None); resultobj = Py_None;
20691 return resultobj;
20692 fail:
20693 return NULL;
20694 }
20695
20696
20697 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20698 PyObject *obj;
20699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20700 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20701 Py_INCREF(obj);
20702 return Py_BuildValue((char *)"");
20703 }
20704 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20705 PyObject *resultobj = NULL;
20706 wxWindow *arg1 = (wxWindow *) NULL ;
20707 wxChildFocusEvent *result;
20708 PyObject * obj0 = 0 ;
20709 char *kwnames[] = {
20710 (char *) "win", NULL
20711 };
20712
20713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20714 if (obj0) {
20715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20716 if (SWIG_arg_fail(1)) SWIG_fail;
20717 }
20718 {
20719 PyThreadState* __tstate = wxPyBeginAllowThreads();
20720 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20721
20722 wxPyEndAllowThreads(__tstate);
20723 if (PyErr_Occurred()) SWIG_fail;
20724 }
20725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20726 return resultobj;
20727 fail:
20728 return NULL;
20729 }
20730
20731
20732 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20733 PyObject *resultobj = NULL;
20734 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20735 wxWindow *result;
20736 PyObject * obj0 = 0 ;
20737 char *kwnames[] = {
20738 (char *) "self", NULL
20739 };
20740
20741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20743 if (SWIG_arg_fail(1)) SWIG_fail;
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20747
20748 wxPyEndAllowThreads(__tstate);
20749 if (PyErr_Occurred()) SWIG_fail;
20750 }
20751 {
20752 resultobj = wxPyMake_wxObject(result, 0);
20753 }
20754 return resultobj;
20755 fail:
20756 return NULL;
20757 }
20758
20759
20760 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20761 PyObject *obj;
20762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20763 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20764 Py_INCREF(obj);
20765 return Py_BuildValue((char *)"");
20766 }
20767 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj = NULL;
20769 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20770 bool arg2 = (bool) true ;
20771 int arg3 = (int) 0 ;
20772 wxActivateEvent *result;
20773 PyObject * obj0 = 0 ;
20774 PyObject * obj1 = 0 ;
20775 PyObject * obj2 = 0 ;
20776 char *kwnames[] = {
20777 (char *) "type",(char *) "active",(char *) "Id", NULL
20778 };
20779
20780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20781 if (obj0) {
20782 {
20783 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20784 if (SWIG_arg_fail(1)) SWIG_fail;
20785 }
20786 }
20787 if (obj1) {
20788 {
20789 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20790 if (SWIG_arg_fail(2)) SWIG_fail;
20791 }
20792 }
20793 if (obj2) {
20794 {
20795 arg3 = static_cast<int >(SWIG_As_int(obj2));
20796 if (SWIG_arg_fail(3)) SWIG_fail;
20797 }
20798 }
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj = NULL;
20815 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20816 bool result;
20817 PyObject * obj0 = 0 ;
20818 char *kwnames[] = {
20819 (char *) "self", NULL
20820 };
20821
20822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20824 if (SWIG_arg_fail(1)) SWIG_fail;
20825 {
20826 PyThreadState* __tstate = wxPyBeginAllowThreads();
20827 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20828
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 {
20833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20834 }
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20842 PyObject *obj;
20843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20844 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20845 Py_INCREF(obj);
20846 return Py_BuildValue((char *)"");
20847 }
20848 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj = NULL;
20850 int arg1 = (int) 0 ;
20851 wxInitDialogEvent *result;
20852 PyObject * obj0 = 0 ;
20853 char *kwnames[] = {
20854 (char *) "Id", NULL
20855 };
20856
20857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20858 if (obj0) {
20859 {
20860 arg1 = static_cast<int >(SWIG_As_int(obj0));
20861 if (SWIG_arg_fail(1)) SWIG_fail;
20862 }
20863 }
20864 {
20865 PyThreadState* __tstate = wxPyBeginAllowThreads();
20866 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20867
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20879 PyObject *obj;
20880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20881 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20882 Py_INCREF(obj);
20883 return Py_BuildValue((char *)"");
20884 }
20885 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20886 PyObject *resultobj = NULL;
20887 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20888 int arg2 = (int) 0 ;
20889 wxMenu *arg3 = (wxMenu *) NULL ;
20890 wxMenuEvent *result;
20891 PyObject * obj0 = 0 ;
20892 PyObject * obj1 = 0 ;
20893 PyObject * obj2 = 0 ;
20894 char *kwnames[] = {
20895 (char *) "type",(char *) "winid",(char *) "menu", NULL
20896 };
20897
20898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20899 if (obj0) {
20900 {
20901 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20902 if (SWIG_arg_fail(1)) SWIG_fail;
20903 }
20904 }
20905 if (obj1) {
20906 {
20907 arg2 = static_cast<int >(SWIG_As_int(obj1));
20908 if (SWIG_arg_fail(2)) SWIG_fail;
20909 }
20910 }
20911 if (obj2) {
20912 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20913 if (SWIG_arg_fail(3)) SWIG_fail;
20914 }
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20918
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj = NULL;
20931 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20932 int result;
20933 PyObject * obj0 = 0 ;
20934 char *kwnames[] = {
20935 (char *) "self", NULL
20936 };
20937
20938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20940 if (SWIG_arg_fail(1)) SWIG_fail;
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20944
20945 wxPyEndAllowThreads(__tstate);
20946 if (PyErr_Occurred()) SWIG_fail;
20947 }
20948 {
20949 resultobj = SWIG_From_int(static_cast<int >(result));
20950 }
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj = NULL;
20959 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20960 bool result;
20961 PyObject * obj0 = 0 ;
20962 char *kwnames[] = {
20963 (char *) "self", NULL
20964 };
20965
20966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20968 if (SWIG_arg_fail(1)) SWIG_fail;
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20972
20973 wxPyEndAllowThreads(__tstate);
20974 if (PyErr_Occurred()) SWIG_fail;
20975 }
20976 {
20977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20978 }
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20986 PyObject *resultobj = NULL;
20987 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20988 wxMenu *result;
20989 PyObject * obj0 = 0 ;
20990 char *kwnames[] = {
20991 (char *) "self", NULL
20992 };
20993
20994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20996 if (SWIG_arg_fail(1)) SWIG_fail;
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
21000
21001 wxPyEndAllowThreads(__tstate);
21002 if (PyErr_Occurred()) SWIG_fail;
21003 }
21004 {
21005 resultobj = wxPyMake_wxObject(result, 0);
21006 }
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21014 PyObject *obj;
21015 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21016 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21017 Py_INCREF(obj);
21018 return Py_BuildValue((char *)"");
21019 }
21020 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21021 PyObject *resultobj = NULL;
21022 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21023 int arg2 = (int) 0 ;
21024 wxCloseEvent *result;
21025 PyObject * obj0 = 0 ;
21026 PyObject * obj1 = 0 ;
21027 char *kwnames[] = {
21028 (char *) "type",(char *) "winid", NULL
21029 };
21030
21031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21032 if (obj0) {
21033 {
21034 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21035 if (SWIG_arg_fail(1)) SWIG_fail;
21036 }
21037 }
21038 if (obj1) {
21039 {
21040 arg2 = static_cast<int >(SWIG_As_int(obj1));
21041 if (SWIG_arg_fail(2)) SWIG_fail;
21042 }
21043 }
21044 {
21045 PyThreadState* __tstate = wxPyBeginAllowThreads();
21046 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21047
21048 wxPyEndAllowThreads(__tstate);
21049 if (PyErr_Occurred()) SWIG_fail;
21050 }
21051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21059 PyObject *resultobj = NULL;
21060 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21061 bool arg2 ;
21062 PyObject * obj0 = 0 ;
21063 PyObject * obj1 = 0 ;
21064 char *kwnames[] = {
21065 (char *) "self",(char *) "logOff", NULL
21066 };
21067
21068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21070 if (SWIG_arg_fail(1)) SWIG_fail;
21071 {
21072 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21073 if (SWIG_arg_fail(2)) SWIG_fail;
21074 }
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 (arg1)->SetLoggingOff(arg2);
21078
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 Py_INCREF(Py_None); resultobj = Py_None;
21083 return resultobj;
21084 fail:
21085 return NULL;
21086 }
21087
21088
21089 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj = NULL;
21091 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21092 bool result;
21093 PyObject * obj0 = 0 ;
21094 char *kwnames[] = {
21095 (char *) "self", NULL
21096 };
21097
21098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21100 if (SWIG_arg_fail(1)) SWIG_fail;
21101 {
21102 PyThreadState* __tstate = wxPyBeginAllowThreads();
21103 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21104
21105 wxPyEndAllowThreads(__tstate);
21106 if (PyErr_Occurred()) SWIG_fail;
21107 }
21108 {
21109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21110 }
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21118 PyObject *resultobj = NULL;
21119 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21120 bool arg2 = (bool) true ;
21121 PyObject * obj0 = 0 ;
21122 PyObject * obj1 = 0 ;
21123 char *kwnames[] = {
21124 (char *) "self",(char *) "veto", NULL
21125 };
21126
21127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21129 if (SWIG_arg_fail(1)) SWIG_fail;
21130 if (obj1) {
21131 {
21132 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21133 if (SWIG_arg_fail(2)) SWIG_fail;
21134 }
21135 }
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 (arg1)->Veto(arg2);
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 Py_INCREF(Py_None); resultobj = Py_None;
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21151 PyObject *resultobj = NULL;
21152 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21153 bool result;
21154 PyObject * obj0 = 0 ;
21155 char *kwnames[] = {
21156 (char *) "self", NULL
21157 };
21158
21159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21161 if (SWIG_arg_fail(1)) SWIG_fail;
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21165
21166 wxPyEndAllowThreads(__tstate);
21167 if (PyErr_Occurred()) SWIG_fail;
21168 }
21169 {
21170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21171 }
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21179 PyObject *resultobj = NULL;
21180 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21181 bool arg2 ;
21182 PyObject * obj0 = 0 ;
21183 PyObject * obj1 = 0 ;
21184 char *kwnames[] = {
21185 (char *) "self",(char *) "canVeto", NULL
21186 };
21187
21188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21190 if (SWIG_arg_fail(1)) SWIG_fail;
21191 {
21192 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21193 if (SWIG_arg_fail(2)) SWIG_fail;
21194 }
21195 {
21196 PyThreadState* __tstate = wxPyBeginAllowThreads();
21197 (arg1)->SetCanVeto(arg2);
21198
21199 wxPyEndAllowThreads(__tstate);
21200 if (PyErr_Occurred()) SWIG_fail;
21201 }
21202 Py_INCREF(Py_None); resultobj = Py_None;
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21210 PyObject *resultobj = NULL;
21211 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21212 bool result;
21213 PyObject * obj0 = 0 ;
21214 char *kwnames[] = {
21215 (char *) "self", NULL
21216 };
21217
21218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21220 if (SWIG_arg_fail(1)) SWIG_fail;
21221 {
21222 PyThreadState* __tstate = wxPyBeginAllowThreads();
21223 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21224
21225 wxPyEndAllowThreads(__tstate);
21226 if (PyErr_Occurred()) SWIG_fail;
21227 }
21228 {
21229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21230 }
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21238 PyObject *obj;
21239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21240 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21241 Py_INCREF(obj);
21242 return Py_BuildValue((char *)"");
21243 }
21244 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj = NULL;
21246 int arg1 = (int) 0 ;
21247 bool arg2 = (bool) false ;
21248 wxShowEvent *result;
21249 PyObject * obj0 = 0 ;
21250 PyObject * obj1 = 0 ;
21251 char *kwnames[] = {
21252 (char *) "winid",(char *) "show", NULL
21253 };
21254
21255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21256 if (obj0) {
21257 {
21258 arg1 = static_cast<int >(SWIG_As_int(obj0));
21259 if (SWIG_arg_fail(1)) SWIG_fail;
21260 }
21261 }
21262 if (obj1) {
21263 {
21264 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21265 if (SWIG_arg_fail(2)) SWIG_fail;
21266 }
21267 }
21268 {
21269 PyThreadState* __tstate = wxPyBeginAllowThreads();
21270 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21271
21272 wxPyEndAllowThreads(__tstate);
21273 if (PyErr_Occurred()) SWIG_fail;
21274 }
21275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21276 return resultobj;
21277 fail:
21278 return NULL;
21279 }
21280
21281
21282 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21283 PyObject *resultobj = NULL;
21284 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21285 bool arg2 ;
21286 PyObject * obj0 = 0 ;
21287 PyObject * obj1 = 0 ;
21288 char *kwnames[] = {
21289 (char *) "self",(char *) "show", NULL
21290 };
21291
21292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21294 if (SWIG_arg_fail(1)) SWIG_fail;
21295 {
21296 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21297 if (SWIG_arg_fail(2)) SWIG_fail;
21298 }
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 (arg1)->SetShow(arg2);
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 Py_INCREF(Py_None); resultobj = Py_None;
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21314 PyObject *resultobj = NULL;
21315 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21316 bool result;
21317 PyObject * obj0 = 0 ;
21318 char *kwnames[] = {
21319 (char *) "self", NULL
21320 };
21321
21322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21324 if (SWIG_arg_fail(1)) SWIG_fail;
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21328
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 {
21333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21334 }
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21342 PyObject *obj;
21343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21344 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21345 Py_INCREF(obj);
21346 return Py_BuildValue((char *)"");
21347 }
21348 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21349 PyObject *resultobj = NULL;
21350 int arg1 = (int) 0 ;
21351 bool arg2 = (bool) true ;
21352 wxIconizeEvent *result;
21353 PyObject * obj0 = 0 ;
21354 PyObject * obj1 = 0 ;
21355 char *kwnames[] = {
21356 (char *) "id",(char *) "iconized", NULL
21357 };
21358
21359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21360 if (obj0) {
21361 {
21362 arg1 = static_cast<int >(SWIG_As_int(obj0));
21363 if (SWIG_arg_fail(1)) SWIG_fail;
21364 }
21365 }
21366 if (obj1) {
21367 {
21368 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21369 if (SWIG_arg_fail(2)) SWIG_fail;
21370 }
21371 }
21372 {
21373 PyThreadState* __tstate = wxPyBeginAllowThreads();
21374 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21375
21376 wxPyEndAllowThreads(__tstate);
21377 if (PyErr_Occurred()) SWIG_fail;
21378 }
21379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21380 return resultobj;
21381 fail:
21382 return NULL;
21383 }
21384
21385
21386 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21387 PyObject *resultobj = NULL;
21388 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21389 bool result;
21390 PyObject * obj0 = 0 ;
21391 char *kwnames[] = {
21392 (char *) "self", NULL
21393 };
21394
21395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21397 if (SWIG_arg_fail(1)) SWIG_fail;
21398 {
21399 PyThreadState* __tstate = wxPyBeginAllowThreads();
21400 result = (bool)(arg1)->Iconized();
21401
21402 wxPyEndAllowThreads(__tstate);
21403 if (PyErr_Occurred()) SWIG_fail;
21404 }
21405 {
21406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21407 }
21408 return resultobj;
21409 fail:
21410 return NULL;
21411 }
21412
21413
21414 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21415 PyObject *obj;
21416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21417 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21418 Py_INCREF(obj);
21419 return Py_BuildValue((char *)"");
21420 }
21421 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21422 PyObject *resultobj = NULL;
21423 int arg1 = (int) 0 ;
21424 wxMaximizeEvent *result;
21425 PyObject * obj0 = 0 ;
21426 char *kwnames[] = {
21427 (char *) "id", NULL
21428 };
21429
21430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21431 if (obj0) {
21432 {
21433 arg1 = static_cast<int >(SWIG_As_int(obj0));
21434 if (SWIG_arg_fail(1)) SWIG_fail;
21435 }
21436 }
21437 {
21438 PyThreadState* __tstate = wxPyBeginAllowThreads();
21439 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21440
21441 wxPyEndAllowThreads(__tstate);
21442 if (PyErr_Occurred()) SWIG_fail;
21443 }
21444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21445 return resultobj;
21446 fail:
21447 return NULL;
21448 }
21449
21450
21451 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21452 PyObject *obj;
21453 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21454 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21455 Py_INCREF(obj);
21456 return Py_BuildValue((char *)"");
21457 }
21458 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21459 PyObject *resultobj = NULL;
21460 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21461 wxPoint result;
21462 PyObject * obj0 = 0 ;
21463 char *kwnames[] = {
21464 (char *) "self", NULL
21465 };
21466
21467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21469 if (SWIG_arg_fail(1)) SWIG_fail;
21470 {
21471 PyThreadState* __tstate = wxPyBeginAllowThreads();
21472 result = (arg1)->GetPosition();
21473
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 {
21478 wxPoint * resultptr;
21479 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21481 }
21482 return resultobj;
21483 fail:
21484 return NULL;
21485 }
21486
21487
21488 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21489 PyObject *resultobj = NULL;
21490 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21491 int result;
21492 PyObject * obj0 = 0 ;
21493 char *kwnames[] = {
21494 (char *) "self", NULL
21495 };
21496
21497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21499 if (SWIG_arg_fail(1)) SWIG_fail;
21500 {
21501 PyThreadState* __tstate = wxPyBeginAllowThreads();
21502 result = (int)(arg1)->GetNumberOfFiles();
21503
21504 wxPyEndAllowThreads(__tstate);
21505 if (PyErr_Occurred()) SWIG_fail;
21506 }
21507 {
21508 resultobj = SWIG_From_int(static_cast<int >(result));
21509 }
21510 return resultobj;
21511 fail:
21512 return NULL;
21513 }
21514
21515
21516 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21517 PyObject *resultobj = NULL;
21518 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21519 PyObject *result;
21520 PyObject * obj0 = 0 ;
21521 char *kwnames[] = {
21522 (char *) "self", NULL
21523 };
21524
21525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21527 if (SWIG_arg_fail(1)) SWIG_fail;
21528 {
21529 PyThreadState* __tstate = wxPyBeginAllowThreads();
21530 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21531
21532 wxPyEndAllowThreads(__tstate);
21533 if (PyErr_Occurred()) SWIG_fail;
21534 }
21535 resultobj = result;
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21543 PyObject *obj;
21544 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21545 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21546 Py_INCREF(obj);
21547 return Py_BuildValue((char *)"");
21548 }
21549 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21550 PyObject *resultobj = NULL;
21551 int arg1 = (int) 0 ;
21552 wxUpdateUIEvent *result;
21553 PyObject * obj0 = 0 ;
21554 char *kwnames[] = {
21555 (char *) "commandId", NULL
21556 };
21557
21558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21559 if (obj0) {
21560 {
21561 arg1 = static_cast<int >(SWIG_As_int(obj0));
21562 if (SWIG_arg_fail(1)) SWIG_fail;
21563 }
21564 }
21565 {
21566 PyThreadState* __tstate = wxPyBeginAllowThreads();
21567 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21568
21569 wxPyEndAllowThreads(__tstate);
21570 if (PyErr_Occurred()) SWIG_fail;
21571 }
21572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21573 return resultobj;
21574 fail:
21575 return NULL;
21576 }
21577
21578
21579 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21580 PyObject *resultobj = NULL;
21581 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21582 bool result;
21583 PyObject * obj0 = 0 ;
21584 char *kwnames[] = {
21585 (char *) "self", NULL
21586 };
21587
21588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21590 if (SWIG_arg_fail(1)) SWIG_fail;
21591 {
21592 PyThreadState* __tstate = wxPyBeginAllowThreads();
21593 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21594
21595 wxPyEndAllowThreads(__tstate);
21596 if (PyErr_Occurred()) SWIG_fail;
21597 }
21598 {
21599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21600 }
21601 return resultobj;
21602 fail:
21603 return NULL;
21604 }
21605
21606
21607 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21608 PyObject *resultobj = NULL;
21609 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21610 bool result;
21611 PyObject * obj0 = 0 ;
21612 char *kwnames[] = {
21613 (char *) "self", NULL
21614 };
21615
21616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21618 if (SWIG_arg_fail(1)) SWIG_fail;
21619 {
21620 PyThreadState* __tstate = wxPyBeginAllowThreads();
21621 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21622
21623 wxPyEndAllowThreads(__tstate);
21624 if (PyErr_Occurred()) SWIG_fail;
21625 }
21626 {
21627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21628 }
21629 return resultobj;
21630 fail:
21631 return NULL;
21632 }
21633
21634
21635 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21636 PyObject *resultobj = NULL;
21637 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21638 wxString result;
21639 PyObject * obj0 = 0 ;
21640 char *kwnames[] = {
21641 (char *) "self", NULL
21642 };
21643
21644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21646 if (SWIG_arg_fail(1)) SWIG_fail;
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21650
21651 wxPyEndAllowThreads(__tstate);
21652 if (PyErr_Occurred()) SWIG_fail;
21653 }
21654 {
21655 #if wxUSE_UNICODE
21656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21657 #else
21658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21659 #endif
21660 }
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj = NULL;
21669 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21670 bool result;
21671 PyObject * obj0 = 0 ;
21672 char *kwnames[] = {
21673 (char *) "self", NULL
21674 };
21675
21676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21678 if (SWIG_arg_fail(1)) SWIG_fail;
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21682
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 {
21687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21688 }
21689 return resultobj;
21690 fail:
21691 return NULL;
21692 }
21693
21694
21695 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21696 PyObject *resultobj = NULL;
21697 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21698 bool result;
21699 PyObject * obj0 = 0 ;
21700 char *kwnames[] = {
21701 (char *) "self", NULL
21702 };
21703
21704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21706 if (SWIG_arg_fail(1)) SWIG_fail;
21707 {
21708 PyThreadState* __tstate = wxPyBeginAllowThreads();
21709 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21710
21711 wxPyEndAllowThreads(__tstate);
21712 if (PyErr_Occurred()) SWIG_fail;
21713 }
21714 {
21715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21716 }
21717 return resultobj;
21718 fail:
21719 return NULL;
21720 }
21721
21722
21723 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21724 PyObject *resultobj = NULL;
21725 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21726 bool result;
21727 PyObject * obj0 = 0 ;
21728 char *kwnames[] = {
21729 (char *) "self", NULL
21730 };
21731
21732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21734 if (SWIG_arg_fail(1)) SWIG_fail;
21735 {
21736 PyThreadState* __tstate = wxPyBeginAllowThreads();
21737 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21738
21739 wxPyEndAllowThreads(__tstate);
21740 if (PyErr_Occurred()) SWIG_fail;
21741 }
21742 {
21743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21744 }
21745 return resultobj;
21746 fail:
21747 return NULL;
21748 }
21749
21750
21751 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj = NULL;
21753 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21754 bool arg2 ;
21755 PyObject * obj0 = 0 ;
21756 PyObject * obj1 = 0 ;
21757 char *kwnames[] = {
21758 (char *) "self",(char *) "check", NULL
21759 };
21760
21761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21763 if (SWIG_arg_fail(1)) SWIG_fail;
21764 {
21765 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21766 if (SWIG_arg_fail(2)) SWIG_fail;
21767 }
21768 {
21769 PyThreadState* __tstate = wxPyBeginAllowThreads();
21770 (arg1)->Check(arg2);
21771
21772 wxPyEndAllowThreads(__tstate);
21773 if (PyErr_Occurred()) SWIG_fail;
21774 }
21775 Py_INCREF(Py_None); resultobj = Py_None;
21776 return resultobj;
21777 fail:
21778 return NULL;
21779 }
21780
21781
21782 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21783 PyObject *resultobj = NULL;
21784 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21785 bool arg2 ;
21786 PyObject * obj0 = 0 ;
21787 PyObject * obj1 = 0 ;
21788 char *kwnames[] = {
21789 (char *) "self",(char *) "enable", NULL
21790 };
21791
21792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21794 if (SWIG_arg_fail(1)) SWIG_fail;
21795 {
21796 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21797 if (SWIG_arg_fail(2)) SWIG_fail;
21798 }
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 (arg1)->Enable(arg2);
21802
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 Py_INCREF(Py_None); resultobj = Py_None;
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21814 PyObject *resultobj = NULL;
21815 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21816 wxString *arg2 = 0 ;
21817 bool temp2 = false ;
21818 PyObject * obj0 = 0 ;
21819 PyObject * obj1 = 0 ;
21820 char *kwnames[] = {
21821 (char *) "self",(char *) "text", NULL
21822 };
21823
21824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21826 if (SWIG_arg_fail(1)) SWIG_fail;
21827 {
21828 arg2 = wxString_in_helper(obj1);
21829 if (arg2 == NULL) SWIG_fail;
21830 temp2 = true;
21831 }
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 (arg1)->SetText((wxString const &)*arg2);
21835
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 Py_INCREF(Py_None); resultobj = Py_None;
21840 {
21841 if (temp2)
21842 delete arg2;
21843 }
21844 return resultobj;
21845 fail:
21846 {
21847 if (temp2)
21848 delete arg2;
21849 }
21850 return NULL;
21851 }
21852
21853
21854 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21855 PyObject *resultobj = NULL;
21856 long arg1 ;
21857 PyObject * obj0 = 0 ;
21858 char *kwnames[] = {
21859 (char *) "updateInterval", NULL
21860 };
21861
21862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21863 {
21864 arg1 = static_cast<long >(SWIG_As_long(obj0));
21865 if (SWIG_arg_fail(1)) SWIG_fail;
21866 }
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 wxUpdateUIEvent::SetUpdateInterval(arg1);
21870
21871 wxPyEndAllowThreads(__tstate);
21872 if (PyErr_Occurred()) SWIG_fail;
21873 }
21874 Py_INCREF(Py_None); resultobj = Py_None;
21875 return resultobj;
21876 fail:
21877 return NULL;
21878 }
21879
21880
21881 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj = NULL;
21883 long result;
21884 char *kwnames[] = {
21885 NULL
21886 };
21887
21888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 {
21897 resultobj = SWIG_From_long(static_cast<long >(result));
21898 }
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21906 PyObject *resultobj = NULL;
21907 wxWindow *arg1 = (wxWindow *) 0 ;
21908 bool result;
21909 PyObject * obj0 = 0 ;
21910 char *kwnames[] = {
21911 (char *) "win", NULL
21912 };
21913
21914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21916 if (SWIG_arg_fail(1)) SWIG_fail;
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21920
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 {
21925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21926 }
21927 return resultobj;
21928 fail:
21929 return NULL;
21930 }
21931
21932
21933 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21934 PyObject *resultobj = NULL;
21935 char *kwnames[] = {
21936 NULL
21937 };
21938
21939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 wxUpdateUIEvent::ResetUpdateTime();
21943
21944 wxPyEndAllowThreads(__tstate);
21945 if (PyErr_Occurred()) SWIG_fail;
21946 }
21947 Py_INCREF(Py_None); resultobj = Py_None;
21948 return resultobj;
21949 fail:
21950 return NULL;
21951 }
21952
21953
21954 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21955 PyObject *resultobj = NULL;
21956 wxUpdateUIMode arg1 ;
21957 PyObject * obj0 = 0 ;
21958 char *kwnames[] = {
21959 (char *) "mode", NULL
21960 };
21961
21962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21963 {
21964 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
21965 if (SWIG_arg_fail(1)) SWIG_fail;
21966 }
21967 {
21968 PyThreadState* __tstate = wxPyBeginAllowThreads();
21969 wxUpdateUIEvent::SetMode(arg1);
21970
21971 wxPyEndAllowThreads(__tstate);
21972 if (PyErr_Occurred()) SWIG_fail;
21973 }
21974 Py_INCREF(Py_None); resultobj = Py_None;
21975 return resultobj;
21976 fail:
21977 return NULL;
21978 }
21979
21980
21981 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21982 PyObject *resultobj = NULL;
21983 wxUpdateUIMode result;
21984 char *kwnames[] = {
21985 NULL
21986 };
21987
21988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21989 {
21990 PyThreadState* __tstate = wxPyBeginAllowThreads();
21991 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21992
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 resultobj = SWIG_From_int((result));
21997 return resultobj;
21998 fail:
21999 return NULL;
22000 }
22001
22002
22003 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
22004 PyObject *obj;
22005 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22006 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22007 Py_INCREF(obj);
22008 return Py_BuildValue((char *)"");
22009 }
22010 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22011 PyObject *resultobj = NULL;
22012 wxSysColourChangedEvent *result;
22013 char *kwnames[] = {
22014 NULL
22015 };
22016
22017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22021
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22033 PyObject *obj;
22034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22035 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22036 Py_INCREF(obj);
22037 return Py_BuildValue((char *)"");
22038 }
22039 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22040 PyObject *resultobj = NULL;
22041 int arg1 = (int) 0 ;
22042 wxWindow *arg2 = (wxWindow *) NULL ;
22043 wxMouseCaptureChangedEvent *result;
22044 PyObject * obj0 = 0 ;
22045 PyObject * obj1 = 0 ;
22046 char *kwnames[] = {
22047 (char *) "winid",(char *) "gainedCapture", NULL
22048 };
22049
22050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22051 if (obj0) {
22052 {
22053 arg1 = static_cast<int >(SWIG_As_int(obj0));
22054 if (SWIG_arg_fail(1)) SWIG_fail;
22055 }
22056 }
22057 if (obj1) {
22058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22059 if (SWIG_arg_fail(2)) SWIG_fail;
22060 }
22061 {
22062 PyThreadState* __tstate = wxPyBeginAllowThreads();
22063 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22064
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22069 return resultobj;
22070 fail:
22071 return NULL;
22072 }
22073
22074
22075 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22076 PyObject *resultobj = NULL;
22077 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22078 wxWindow *result;
22079 PyObject * obj0 = 0 ;
22080 char *kwnames[] = {
22081 (char *) "self", NULL
22082 };
22083
22084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22086 if (SWIG_arg_fail(1)) SWIG_fail;
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22090
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 {
22095 resultobj = wxPyMake_wxObject(result, 0);
22096 }
22097 return resultobj;
22098 fail:
22099 return NULL;
22100 }
22101
22102
22103 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22104 PyObject *obj;
22105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22106 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22107 Py_INCREF(obj);
22108 return Py_BuildValue((char *)"");
22109 }
22110 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22111 PyObject *resultobj = NULL;
22112 wxDisplayChangedEvent *result;
22113 char *kwnames[] = {
22114 NULL
22115 };
22116
22117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22121
22122 wxPyEndAllowThreads(__tstate);
22123 if (PyErr_Occurred()) SWIG_fail;
22124 }
22125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22133 PyObject *obj;
22134 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22135 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22136 Py_INCREF(obj);
22137 return Py_BuildValue((char *)"");
22138 }
22139 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj = NULL;
22141 int arg1 = (int) 0 ;
22142 wxPaletteChangedEvent *result;
22143 PyObject * obj0 = 0 ;
22144 char *kwnames[] = {
22145 (char *) "id", NULL
22146 };
22147
22148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22149 if (obj0) {
22150 {
22151 arg1 = static_cast<int >(SWIG_As_int(obj0));
22152 if (SWIG_arg_fail(1)) SWIG_fail;
22153 }
22154 }
22155 {
22156 PyThreadState* __tstate = wxPyBeginAllowThreads();
22157 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22158
22159 wxPyEndAllowThreads(__tstate);
22160 if (PyErr_Occurred()) SWIG_fail;
22161 }
22162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22163 return resultobj;
22164 fail:
22165 return NULL;
22166 }
22167
22168
22169 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22170 PyObject *resultobj = NULL;
22171 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22172 wxWindow *arg2 = (wxWindow *) 0 ;
22173 PyObject * obj0 = 0 ;
22174 PyObject * obj1 = 0 ;
22175 char *kwnames[] = {
22176 (char *) "self",(char *) "win", NULL
22177 };
22178
22179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22181 if (SWIG_arg_fail(1)) SWIG_fail;
22182 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22183 if (SWIG_arg_fail(2)) SWIG_fail;
22184 {
22185 PyThreadState* __tstate = wxPyBeginAllowThreads();
22186 (arg1)->SetChangedWindow(arg2);
22187
22188 wxPyEndAllowThreads(__tstate);
22189 if (PyErr_Occurred()) SWIG_fail;
22190 }
22191 Py_INCREF(Py_None); resultobj = Py_None;
22192 return resultobj;
22193 fail:
22194 return NULL;
22195 }
22196
22197
22198 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22199 PyObject *resultobj = NULL;
22200 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22201 wxWindow *result;
22202 PyObject * obj0 = 0 ;
22203 char *kwnames[] = {
22204 (char *) "self", NULL
22205 };
22206
22207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22209 if (SWIG_arg_fail(1)) SWIG_fail;
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 result = (wxWindow *)(arg1)->GetChangedWindow();
22213
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 {
22218 resultobj = wxPyMake_wxObject(result, 0);
22219 }
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22227 PyObject *obj;
22228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22229 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22230 Py_INCREF(obj);
22231 return Py_BuildValue((char *)"");
22232 }
22233 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22234 PyObject *resultobj = NULL;
22235 int arg1 = (int) 0 ;
22236 wxQueryNewPaletteEvent *result;
22237 PyObject * obj0 = 0 ;
22238 char *kwnames[] = {
22239 (char *) "winid", NULL
22240 };
22241
22242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22243 if (obj0) {
22244 {
22245 arg1 = static_cast<int >(SWIG_As_int(obj0));
22246 if (SWIG_arg_fail(1)) SWIG_fail;
22247 }
22248 }
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22252
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj = NULL;
22265 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22266 bool arg2 ;
22267 PyObject * obj0 = 0 ;
22268 PyObject * obj1 = 0 ;
22269 char *kwnames[] = {
22270 (char *) "self",(char *) "realized", NULL
22271 };
22272
22273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22275 if (SWIG_arg_fail(1)) SWIG_fail;
22276 {
22277 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22278 if (SWIG_arg_fail(2)) SWIG_fail;
22279 }
22280 {
22281 PyThreadState* __tstate = wxPyBeginAllowThreads();
22282 (arg1)->SetPaletteRealized(arg2);
22283
22284 wxPyEndAllowThreads(__tstate);
22285 if (PyErr_Occurred()) SWIG_fail;
22286 }
22287 Py_INCREF(Py_None); resultobj = Py_None;
22288 return resultobj;
22289 fail:
22290 return NULL;
22291 }
22292
22293
22294 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22295 PyObject *resultobj = NULL;
22296 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22297 bool result;
22298 PyObject * obj0 = 0 ;
22299 char *kwnames[] = {
22300 (char *) "self", NULL
22301 };
22302
22303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22305 if (SWIG_arg_fail(1)) SWIG_fail;
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22309
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 {
22314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22315 }
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22323 PyObject *obj;
22324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22325 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22326 Py_INCREF(obj);
22327 return Py_BuildValue((char *)"");
22328 }
22329 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj = NULL;
22331 wxNavigationKeyEvent *result;
22332 char *kwnames[] = {
22333 NULL
22334 };
22335
22336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22337 {
22338 PyThreadState* __tstate = wxPyBeginAllowThreads();
22339 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22340
22341 wxPyEndAllowThreads(__tstate);
22342 if (PyErr_Occurred()) SWIG_fail;
22343 }
22344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22352 PyObject *resultobj = NULL;
22353 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22354 bool result;
22355 PyObject * obj0 = 0 ;
22356 char *kwnames[] = {
22357 (char *) "self", NULL
22358 };
22359
22360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22362 if (SWIG_arg_fail(1)) SWIG_fail;
22363 {
22364 PyThreadState* __tstate = wxPyBeginAllowThreads();
22365 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22366
22367 wxPyEndAllowThreads(__tstate);
22368 if (PyErr_Occurred()) SWIG_fail;
22369 }
22370 {
22371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22372 }
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj = NULL;
22381 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22382 bool arg2 ;
22383 PyObject * obj0 = 0 ;
22384 PyObject * obj1 = 0 ;
22385 char *kwnames[] = {
22386 (char *) "self",(char *) "forward", NULL
22387 };
22388
22389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22391 if (SWIG_arg_fail(1)) SWIG_fail;
22392 {
22393 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22394 if (SWIG_arg_fail(2)) SWIG_fail;
22395 }
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 (arg1)->SetDirection(arg2);
22399
22400 wxPyEndAllowThreads(__tstate);
22401 if (PyErr_Occurred()) SWIG_fail;
22402 }
22403 Py_INCREF(Py_None); resultobj = Py_None;
22404 return resultobj;
22405 fail:
22406 return NULL;
22407 }
22408
22409
22410 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22411 PyObject *resultobj = NULL;
22412 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22413 bool result;
22414 PyObject * obj0 = 0 ;
22415 char *kwnames[] = {
22416 (char *) "self", NULL
22417 };
22418
22419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22421 if (SWIG_arg_fail(1)) SWIG_fail;
22422 {
22423 PyThreadState* __tstate = wxPyBeginAllowThreads();
22424 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22425
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 {
22430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22431 }
22432 return resultobj;
22433 fail:
22434 return NULL;
22435 }
22436
22437
22438 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22439 PyObject *resultobj = NULL;
22440 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22441 bool arg2 ;
22442 PyObject * obj0 = 0 ;
22443 PyObject * obj1 = 0 ;
22444 char *kwnames[] = {
22445 (char *) "self",(char *) "ischange", NULL
22446 };
22447
22448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22450 if (SWIG_arg_fail(1)) SWIG_fail;
22451 {
22452 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22453 if (SWIG_arg_fail(2)) SWIG_fail;
22454 }
22455 {
22456 PyThreadState* __tstate = wxPyBeginAllowThreads();
22457 (arg1)->SetWindowChange(arg2);
22458
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 Py_INCREF(Py_None); resultobj = Py_None;
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22470 PyObject *resultobj = NULL;
22471 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22472 bool result;
22473 PyObject * obj0 = 0 ;
22474 char *kwnames[] = {
22475 (char *) "self", NULL
22476 };
22477
22478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(1)) SWIG_fail;
22481 {
22482 PyThreadState* __tstate = wxPyBeginAllowThreads();
22483 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22484
22485 wxPyEndAllowThreads(__tstate);
22486 if (PyErr_Occurred()) SWIG_fail;
22487 }
22488 {
22489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22490 }
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22498 PyObject *resultobj = NULL;
22499 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22500 bool arg2 ;
22501 PyObject * obj0 = 0 ;
22502 PyObject * obj1 = 0 ;
22503 char *kwnames[] = {
22504 (char *) "self",(char *) "bIs", NULL
22505 };
22506
22507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22509 if (SWIG_arg_fail(1)) SWIG_fail;
22510 {
22511 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22512 if (SWIG_arg_fail(2)) SWIG_fail;
22513 }
22514 {
22515 PyThreadState* __tstate = wxPyBeginAllowThreads();
22516 (arg1)->SetFromTab(arg2);
22517
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 Py_INCREF(Py_None); resultobj = Py_None;
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22529 PyObject *resultobj = NULL;
22530 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22531 long arg2 ;
22532 PyObject * obj0 = 0 ;
22533 PyObject * obj1 = 0 ;
22534 char *kwnames[] = {
22535 (char *) "self",(char *) "flags", NULL
22536 };
22537
22538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22540 if (SWIG_arg_fail(1)) SWIG_fail;
22541 {
22542 arg2 = static_cast<long >(SWIG_As_long(obj1));
22543 if (SWIG_arg_fail(2)) SWIG_fail;
22544 }
22545 {
22546 PyThreadState* __tstate = wxPyBeginAllowThreads();
22547 (arg1)->SetFlags(arg2);
22548
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 Py_INCREF(Py_None); resultobj = Py_None;
22553 return resultobj;
22554 fail:
22555 return NULL;
22556 }
22557
22558
22559 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22560 PyObject *resultobj = NULL;
22561 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22562 wxWindow *result;
22563 PyObject * obj0 = 0 ;
22564 char *kwnames[] = {
22565 (char *) "self", NULL
22566 };
22567
22568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22570 if (SWIG_arg_fail(1)) SWIG_fail;
22571 {
22572 PyThreadState* __tstate = wxPyBeginAllowThreads();
22573 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22574
22575 wxPyEndAllowThreads(__tstate);
22576 if (PyErr_Occurred()) SWIG_fail;
22577 }
22578 {
22579 resultobj = wxPyMake_wxObject(result, 0);
22580 }
22581 return resultobj;
22582 fail:
22583 return NULL;
22584 }
22585
22586
22587 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22588 PyObject *resultobj = NULL;
22589 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22590 wxWindow *arg2 = (wxWindow *) 0 ;
22591 PyObject * obj0 = 0 ;
22592 PyObject * obj1 = 0 ;
22593 char *kwnames[] = {
22594 (char *) "self",(char *) "win", NULL
22595 };
22596
22597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22599 if (SWIG_arg_fail(1)) SWIG_fail;
22600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22601 if (SWIG_arg_fail(2)) SWIG_fail;
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 (arg1)->SetCurrentFocus(arg2);
22605
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 Py_INCREF(Py_None); resultobj = Py_None;
22610 return resultobj;
22611 fail:
22612 return NULL;
22613 }
22614
22615
22616 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22617 PyObject *obj;
22618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22619 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22620 Py_INCREF(obj);
22621 return Py_BuildValue((char *)"");
22622 }
22623 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22624 PyObject *resultobj = NULL;
22625 wxWindow *arg1 = (wxWindow *) NULL ;
22626 wxWindowCreateEvent *result;
22627 PyObject * obj0 = 0 ;
22628 char *kwnames[] = {
22629 (char *) "win", NULL
22630 };
22631
22632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22633 if (obj0) {
22634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22635 if (SWIG_arg_fail(1)) SWIG_fail;
22636 }
22637 {
22638 PyThreadState* __tstate = wxPyBeginAllowThreads();
22639 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22640
22641 wxPyEndAllowThreads(__tstate);
22642 if (PyErr_Occurred()) SWIG_fail;
22643 }
22644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22645 return resultobj;
22646 fail:
22647 return NULL;
22648 }
22649
22650
22651 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22652 PyObject *resultobj = NULL;
22653 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22654 wxWindow *result;
22655 PyObject * obj0 = 0 ;
22656 char *kwnames[] = {
22657 (char *) "self", NULL
22658 };
22659
22660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22662 if (SWIG_arg_fail(1)) SWIG_fail;
22663 {
22664 PyThreadState* __tstate = wxPyBeginAllowThreads();
22665 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22666
22667 wxPyEndAllowThreads(__tstate);
22668 if (PyErr_Occurred()) SWIG_fail;
22669 }
22670 {
22671 resultobj = wxPyMake_wxObject(result, 0);
22672 }
22673 return resultobj;
22674 fail:
22675 return NULL;
22676 }
22677
22678
22679 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22680 PyObject *obj;
22681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22682 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22683 Py_INCREF(obj);
22684 return Py_BuildValue((char *)"");
22685 }
22686 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22687 PyObject *resultobj = NULL;
22688 wxWindow *arg1 = (wxWindow *) NULL ;
22689 wxWindowDestroyEvent *result;
22690 PyObject * obj0 = 0 ;
22691 char *kwnames[] = {
22692 (char *) "win", NULL
22693 };
22694
22695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22696 if (obj0) {
22697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22698 if (SWIG_arg_fail(1)) SWIG_fail;
22699 }
22700 {
22701 PyThreadState* __tstate = wxPyBeginAllowThreads();
22702 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22703
22704 wxPyEndAllowThreads(__tstate);
22705 if (PyErr_Occurred()) SWIG_fail;
22706 }
22707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22715 PyObject *resultobj = NULL;
22716 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22717 wxWindow *result;
22718 PyObject * obj0 = 0 ;
22719 char *kwnames[] = {
22720 (char *) "self", NULL
22721 };
22722
22723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22725 if (SWIG_arg_fail(1)) SWIG_fail;
22726 {
22727 PyThreadState* __tstate = wxPyBeginAllowThreads();
22728 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22729
22730 wxPyEndAllowThreads(__tstate);
22731 if (PyErr_Occurred()) SWIG_fail;
22732 }
22733 {
22734 resultobj = wxPyMake_wxObject(result, 0);
22735 }
22736 return resultobj;
22737 fail:
22738 return NULL;
22739 }
22740
22741
22742 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22743 PyObject *obj;
22744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22745 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22746 Py_INCREF(obj);
22747 return Py_BuildValue((char *)"");
22748 }
22749 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22750 PyObject *resultobj = NULL;
22751 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22752 int arg2 = (int) 0 ;
22753 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22754 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22755 wxContextMenuEvent *result;
22756 wxPoint temp3 ;
22757 PyObject * obj0 = 0 ;
22758 PyObject * obj1 = 0 ;
22759 PyObject * obj2 = 0 ;
22760 char *kwnames[] = {
22761 (char *) "type",(char *) "winid",(char *) "pt", NULL
22762 };
22763
22764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22765 if (obj0) {
22766 {
22767 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22768 if (SWIG_arg_fail(1)) SWIG_fail;
22769 }
22770 }
22771 if (obj1) {
22772 {
22773 arg2 = static_cast<int >(SWIG_As_int(obj1));
22774 if (SWIG_arg_fail(2)) SWIG_fail;
22775 }
22776 }
22777 if (obj2) {
22778 {
22779 arg3 = &temp3;
22780 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22781 }
22782 }
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22786
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22798 PyObject *resultobj = NULL;
22799 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22800 wxPoint *result;
22801 PyObject * obj0 = 0 ;
22802 char *kwnames[] = {
22803 (char *) "self", NULL
22804 };
22805
22806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22808 if (SWIG_arg_fail(1)) SWIG_fail;
22809 {
22810 PyThreadState* __tstate = wxPyBeginAllowThreads();
22811 {
22812 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22813 result = (wxPoint *) &_result_ref;
22814 }
22815
22816 wxPyEndAllowThreads(__tstate);
22817 if (PyErr_Occurred()) SWIG_fail;
22818 }
22819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22827 PyObject *resultobj = NULL;
22828 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22829 wxPoint *arg2 = 0 ;
22830 wxPoint temp2 ;
22831 PyObject * obj0 = 0 ;
22832 PyObject * obj1 = 0 ;
22833 char *kwnames[] = {
22834 (char *) "self",(char *) "pos", NULL
22835 };
22836
22837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22839 if (SWIG_arg_fail(1)) SWIG_fail;
22840 {
22841 arg2 = &temp2;
22842 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22843 }
22844 {
22845 PyThreadState* __tstate = wxPyBeginAllowThreads();
22846 (arg1)->SetPosition((wxPoint const &)*arg2);
22847
22848 wxPyEndAllowThreads(__tstate);
22849 if (PyErr_Occurred()) SWIG_fail;
22850 }
22851 Py_INCREF(Py_None); resultobj = Py_None;
22852 return resultobj;
22853 fail:
22854 return NULL;
22855 }
22856
22857
22858 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22859 PyObject *obj;
22860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22861 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22862 Py_INCREF(obj);
22863 return Py_BuildValue((char *)"");
22864 }
22865 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22866 PyObject *resultobj = NULL;
22867 wxIdleEvent *result;
22868 char *kwnames[] = {
22869 NULL
22870 };
22871
22872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22873 {
22874 PyThreadState* __tstate = wxPyBeginAllowThreads();
22875 result = (wxIdleEvent *)new wxIdleEvent();
22876
22877 wxPyEndAllowThreads(__tstate);
22878 if (PyErr_Occurred()) SWIG_fail;
22879 }
22880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22881 return resultobj;
22882 fail:
22883 return NULL;
22884 }
22885
22886
22887 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22888 PyObject *resultobj = NULL;
22889 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22890 bool arg2 = (bool) true ;
22891 PyObject * obj0 = 0 ;
22892 PyObject * obj1 = 0 ;
22893 char *kwnames[] = {
22894 (char *) "self",(char *) "needMore", NULL
22895 };
22896
22897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22899 if (SWIG_arg_fail(1)) SWIG_fail;
22900 if (obj1) {
22901 {
22902 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22903 if (SWIG_arg_fail(2)) SWIG_fail;
22904 }
22905 }
22906 {
22907 PyThreadState* __tstate = wxPyBeginAllowThreads();
22908 (arg1)->RequestMore(arg2);
22909
22910 wxPyEndAllowThreads(__tstate);
22911 if (PyErr_Occurred()) SWIG_fail;
22912 }
22913 Py_INCREF(Py_None); resultobj = Py_None;
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22921 PyObject *resultobj = NULL;
22922 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22923 bool result;
22924 PyObject * obj0 = 0 ;
22925 char *kwnames[] = {
22926 (char *) "self", NULL
22927 };
22928
22929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22931 if (SWIG_arg_fail(1)) SWIG_fail;
22932 {
22933 PyThreadState* __tstate = wxPyBeginAllowThreads();
22934 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22935
22936 wxPyEndAllowThreads(__tstate);
22937 if (PyErr_Occurred()) SWIG_fail;
22938 }
22939 {
22940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22941 }
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj = NULL;
22950 wxIdleMode arg1 ;
22951 PyObject * obj0 = 0 ;
22952 char *kwnames[] = {
22953 (char *) "mode", NULL
22954 };
22955
22956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22957 {
22958 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
22959 if (SWIG_arg_fail(1)) SWIG_fail;
22960 }
22961 {
22962 PyThreadState* __tstate = wxPyBeginAllowThreads();
22963 wxIdleEvent::SetMode(arg1);
22964
22965 wxPyEndAllowThreads(__tstate);
22966 if (PyErr_Occurred()) SWIG_fail;
22967 }
22968 Py_INCREF(Py_None); resultobj = Py_None;
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22976 PyObject *resultobj = NULL;
22977 wxIdleMode result;
22978 char *kwnames[] = {
22979 NULL
22980 };
22981
22982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 result = (wxIdleMode)wxIdleEvent::GetMode();
22986
22987 wxPyEndAllowThreads(__tstate);
22988 if (PyErr_Occurred()) SWIG_fail;
22989 }
22990 resultobj = SWIG_From_int((result));
22991 return resultobj;
22992 fail:
22993 return NULL;
22994 }
22995
22996
22997 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj = NULL;
22999 wxWindow *arg1 = (wxWindow *) 0 ;
23000 bool result;
23001 PyObject * obj0 = 0 ;
23002 char *kwnames[] = {
23003 (char *) "win", NULL
23004 };
23005
23006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23008 if (SWIG_arg_fail(1)) SWIG_fail;
23009 {
23010 PyThreadState* __tstate = wxPyBeginAllowThreads();
23011 result = (bool)wxIdleEvent::CanSend(arg1);
23012
23013 wxPyEndAllowThreads(__tstate);
23014 if (PyErr_Occurred()) SWIG_fail;
23015 }
23016 {
23017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23018 }
23019 return resultobj;
23020 fail:
23021 return NULL;
23022 }
23023
23024
23025 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23026 PyObject *obj;
23027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23028 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23029 Py_INCREF(obj);
23030 return Py_BuildValue((char *)"");
23031 }
23032 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj = NULL;
23034 int arg1 = (int) 0 ;
23035 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23036 wxPyEvent *result;
23037 PyObject * obj0 = 0 ;
23038 PyObject * obj1 = 0 ;
23039 char *kwnames[] = {
23040 (char *) "winid",(char *) "eventType", NULL
23041 };
23042
23043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23044 if (obj0) {
23045 {
23046 arg1 = static_cast<int >(SWIG_As_int(obj0));
23047 if (SWIG_arg_fail(1)) SWIG_fail;
23048 }
23049 }
23050 if (obj1) {
23051 {
23052 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23053 if (SWIG_arg_fail(2)) SWIG_fail;
23054 }
23055 }
23056 {
23057 PyThreadState* __tstate = wxPyBeginAllowThreads();
23058 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23059
23060 wxPyEndAllowThreads(__tstate);
23061 if (PyErr_Occurred()) SWIG_fail;
23062 }
23063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23064 return resultobj;
23065 fail:
23066 return NULL;
23067 }
23068
23069
23070 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23071 PyObject *resultobj = NULL;
23072 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23073 PyObject * obj0 = 0 ;
23074 char *kwnames[] = {
23075 (char *) "self", NULL
23076 };
23077
23078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23080 if (SWIG_arg_fail(1)) SWIG_fail;
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 delete arg1;
23084
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 Py_INCREF(Py_None); resultobj = Py_None;
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23096 PyObject *resultobj = NULL;
23097 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23098 PyObject *arg2 = (PyObject *) 0 ;
23099 PyObject * obj0 = 0 ;
23100 PyObject * obj1 = 0 ;
23101 char *kwnames[] = {
23102 (char *) "self",(char *) "self", NULL
23103 };
23104
23105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23107 if (SWIG_arg_fail(1)) SWIG_fail;
23108 arg2 = obj1;
23109 {
23110 PyThreadState* __tstate = wxPyBeginAllowThreads();
23111 (arg1)->SetSelf(arg2);
23112
23113 wxPyEndAllowThreads(__tstate);
23114 if (PyErr_Occurred()) SWIG_fail;
23115 }
23116 Py_INCREF(Py_None); resultobj = Py_None;
23117 return resultobj;
23118 fail:
23119 return NULL;
23120 }
23121
23122
23123 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23124 PyObject *resultobj = NULL;
23125 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23126 PyObject *result;
23127 PyObject * obj0 = 0 ;
23128 char *kwnames[] = {
23129 (char *) "self", NULL
23130 };
23131
23132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23134 if (SWIG_arg_fail(1)) SWIG_fail;
23135 {
23136 PyThreadState* __tstate = wxPyBeginAllowThreads();
23137 result = (PyObject *)(arg1)->GetSelf();
23138
23139 wxPyEndAllowThreads(__tstate);
23140 if (PyErr_Occurred()) SWIG_fail;
23141 }
23142 resultobj = result;
23143 return resultobj;
23144 fail:
23145 return NULL;
23146 }
23147
23148
23149 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23150 PyObject *obj;
23151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23152 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23153 Py_INCREF(obj);
23154 return Py_BuildValue((char *)"");
23155 }
23156 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23157 PyObject *resultobj = NULL;
23158 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23159 int arg2 = (int) 0 ;
23160 wxPyCommandEvent *result;
23161 PyObject * obj0 = 0 ;
23162 PyObject * obj1 = 0 ;
23163 char *kwnames[] = {
23164 (char *) "eventType",(char *) "id", NULL
23165 };
23166
23167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23168 if (obj0) {
23169 {
23170 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 }
23173 }
23174 if (obj1) {
23175 {
23176 arg2 = static_cast<int >(SWIG_As_int(obj1));
23177 if (SWIG_arg_fail(2)) SWIG_fail;
23178 }
23179 }
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23183
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23195 PyObject *resultobj = NULL;
23196 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23197 PyObject * obj0 = 0 ;
23198 char *kwnames[] = {
23199 (char *) "self", NULL
23200 };
23201
23202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23204 if (SWIG_arg_fail(1)) SWIG_fail;
23205 {
23206 PyThreadState* __tstate = wxPyBeginAllowThreads();
23207 delete arg1;
23208
23209 wxPyEndAllowThreads(__tstate);
23210 if (PyErr_Occurred()) SWIG_fail;
23211 }
23212 Py_INCREF(Py_None); resultobj = Py_None;
23213 return resultobj;
23214 fail:
23215 return NULL;
23216 }
23217
23218
23219 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23220 PyObject *resultobj = NULL;
23221 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23222 PyObject *arg2 = (PyObject *) 0 ;
23223 PyObject * obj0 = 0 ;
23224 PyObject * obj1 = 0 ;
23225 char *kwnames[] = {
23226 (char *) "self",(char *) "self", NULL
23227 };
23228
23229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23231 if (SWIG_arg_fail(1)) SWIG_fail;
23232 arg2 = obj1;
23233 {
23234 PyThreadState* __tstate = wxPyBeginAllowThreads();
23235 (arg1)->SetSelf(arg2);
23236
23237 wxPyEndAllowThreads(__tstate);
23238 if (PyErr_Occurred()) SWIG_fail;
23239 }
23240 Py_INCREF(Py_None); resultobj = Py_None;
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23248 PyObject *resultobj = NULL;
23249 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23250 PyObject *result;
23251 PyObject * obj0 = 0 ;
23252 char *kwnames[] = {
23253 (char *) "self", NULL
23254 };
23255
23256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23258 if (SWIG_arg_fail(1)) SWIG_fail;
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (PyObject *)(arg1)->GetSelf();
23262
23263 wxPyEndAllowThreads(__tstate);
23264 if (PyErr_Occurred()) SWIG_fail;
23265 }
23266 resultobj = result;
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23274 PyObject *obj;
23275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23276 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23277 Py_INCREF(obj);
23278 return Py_BuildValue((char *)"");
23279 }
23280 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23281 PyObject *resultobj = NULL;
23282 wxWindow *arg1 = (wxWindow *) 0 ;
23283 wxDateTime *arg2 = 0 ;
23284 wxEventType arg3 ;
23285 wxDateEvent *result;
23286 PyObject * obj0 = 0 ;
23287 PyObject * obj1 = 0 ;
23288 PyObject * obj2 = 0 ;
23289 char *kwnames[] = {
23290 (char *) "win",(char *) "dt",(char *) "type", NULL
23291 };
23292
23293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23295 if (SWIG_arg_fail(1)) SWIG_fail;
23296 {
23297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23298 if (SWIG_arg_fail(2)) SWIG_fail;
23299 if (arg2 == NULL) {
23300 SWIG_null_ref("wxDateTime");
23301 }
23302 if (SWIG_arg_fail(2)) SWIG_fail;
23303 }
23304 {
23305 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23306 if (SWIG_arg_fail(3)) SWIG_fail;
23307 }
23308 {
23309 PyThreadState* __tstate = wxPyBeginAllowThreads();
23310 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23311
23312 wxPyEndAllowThreads(__tstate);
23313 if (PyErr_Occurred()) SWIG_fail;
23314 }
23315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23316 return resultobj;
23317 fail:
23318 return NULL;
23319 }
23320
23321
23322 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23323 PyObject *resultobj = NULL;
23324 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23325 wxDateTime *result;
23326 PyObject * obj0 = 0 ;
23327 char *kwnames[] = {
23328 (char *) "self", NULL
23329 };
23330
23331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23333 if (SWIG_arg_fail(1)) SWIG_fail;
23334 {
23335 PyThreadState* __tstate = wxPyBeginAllowThreads();
23336 {
23337 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23338 result = (wxDateTime *) &_result_ref;
23339 }
23340
23341 wxPyEndAllowThreads(__tstate);
23342 if (PyErr_Occurred()) SWIG_fail;
23343 }
23344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23352 PyObject *resultobj = NULL;
23353 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23354 wxDateTime *arg2 = 0 ;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 char *kwnames[] = {
23358 (char *) "self",(char *) "date", NULL
23359 };
23360
23361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23363 if (SWIG_arg_fail(1)) SWIG_fail;
23364 {
23365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(2)) SWIG_fail;
23367 if (arg2 == NULL) {
23368 SWIG_null_ref("wxDateTime");
23369 }
23370 if (SWIG_arg_fail(2)) SWIG_fail;
23371 }
23372 {
23373 PyThreadState* __tstate = wxPyBeginAllowThreads();
23374 (arg1)->SetDate((wxDateTime const &)*arg2);
23375
23376 wxPyEndAllowThreads(__tstate);
23377 if (PyErr_Occurred()) SWIG_fail;
23378 }
23379 Py_INCREF(Py_None); resultobj = Py_None;
23380 return resultobj;
23381 fail:
23382 return NULL;
23383 }
23384
23385
23386 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23387 PyObject *obj;
23388 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23389 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23390 Py_INCREF(obj);
23391 return Py_BuildValue((char *)"");
23392 }
23393 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23394 PyObject *resultobj = NULL;
23395 wxPyApp *result;
23396 char *kwnames[] = {
23397 NULL
23398 };
23399
23400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23401 {
23402 PyThreadState* __tstate = wxPyBeginAllowThreads();
23403 result = (wxPyApp *)new_wxPyApp();
23404
23405 wxPyEndAllowThreads(__tstate);
23406 if (PyErr_Occurred()) SWIG_fail;
23407 }
23408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23416 PyObject *resultobj = NULL;
23417 wxPyApp *arg1 = (wxPyApp *) 0 ;
23418 PyObject * obj0 = 0 ;
23419 char *kwnames[] = {
23420 (char *) "self", NULL
23421 };
23422
23423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23425 if (SWIG_arg_fail(1)) SWIG_fail;
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 delete arg1;
23429
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 Py_INCREF(Py_None); resultobj = Py_None;
23434 return resultobj;
23435 fail:
23436 return NULL;
23437 }
23438
23439
23440 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23441 PyObject *resultobj = NULL;
23442 wxPyApp *arg1 = (wxPyApp *) 0 ;
23443 PyObject *arg2 = (PyObject *) 0 ;
23444 PyObject *arg3 = (PyObject *) 0 ;
23445 bool arg4 ;
23446 PyObject * obj0 = 0 ;
23447 PyObject * obj1 = 0 ;
23448 PyObject * obj2 = 0 ;
23449 PyObject * obj3 = 0 ;
23450 char *kwnames[] = {
23451 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23452 };
23453
23454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23456 if (SWIG_arg_fail(1)) SWIG_fail;
23457 arg2 = obj1;
23458 arg3 = obj2;
23459 {
23460 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23461 if (SWIG_arg_fail(4)) SWIG_fail;
23462 }
23463 {
23464 PyThreadState* __tstate = wxPyBeginAllowThreads();
23465 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23466
23467 wxPyEndAllowThreads(__tstate);
23468 if (PyErr_Occurred()) SWIG_fail;
23469 }
23470 Py_INCREF(Py_None); resultobj = Py_None;
23471 return resultobj;
23472 fail:
23473 return NULL;
23474 }
23475
23476
23477 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj = NULL;
23479 wxPyApp *arg1 = (wxPyApp *) 0 ;
23480 wxString result;
23481 PyObject * obj0 = 0 ;
23482 char *kwnames[] = {
23483 (char *) "self", NULL
23484 };
23485
23486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23488 if (SWIG_arg_fail(1)) SWIG_fail;
23489 {
23490 PyThreadState* __tstate = wxPyBeginAllowThreads();
23491 result = ((wxPyApp const *)arg1)->GetAppName();
23492
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 {
23497 #if wxUSE_UNICODE
23498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23499 #else
23500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23501 #endif
23502 }
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23510 PyObject *resultobj = NULL;
23511 wxPyApp *arg1 = (wxPyApp *) 0 ;
23512 wxString *arg2 = 0 ;
23513 bool temp2 = false ;
23514 PyObject * obj0 = 0 ;
23515 PyObject * obj1 = 0 ;
23516 char *kwnames[] = {
23517 (char *) "self",(char *) "name", NULL
23518 };
23519
23520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23522 if (SWIG_arg_fail(1)) SWIG_fail;
23523 {
23524 arg2 = wxString_in_helper(obj1);
23525 if (arg2 == NULL) SWIG_fail;
23526 temp2 = true;
23527 }
23528 {
23529 PyThreadState* __tstate = wxPyBeginAllowThreads();
23530 (arg1)->SetAppName((wxString const &)*arg2);
23531
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 Py_INCREF(Py_None); resultobj = Py_None;
23536 {
23537 if (temp2)
23538 delete arg2;
23539 }
23540 return resultobj;
23541 fail:
23542 {
23543 if (temp2)
23544 delete arg2;
23545 }
23546 return NULL;
23547 }
23548
23549
23550 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj = NULL;
23552 wxPyApp *arg1 = (wxPyApp *) 0 ;
23553 wxString result;
23554 PyObject * obj0 = 0 ;
23555 char *kwnames[] = {
23556 (char *) "self", NULL
23557 };
23558
23559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23561 if (SWIG_arg_fail(1)) SWIG_fail;
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = ((wxPyApp const *)arg1)->GetClassName();
23565
23566 wxPyEndAllowThreads(__tstate);
23567 if (PyErr_Occurred()) SWIG_fail;
23568 }
23569 {
23570 #if wxUSE_UNICODE
23571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23572 #else
23573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23574 #endif
23575 }
23576 return resultobj;
23577 fail:
23578 return NULL;
23579 }
23580
23581
23582 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23583 PyObject *resultobj = NULL;
23584 wxPyApp *arg1 = (wxPyApp *) 0 ;
23585 wxString *arg2 = 0 ;
23586 bool temp2 = false ;
23587 PyObject * obj0 = 0 ;
23588 PyObject * obj1 = 0 ;
23589 char *kwnames[] = {
23590 (char *) "self",(char *) "name", NULL
23591 };
23592
23593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23595 if (SWIG_arg_fail(1)) SWIG_fail;
23596 {
23597 arg2 = wxString_in_helper(obj1);
23598 if (arg2 == NULL) SWIG_fail;
23599 temp2 = true;
23600 }
23601 {
23602 PyThreadState* __tstate = wxPyBeginAllowThreads();
23603 (arg1)->SetClassName((wxString const &)*arg2);
23604
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 Py_INCREF(Py_None); resultobj = Py_None;
23609 {
23610 if (temp2)
23611 delete arg2;
23612 }
23613 return resultobj;
23614 fail:
23615 {
23616 if (temp2)
23617 delete arg2;
23618 }
23619 return NULL;
23620 }
23621
23622
23623 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23624 PyObject *resultobj = NULL;
23625 wxPyApp *arg1 = (wxPyApp *) 0 ;
23626 wxString *result;
23627 PyObject * obj0 = 0 ;
23628 char *kwnames[] = {
23629 (char *) "self", NULL
23630 };
23631
23632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23634 if (SWIG_arg_fail(1)) SWIG_fail;
23635 {
23636 PyThreadState* __tstate = wxPyBeginAllowThreads();
23637 {
23638 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23639 result = (wxString *) &_result_ref;
23640 }
23641
23642 wxPyEndAllowThreads(__tstate);
23643 if (PyErr_Occurred()) SWIG_fail;
23644 }
23645 {
23646 #if wxUSE_UNICODE
23647 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23648 #else
23649 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23650 #endif
23651 }
23652 return resultobj;
23653 fail:
23654 return NULL;
23655 }
23656
23657
23658 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23659 PyObject *resultobj = NULL;
23660 wxPyApp *arg1 = (wxPyApp *) 0 ;
23661 wxString *arg2 = 0 ;
23662 bool temp2 = false ;
23663 PyObject * obj0 = 0 ;
23664 PyObject * obj1 = 0 ;
23665 char *kwnames[] = {
23666 (char *) "self",(char *) "name", NULL
23667 };
23668
23669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23671 if (SWIG_arg_fail(1)) SWIG_fail;
23672 {
23673 arg2 = wxString_in_helper(obj1);
23674 if (arg2 == NULL) SWIG_fail;
23675 temp2 = true;
23676 }
23677 {
23678 PyThreadState* __tstate = wxPyBeginAllowThreads();
23679 (arg1)->SetVendorName((wxString const &)*arg2);
23680
23681 wxPyEndAllowThreads(__tstate);
23682 if (PyErr_Occurred()) SWIG_fail;
23683 }
23684 Py_INCREF(Py_None); resultobj = Py_None;
23685 {
23686 if (temp2)
23687 delete arg2;
23688 }
23689 return resultobj;
23690 fail:
23691 {
23692 if (temp2)
23693 delete arg2;
23694 }
23695 return NULL;
23696 }
23697
23698
23699 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23700 PyObject *resultobj = NULL;
23701 wxPyApp *arg1 = (wxPyApp *) 0 ;
23702 wxAppTraits *result;
23703 PyObject * obj0 = 0 ;
23704 char *kwnames[] = {
23705 (char *) "self", NULL
23706 };
23707
23708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23710 if (SWIG_arg_fail(1)) SWIG_fail;
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = (wxAppTraits *)(arg1)->GetTraits();
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23726 PyObject *resultobj = NULL;
23727 wxPyApp *arg1 = (wxPyApp *) 0 ;
23728 PyObject * obj0 = 0 ;
23729 char *kwnames[] = {
23730 (char *) "self", NULL
23731 };
23732
23733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23735 if (SWIG_arg_fail(1)) SWIG_fail;
23736 {
23737 PyThreadState* __tstate = wxPyBeginAllowThreads();
23738 (arg1)->ProcessPendingEvents();
23739
23740 wxPyEndAllowThreads(__tstate);
23741 if (PyErr_Occurred()) SWIG_fail;
23742 }
23743 Py_INCREF(Py_None); resultobj = Py_None;
23744 return resultobj;
23745 fail:
23746 return NULL;
23747 }
23748
23749
23750 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23751 PyObject *resultobj = NULL;
23752 wxPyApp *arg1 = (wxPyApp *) 0 ;
23753 bool arg2 = (bool) false ;
23754 bool result;
23755 PyObject * obj0 = 0 ;
23756 PyObject * obj1 = 0 ;
23757 char *kwnames[] = {
23758 (char *) "self",(char *) "onlyIfNeeded", NULL
23759 };
23760
23761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23763 if (SWIG_arg_fail(1)) SWIG_fail;
23764 if (obj1) {
23765 {
23766 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23767 if (SWIG_arg_fail(2)) SWIG_fail;
23768 }
23769 }
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = (bool)(arg1)->Yield(arg2);
23773
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 {
23778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23779 }
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj = NULL;
23788 wxPyApp *arg1 = (wxPyApp *) 0 ;
23789 PyObject * obj0 = 0 ;
23790 char *kwnames[] = {
23791 (char *) "self", NULL
23792 };
23793
23794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 {
23798 PyThreadState* __tstate = wxPyBeginAllowThreads();
23799 (arg1)->WakeUpIdle();
23800
23801 wxPyEndAllowThreads(__tstate);
23802 if (PyErr_Occurred()) SWIG_fail;
23803 }
23804 Py_INCREF(Py_None); resultobj = Py_None;
23805 return resultobj;
23806 fail:
23807 return NULL;
23808 }
23809
23810
23811 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23812 PyObject *resultobj = NULL;
23813 bool result;
23814 char *kwnames[] = {
23815 NULL
23816 };
23817
23818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23819 {
23820 PyThreadState* __tstate = wxPyBeginAllowThreads();
23821 result = (bool)wxPyApp::IsMainLoopRunning();
23822
23823 wxPyEndAllowThreads(__tstate);
23824 if (PyErr_Occurred()) SWIG_fail;
23825 }
23826 {
23827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23828 }
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23836 PyObject *resultobj = NULL;
23837 wxPyApp *arg1 = (wxPyApp *) 0 ;
23838 int result;
23839 PyObject * obj0 = 0 ;
23840 char *kwnames[] = {
23841 (char *) "self", NULL
23842 };
23843
23844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23846 if (SWIG_arg_fail(1)) SWIG_fail;
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 result = (int)(arg1)->MainLoop();
23850
23851 wxPyEndAllowThreads(__tstate);
23852 if (PyErr_Occurred()) SWIG_fail;
23853 }
23854 {
23855 resultobj = SWIG_From_int(static_cast<int >(result));
23856 }
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj = NULL;
23865 wxPyApp *arg1 = (wxPyApp *) 0 ;
23866 PyObject * obj0 = 0 ;
23867 char *kwnames[] = {
23868 (char *) "self", NULL
23869 };
23870
23871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",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 (arg1)->Exit();
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 Py_INCREF(Py_None); resultobj = Py_None;
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 static PyObject *_wrap_PyApp_ExitMainLoop(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_ExitMainLoop",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)->ExitMainLoop();
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_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj = NULL;
23915 wxPyApp *arg1 = (wxPyApp *) 0 ;
23916 bool result;
23917 PyObject * obj0 = 0 ;
23918 char *kwnames[] = {
23919 (char *) "self", NULL
23920 };
23921
23922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23924 if (SWIG_arg_fail(1)) SWIG_fail;
23925 {
23926 PyThreadState* __tstate = wxPyBeginAllowThreads();
23927 result = (bool)(arg1)->Pending();
23928
23929 wxPyEndAllowThreads(__tstate);
23930 if (PyErr_Occurred()) SWIG_fail;
23931 }
23932 {
23933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23934 }
23935 return resultobj;
23936 fail:
23937 return NULL;
23938 }
23939
23940
23941 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23942 PyObject *resultobj = NULL;
23943 wxPyApp *arg1 = (wxPyApp *) 0 ;
23944 bool result;
23945 PyObject * obj0 = 0 ;
23946 char *kwnames[] = {
23947 (char *) "self", NULL
23948 };
23949
23950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23952 if (SWIG_arg_fail(1)) SWIG_fail;
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (bool)(arg1)->Dispatch();
23956
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 {
23961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23962 }
23963 return resultobj;
23964 fail:
23965 return NULL;
23966 }
23967
23968
23969 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23970 PyObject *resultobj = NULL;
23971 wxPyApp *arg1 = (wxPyApp *) 0 ;
23972 bool result;
23973 PyObject * obj0 = 0 ;
23974 char *kwnames[] = {
23975 (char *) "self", NULL
23976 };
23977
23978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23980 if (SWIG_arg_fail(1)) SWIG_fail;
23981 {
23982 PyThreadState* __tstate = wxPyBeginAllowThreads();
23983 result = (bool)(arg1)->ProcessIdle();
23984
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 {
23989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23990 }
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23998 PyObject *resultobj = NULL;
23999 wxPyApp *arg1 = (wxPyApp *) 0 ;
24000 wxWindow *arg2 = (wxWindow *) 0 ;
24001 wxIdleEvent *arg3 = 0 ;
24002 bool result;
24003 PyObject * obj0 = 0 ;
24004 PyObject * obj1 = 0 ;
24005 PyObject * obj2 = 0 ;
24006 char *kwnames[] = {
24007 (char *) "self",(char *) "win",(char *) "event", NULL
24008 };
24009
24010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
24011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24012 if (SWIG_arg_fail(1)) SWIG_fail;
24013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24014 if (SWIG_arg_fail(2)) SWIG_fail;
24015 {
24016 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24017 if (SWIG_arg_fail(3)) SWIG_fail;
24018 if (arg3 == NULL) {
24019 SWIG_null_ref("wxIdleEvent");
24020 }
24021 if (SWIG_arg_fail(3)) SWIG_fail;
24022 }
24023 {
24024 PyThreadState* __tstate = wxPyBeginAllowThreads();
24025 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24026
24027 wxPyEndAllowThreads(__tstate);
24028 if (PyErr_Occurred()) SWIG_fail;
24029 }
24030 {
24031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24032 }
24033 return resultobj;
24034 fail:
24035 return NULL;
24036 }
24037
24038
24039 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24040 PyObject *resultobj = NULL;
24041 wxPyApp *arg1 = (wxPyApp *) 0 ;
24042 bool result;
24043 PyObject * obj0 = 0 ;
24044 char *kwnames[] = {
24045 (char *) "self", NULL
24046 };
24047
24048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24050 if (SWIG_arg_fail(1)) SWIG_fail;
24051 {
24052 PyThreadState* __tstate = wxPyBeginAllowThreads();
24053 result = (bool)((wxPyApp const *)arg1)->IsActive();
24054
24055 wxPyEndAllowThreads(__tstate);
24056 if (PyErr_Occurred()) SWIG_fail;
24057 }
24058 {
24059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24060 }
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24068 PyObject *resultobj = NULL;
24069 wxPyApp *arg1 = (wxPyApp *) 0 ;
24070 wxWindow *arg2 = (wxWindow *) 0 ;
24071 PyObject * obj0 = 0 ;
24072 PyObject * obj1 = 0 ;
24073 char *kwnames[] = {
24074 (char *) "self",(char *) "win", NULL
24075 };
24076
24077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24079 if (SWIG_arg_fail(1)) SWIG_fail;
24080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24081 if (SWIG_arg_fail(2)) SWIG_fail;
24082 {
24083 PyThreadState* __tstate = wxPyBeginAllowThreads();
24084 (arg1)->SetTopWindow(arg2);
24085
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 Py_INCREF(Py_None); resultobj = Py_None;
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24097 PyObject *resultobj = NULL;
24098 wxPyApp *arg1 = (wxPyApp *) 0 ;
24099 wxWindow *result;
24100 PyObject * obj0 = 0 ;
24101 char *kwnames[] = {
24102 (char *) "self", NULL
24103 };
24104
24105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24107 if (SWIG_arg_fail(1)) SWIG_fail;
24108 {
24109 PyThreadState* __tstate = wxPyBeginAllowThreads();
24110 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24111
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 {
24116 resultobj = wxPyMake_wxObject(result, 0);
24117 }
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24125 PyObject *resultobj = NULL;
24126 wxPyApp *arg1 = (wxPyApp *) 0 ;
24127 bool arg2 ;
24128 PyObject * obj0 = 0 ;
24129 PyObject * obj1 = 0 ;
24130 char *kwnames[] = {
24131 (char *) "self",(char *) "flag", NULL
24132 };
24133
24134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24136 if (SWIG_arg_fail(1)) SWIG_fail;
24137 {
24138 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24139 if (SWIG_arg_fail(2)) SWIG_fail;
24140 }
24141 {
24142 PyThreadState* __tstate = wxPyBeginAllowThreads();
24143 (arg1)->SetExitOnFrameDelete(arg2);
24144
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 Py_INCREF(Py_None); resultobj = Py_None;
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24156 PyObject *resultobj = NULL;
24157 wxPyApp *arg1 = (wxPyApp *) 0 ;
24158 bool result;
24159 PyObject * obj0 = 0 ;
24160 char *kwnames[] = {
24161 (char *) "self", NULL
24162 };
24163
24164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24166 if (SWIG_arg_fail(1)) SWIG_fail;
24167 {
24168 PyThreadState* __tstate = wxPyBeginAllowThreads();
24169 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24170
24171 wxPyEndAllowThreads(__tstate);
24172 if (PyErr_Occurred()) SWIG_fail;
24173 }
24174 {
24175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24176 }
24177 return resultobj;
24178 fail:
24179 return NULL;
24180 }
24181
24182
24183 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj = NULL;
24185 wxPyApp *arg1 = (wxPyApp *) 0 ;
24186 bool arg2 ;
24187 PyObject * obj0 = 0 ;
24188 PyObject * obj1 = 0 ;
24189 char *kwnames[] = {
24190 (char *) "self",(char *) "flag", NULL
24191 };
24192
24193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24195 if (SWIG_arg_fail(1)) SWIG_fail;
24196 {
24197 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24198 if (SWIG_arg_fail(2)) SWIG_fail;
24199 }
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 (arg1)->SetUseBestVisual(arg2);
24203
24204 wxPyEndAllowThreads(__tstate);
24205 if (PyErr_Occurred()) SWIG_fail;
24206 }
24207 Py_INCREF(Py_None); resultobj = Py_None;
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24215 PyObject *resultobj = NULL;
24216 wxPyApp *arg1 = (wxPyApp *) 0 ;
24217 bool result;
24218 PyObject * obj0 = 0 ;
24219 char *kwnames[] = {
24220 (char *) "self", NULL
24221 };
24222
24223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24225 if (SWIG_arg_fail(1)) SWIG_fail;
24226 {
24227 PyThreadState* __tstate = wxPyBeginAllowThreads();
24228 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24229
24230 wxPyEndAllowThreads(__tstate);
24231 if (PyErr_Occurred()) SWIG_fail;
24232 }
24233 {
24234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24235 }
24236 return resultobj;
24237 fail:
24238 return NULL;
24239 }
24240
24241
24242 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24243 PyObject *resultobj = NULL;
24244 wxPyApp *arg1 = (wxPyApp *) 0 ;
24245 int arg2 ;
24246 PyObject * obj0 = 0 ;
24247 PyObject * obj1 = 0 ;
24248 char *kwnames[] = {
24249 (char *) "self",(char *) "mode", NULL
24250 };
24251
24252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24254 if (SWIG_arg_fail(1)) SWIG_fail;
24255 {
24256 arg2 = static_cast<int >(SWIG_As_int(obj1));
24257 if (SWIG_arg_fail(2)) SWIG_fail;
24258 }
24259 {
24260 PyThreadState* __tstate = wxPyBeginAllowThreads();
24261 (arg1)->SetPrintMode(arg2);
24262
24263 wxPyEndAllowThreads(__tstate);
24264 if (PyErr_Occurred()) SWIG_fail;
24265 }
24266 Py_INCREF(Py_None); resultobj = Py_None;
24267 return resultobj;
24268 fail:
24269 return NULL;
24270 }
24271
24272
24273 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24274 PyObject *resultobj = NULL;
24275 wxPyApp *arg1 = (wxPyApp *) 0 ;
24276 int result;
24277 PyObject * obj0 = 0 ;
24278 char *kwnames[] = {
24279 (char *) "self", NULL
24280 };
24281
24282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24284 if (SWIG_arg_fail(1)) SWIG_fail;
24285 {
24286 PyThreadState* __tstate = wxPyBeginAllowThreads();
24287 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24288
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 {
24293 resultobj = SWIG_From_int(static_cast<int >(result));
24294 }
24295 return resultobj;
24296 fail:
24297 return NULL;
24298 }
24299
24300
24301 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24302 PyObject *resultobj = NULL;
24303 wxPyApp *arg1 = (wxPyApp *) 0 ;
24304 int arg2 ;
24305 PyObject * obj0 = 0 ;
24306 PyObject * obj1 = 0 ;
24307 char *kwnames[] = {
24308 (char *) "self",(char *) "mode", NULL
24309 };
24310
24311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24313 if (SWIG_arg_fail(1)) SWIG_fail;
24314 {
24315 arg2 = static_cast<int >(SWIG_As_int(obj1));
24316 if (SWIG_arg_fail(2)) SWIG_fail;
24317 }
24318 {
24319 PyThreadState* __tstate = wxPyBeginAllowThreads();
24320 (arg1)->SetAssertMode(arg2);
24321
24322 wxPyEndAllowThreads(__tstate);
24323 if (PyErr_Occurred()) SWIG_fail;
24324 }
24325 Py_INCREF(Py_None); resultobj = Py_None;
24326 return resultobj;
24327 fail:
24328 return NULL;
24329 }
24330
24331
24332 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24333 PyObject *resultobj = NULL;
24334 wxPyApp *arg1 = (wxPyApp *) 0 ;
24335 int result;
24336 PyObject * obj0 = 0 ;
24337 char *kwnames[] = {
24338 (char *) "self", NULL
24339 };
24340
24341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24343 if (SWIG_arg_fail(1)) SWIG_fail;
24344 {
24345 PyThreadState* __tstate = wxPyBeginAllowThreads();
24346 result = (int)(arg1)->GetAssertMode();
24347
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 {
24352 resultobj = SWIG_From_int(static_cast<int >(result));
24353 }
24354 return resultobj;
24355 fail:
24356 return NULL;
24357 }
24358
24359
24360 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24361 PyObject *resultobj = NULL;
24362 bool result;
24363 char *kwnames[] = {
24364 NULL
24365 };
24366
24367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24368 {
24369 PyThreadState* __tstate = wxPyBeginAllowThreads();
24370 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24371
24372 wxPyEndAllowThreads(__tstate);
24373 if (PyErr_Occurred()) SWIG_fail;
24374 }
24375 {
24376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24377 }
24378 return resultobj;
24379 fail:
24380 return NULL;
24381 }
24382
24383
24384 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24385 PyObject *resultobj = NULL;
24386 long result;
24387 char *kwnames[] = {
24388 NULL
24389 };
24390
24391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24392 {
24393 PyThreadState* __tstate = wxPyBeginAllowThreads();
24394 result = (long)wxPyApp::GetMacAboutMenuItemId();
24395
24396 wxPyEndAllowThreads(__tstate);
24397 if (PyErr_Occurred()) SWIG_fail;
24398 }
24399 {
24400 resultobj = SWIG_From_long(static_cast<long >(result));
24401 }
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj = NULL;
24410 long result;
24411 char *kwnames[] = {
24412 NULL
24413 };
24414
24415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24416 {
24417 PyThreadState* __tstate = wxPyBeginAllowThreads();
24418 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24419
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 {
24424 resultobj = SWIG_From_long(static_cast<long >(result));
24425 }
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24433 PyObject *resultobj = NULL;
24434 long result;
24435 char *kwnames[] = {
24436 NULL
24437 };
24438
24439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24440 {
24441 PyThreadState* __tstate = wxPyBeginAllowThreads();
24442 result = (long)wxPyApp::GetMacExitMenuItemId();
24443
24444 wxPyEndAllowThreads(__tstate);
24445 if (PyErr_Occurred()) SWIG_fail;
24446 }
24447 {
24448 resultobj = SWIG_From_long(static_cast<long >(result));
24449 }
24450 return resultobj;
24451 fail:
24452 return NULL;
24453 }
24454
24455
24456 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24457 PyObject *resultobj = NULL;
24458 wxString result;
24459 char *kwnames[] = {
24460 NULL
24461 };
24462
24463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24464 {
24465 PyThreadState* __tstate = wxPyBeginAllowThreads();
24466 result = wxPyApp::GetMacHelpMenuTitleName();
24467
24468 wxPyEndAllowThreads(__tstate);
24469 if (PyErr_Occurred()) SWIG_fail;
24470 }
24471 {
24472 #if wxUSE_UNICODE
24473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24474 #else
24475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24476 #endif
24477 }
24478 return resultobj;
24479 fail:
24480 return NULL;
24481 }
24482
24483
24484 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj = NULL;
24486 bool arg1 ;
24487 PyObject * obj0 = 0 ;
24488 char *kwnames[] = {
24489 (char *) "val", NULL
24490 };
24491
24492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24493 {
24494 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24495 if (SWIG_arg_fail(1)) SWIG_fail;
24496 }
24497 {
24498 PyThreadState* __tstate = wxPyBeginAllowThreads();
24499 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24500
24501 wxPyEndAllowThreads(__tstate);
24502 if (PyErr_Occurred()) SWIG_fail;
24503 }
24504 Py_INCREF(Py_None); resultobj = Py_None;
24505 return resultobj;
24506 fail:
24507 return NULL;
24508 }
24509
24510
24511 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24512 PyObject *resultobj = NULL;
24513 long arg1 ;
24514 PyObject * obj0 = 0 ;
24515 char *kwnames[] = {
24516 (char *) "val", NULL
24517 };
24518
24519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24520 {
24521 arg1 = static_cast<long >(SWIG_As_long(obj0));
24522 if (SWIG_arg_fail(1)) SWIG_fail;
24523 }
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 wxPyApp::SetMacAboutMenuItemId(arg1);
24527
24528 wxPyEndAllowThreads(__tstate);
24529 if (PyErr_Occurred()) SWIG_fail;
24530 }
24531 Py_INCREF(Py_None); resultobj = Py_None;
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj = NULL;
24540 long arg1 ;
24541 PyObject * obj0 = 0 ;
24542 char *kwnames[] = {
24543 (char *) "val", NULL
24544 };
24545
24546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24547 {
24548 arg1 = static_cast<long >(SWIG_As_long(obj0));
24549 if (SWIG_arg_fail(1)) SWIG_fail;
24550 }
24551 {
24552 PyThreadState* __tstate = wxPyBeginAllowThreads();
24553 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24554
24555 wxPyEndAllowThreads(__tstate);
24556 if (PyErr_Occurred()) SWIG_fail;
24557 }
24558 Py_INCREF(Py_None); resultobj = Py_None;
24559 return resultobj;
24560 fail:
24561 return NULL;
24562 }
24563
24564
24565 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24566 PyObject *resultobj = NULL;
24567 long arg1 ;
24568 PyObject * obj0 = 0 ;
24569 char *kwnames[] = {
24570 (char *) "val", NULL
24571 };
24572
24573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24574 {
24575 arg1 = static_cast<long >(SWIG_As_long(obj0));
24576 if (SWIG_arg_fail(1)) SWIG_fail;
24577 }
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 wxPyApp::SetMacExitMenuItemId(arg1);
24581
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 Py_INCREF(Py_None); resultobj = Py_None;
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24593 PyObject *resultobj = NULL;
24594 wxString *arg1 = 0 ;
24595 bool temp1 = false ;
24596 PyObject * obj0 = 0 ;
24597 char *kwnames[] = {
24598 (char *) "val", NULL
24599 };
24600
24601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24602 {
24603 arg1 = wxString_in_helper(obj0);
24604 if (arg1 == NULL) SWIG_fail;
24605 temp1 = true;
24606 }
24607 {
24608 PyThreadState* __tstate = wxPyBeginAllowThreads();
24609 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24610
24611 wxPyEndAllowThreads(__tstate);
24612 if (PyErr_Occurred()) SWIG_fail;
24613 }
24614 Py_INCREF(Py_None); resultobj = Py_None;
24615 {
24616 if (temp1)
24617 delete arg1;
24618 }
24619 return resultobj;
24620 fail:
24621 {
24622 if (temp1)
24623 delete arg1;
24624 }
24625 return NULL;
24626 }
24627
24628
24629 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24630 PyObject *resultobj = NULL;
24631 wxPyApp *arg1 = (wxPyApp *) 0 ;
24632 PyObject * obj0 = 0 ;
24633 char *kwnames[] = {
24634 (char *) "self", NULL
24635 };
24636
24637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24639 if (SWIG_arg_fail(1)) SWIG_fail;
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 (arg1)->_BootstrapApp();
24643
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 Py_INCREF(Py_None); resultobj = Py_None;
24648 return resultobj;
24649 fail:
24650 return NULL;
24651 }
24652
24653
24654 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24655 PyObject *resultobj = NULL;
24656 int result;
24657 char *kwnames[] = {
24658 NULL
24659 };
24660
24661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24662 {
24663 PyThreadState* __tstate = wxPyBeginAllowThreads();
24664 result = (int)wxPyApp_GetComCtl32Version();
24665
24666 wxPyEndAllowThreads(__tstate);
24667 if (PyErr_Occurred()) SWIG_fail;
24668 }
24669 {
24670 resultobj = SWIG_From_int(static_cast<int >(result));
24671 }
24672 return resultobj;
24673 fail:
24674 return NULL;
24675 }
24676
24677
24678 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24679 PyObject *obj;
24680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24681 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24682 Py_INCREF(obj);
24683 return Py_BuildValue((char *)"");
24684 }
24685 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24686 PyObject *resultobj = NULL;
24687 char *kwnames[] = {
24688 NULL
24689 };
24690
24691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 wxExit();
24695
24696 wxPyEndAllowThreads(__tstate);
24697 if (PyErr_Occurred()) SWIG_fail;
24698 }
24699 Py_INCREF(Py_None); resultobj = Py_None;
24700 return resultobj;
24701 fail:
24702 return NULL;
24703 }
24704
24705
24706 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24707 PyObject *resultobj = NULL;
24708 bool result;
24709 char *kwnames[] = {
24710 NULL
24711 };
24712
24713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24714 {
24715 PyThreadState* __tstate = wxPyBeginAllowThreads();
24716 result = (bool)wxYield();
24717
24718 wxPyEndAllowThreads(__tstate);
24719 if (PyErr_Occurred()) SWIG_fail;
24720 }
24721 {
24722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24723 }
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24731 PyObject *resultobj = NULL;
24732 bool result;
24733 char *kwnames[] = {
24734 NULL
24735 };
24736
24737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24738 {
24739 PyThreadState* __tstate = wxPyBeginAllowThreads();
24740 result = (bool)wxYieldIfNeeded();
24741
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24755 PyObject *resultobj = NULL;
24756 wxWindow *arg1 = (wxWindow *) NULL ;
24757 bool arg2 = (bool) false ;
24758 bool result;
24759 PyObject * obj0 = 0 ;
24760 PyObject * obj1 = 0 ;
24761 char *kwnames[] = {
24762 (char *) "win",(char *) "onlyIfNeeded", NULL
24763 };
24764
24765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24766 if (obj0) {
24767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24768 if (SWIG_arg_fail(1)) SWIG_fail;
24769 }
24770 if (obj1) {
24771 {
24772 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24773 if (SWIG_arg_fail(2)) SWIG_fail;
24774 }
24775 }
24776 {
24777 PyThreadState* __tstate = wxPyBeginAllowThreads();
24778 result = (bool)wxSafeYield(arg1,arg2);
24779
24780 wxPyEndAllowThreads(__tstate);
24781 if (PyErr_Occurred()) SWIG_fail;
24782 }
24783 {
24784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24785 }
24786 return resultobj;
24787 fail:
24788 return NULL;
24789 }
24790
24791
24792 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24793 PyObject *resultobj = NULL;
24794 char *kwnames[] = {
24795 NULL
24796 };
24797
24798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 wxWakeUpIdle();
24802
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 Py_INCREF(Py_None); resultobj = Py_None;
24807 return resultobj;
24808 fail:
24809 return NULL;
24810 }
24811
24812
24813 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24814 PyObject *resultobj = NULL;
24815 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24816 wxEvent *arg2 = 0 ;
24817 PyObject * obj0 = 0 ;
24818 PyObject * obj1 = 0 ;
24819 char *kwnames[] = {
24820 (char *) "dest",(char *) "event", NULL
24821 };
24822
24823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24825 if (SWIG_arg_fail(1)) SWIG_fail;
24826 {
24827 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24828 if (SWIG_arg_fail(2)) SWIG_fail;
24829 if (arg2 == NULL) {
24830 SWIG_null_ref("wxEvent");
24831 }
24832 if (SWIG_arg_fail(2)) SWIG_fail;
24833 }
24834 {
24835 PyThreadState* __tstate = wxPyBeginAllowThreads();
24836 wxPostEvent(arg1,*arg2);
24837
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 Py_INCREF(Py_None); resultobj = Py_None;
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24849 PyObject *resultobj = NULL;
24850 char *kwnames[] = {
24851 NULL
24852 };
24853
24854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 wxApp_CleanUp();
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_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24870 PyObject *resultobj = NULL;
24871 wxPyApp *result;
24872 char *kwnames[] = {
24873 NULL
24874 };
24875
24876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (wxPyApp *)wxPyGetApp();
24880
24881 wxPyEndAllowThreads(__tstate);
24882 if (PyErr_Occurred()) SWIG_fail;
24883 }
24884 {
24885 resultobj = wxPyMake_wxObject(result, 0);
24886 }
24887 return resultobj;
24888 fail:
24889 return NULL;
24890 }
24891
24892
24893 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24894 PyObject *resultobj = NULL;
24895 char *arg1 = (char *) 0 ;
24896 PyObject * obj0 = 0 ;
24897 char *kwnames[] = {
24898 (char *) "encoding", NULL
24899 };
24900
24901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24902 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24903 SWIG_arg_fail(1);SWIG_fail;
24904 }
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 wxSetDefaultPyEncoding((char const *)arg1);
24908
24909 wxPyEndAllowThreads(__tstate);
24910 if (PyErr_Occurred()) SWIG_fail;
24911 }
24912 Py_INCREF(Py_None); resultobj = Py_None;
24913 return resultobj;
24914 fail:
24915 return NULL;
24916 }
24917
24918
24919 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24920 PyObject *resultobj = NULL;
24921 char *result;
24922 char *kwnames[] = {
24923 NULL
24924 };
24925
24926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24927 {
24928 PyThreadState* __tstate = wxPyBeginAllowThreads();
24929 result = (char *)wxGetDefaultPyEncoding();
24930
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 resultobj = SWIG_FromCharPtr(result);
24935 return resultobj;
24936 fail:
24937 return NULL;
24938 }
24939
24940
24941 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24942 PyObject *resultobj = NULL;
24943 wxEventLoop *result;
24944 char *kwnames[] = {
24945 NULL
24946 };
24947
24948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (wxEventLoop *)new wxEventLoop();
24952
24953 wxPyEndAllowThreads(__tstate);
24954 if (PyErr_Occurred()) SWIG_fail;
24955 }
24956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24957 return resultobj;
24958 fail:
24959 return NULL;
24960 }
24961
24962
24963 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24964 PyObject *resultobj = NULL;
24965 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24966 PyObject * obj0 = 0 ;
24967 char *kwnames[] = {
24968 (char *) "self", NULL
24969 };
24970
24971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24973 if (SWIG_arg_fail(1)) SWIG_fail;
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 delete arg1;
24977
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 Py_INCREF(Py_None); resultobj = Py_None;
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24989 PyObject *resultobj = NULL;
24990 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24991 int result;
24992 PyObject * obj0 = 0 ;
24993 char *kwnames[] = {
24994 (char *) "self", NULL
24995 };
24996
24997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24999 if (SWIG_arg_fail(1)) SWIG_fail;
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 result = (int)(arg1)->Run();
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 {
25008 resultobj = SWIG_From_int(static_cast<int >(result));
25009 }
25010 return resultobj;
25011 fail:
25012 return NULL;
25013 }
25014
25015
25016 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25017 PyObject *resultobj = NULL;
25018 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25019 int arg2 = (int) 0 ;
25020 PyObject * obj0 = 0 ;
25021 PyObject * obj1 = 0 ;
25022 char *kwnames[] = {
25023 (char *) "self",(char *) "rc", NULL
25024 };
25025
25026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25028 if (SWIG_arg_fail(1)) SWIG_fail;
25029 if (obj1) {
25030 {
25031 arg2 = static_cast<int >(SWIG_As_int(obj1));
25032 if (SWIG_arg_fail(2)) SWIG_fail;
25033 }
25034 }
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 (arg1)->Exit(arg2);
25038
25039 wxPyEndAllowThreads(__tstate);
25040 if (PyErr_Occurred()) SWIG_fail;
25041 }
25042 Py_INCREF(Py_None); resultobj = Py_None;
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj = NULL;
25051 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25052 bool result;
25053 PyObject * obj0 = 0 ;
25054 char *kwnames[] = {
25055 (char *) "self", NULL
25056 };
25057
25058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25060 if (SWIG_arg_fail(1)) SWIG_fail;
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (bool)((wxEventLoop const *)arg1)->Pending();
25064
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj = NULL;
25079 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25080 bool result;
25081 PyObject * obj0 = 0 ;
25082 char *kwnames[] = {
25083 (char *) "self", NULL
25084 };
25085
25086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25088 if (SWIG_arg_fail(1)) SWIG_fail;
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 result = (bool)(arg1)->Dispatch();
25092
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 {
25097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25098 }
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25106 PyObject *resultobj = NULL;
25107 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25108 bool result;
25109 PyObject * obj0 = 0 ;
25110 char *kwnames[] = {
25111 (char *) "self", NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25116 if (SWIG_arg_fail(1)) SWIG_fail;
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25120
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 {
25125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25126 }
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj = NULL;
25135 wxEventLoop *result;
25136 char *kwnames[] = {
25137 NULL
25138 };
25139
25140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25141 {
25142 PyThreadState* __tstate = wxPyBeginAllowThreads();
25143 result = (wxEventLoop *)wxEventLoop::GetActive();
25144
25145 wxPyEndAllowThreads(__tstate);
25146 if (PyErr_Occurred()) SWIG_fail;
25147 }
25148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25149 return resultobj;
25150 fail:
25151 return NULL;
25152 }
25153
25154
25155 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25156 PyObject *resultobj = NULL;
25157 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25158 PyObject * obj0 = 0 ;
25159 char *kwnames[] = {
25160 (char *) "loop", NULL
25161 };
25162
25163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25165 if (SWIG_arg_fail(1)) SWIG_fail;
25166 {
25167 PyThreadState* __tstate = wxPyBeginAllowThreads();
25168 wxEventLoop::SetActive(arg1);
25169
25170 wxPyEndAllowThreads(__tstate);
25171 if (PyErr_Occurred()) SWIG_fail;
25172 }
25173 Py_INCREF(Py_None); resultobj = Py_None;
25174 return resultobj;
25175 fail:
25176 return NULL;
25177 }
25178
25179
25180 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25181 PyObject *obj;
25182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25183 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25184 Py_INCREF(obj);
25185 return Py_BuildValue((char *)"");
25186 }
25187 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25188 PyObject *resultobj = NULL;
25189 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25190 wxEventLoopActivator *result;
25191 PyObject * obj0 = 0 ;
25192 char *kwnames[] = {
25193 (char *) "evtLoop", NULL
25194 };
25195
25196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25198 if (SWIG_arg_fail(1)) SWIG_fail;
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25202
25203 wxPyEndAllowThreads(__tstate);
25204 if (PyErr_Occurred()) SWIG_fail;
25205 }
25206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25207 return resultobj;
25208 fail:
25209 return NULL;
25210 }
25211
25212
25213 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25214 PyObject *resultobj = NULL;
25215 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25216 PyObject * obj0 = 0 ;
25217 char *kwnames[] = {
25218 (char *) "self", NULL
25219 };
25220
25221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25223 if (SWIG_arg_fail(1)) SWIG_fail;
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 delete arg1;
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 Py_INCREF(Py_None); resultobj = Py_None;
25232 return resultobj;
25233 fail:
25234 return NULL;
25235 }
25236
25237
25238 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25239 PyObject *obj;
25240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25241 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25242 Py_INCREF(obj);
25243 return Py_BuildValue((char *)"");
25244 }
25245 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25246 PyObject *resultobj = NULL;
25247 int arg1 = (int) 0 ;
25248 int arg2 = (int) 0 ;
25249 int arg3 = (int) 0 ;
25250 wxAcceleratorEntry *result;
25251 PyObject * obj0 = 0 ;
25252 PyObject * obj1 = 0 ;
25253 PyObject * obj2 = 0 ;
25254 char *kwnames[] = {
25255 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25256 };
25257
25258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25259 if (obj0) {
25260 {
25261 arg1 = static_cast<int >(SWIG_As_int(obj0));
25262 if (SWIG_arg_fail(1)) SWIG_fail;
25263 }
25264 }
25265 if (obj1) {
25266 {
25267 arg2 = static_cast<int >(SWIG_As_int(obj1));
25268 if (SWIG_arg_fail(2)) SWIG_fail;
25269 }
25270 }
25271 if (obj2) {
25272 {
25273 arg3 = static_cast<int >(SWIG_As_int(obj2));
25274 if (SWIG_arg_fail(3)) SWIG_fail;
25275 }
25276 }
25277 {
25278 PyThreadState* __tstate = wxPyBeginAllowThreads();
25279 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25280
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25292 PyObject *resultobj = NULL;
25293 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25294 PyObject * obj0 = 0 ;
25295 char *kwnames[] = {
25296 (char *) "self", NULL
25297 };
25298
25299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25301 if (SWIG_arg_fail(1)) SWIG_fail;
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 delete arg1;
25305
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 Py_INCREF(Py_None); resultobj = Py_None;
25310 return resultobj;
25311 fail:
25312 return NULL;
25313 }
25314
25315
25316 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25317 PyObject *resultobj = NULL;
25318 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25319 int arg2 ;
25320 int arg3 ;
25321 int arg4 ;
25322 PyObject * obj0 = 0 ;
25323 PyObject * obj1 = 0 ;
25324 PyObject * obj2 = 0 ;
25325 PyObject * obj3 = 0 ;
25326 char *kwnames[] = {
25327 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25328 };
25329
25330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25332 if (SWIG_arg_fail(1)) SWIG_fail;
25333 {
25334 arg2 = static_cast<int >(SWIG_As_int(obj1));
25335 if (SWIG_arg_fail(2)) SWIG_fail;
25336 }
25337 {
25338 arg3 = static_cast<int >(SWIG_As_int(obj2));
25339 if (SWIG_arg_fail(3)) SWIG_fail;
25340 }
25341 {
25342 arg4 = static_cast<int >(SWIG_As_int(obj3));
25343 if (SWIG_arg_fail(4)) SWIG_fail;
25344 }
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 (arg1)->Set(arg2,arg3,arg4);
25348
25349 wxPyEndAllowThreads(__tstate);
25350 if (PyErr_Occurred()) SWIG_fail;
25351 }
25352 Py_INCREF(Py_None); resultobj = Py_None;
25353 return resultobj;
25354 fail:
25355 return NULL;
25356 }
25357
25358
25359 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25360 PyObject *resultobj = NULL;
25361 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25362 int result;
25363 PyObject * obj0 = 0 ;
25364 char *kwnames[] = {
25365 (char *) "self", NULL
25366 };
25367
25368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25370 if (SWIG_arg_fail(1)) SWIG_fail;
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 result = (int)(arg1)->GetFlags();
25374
25375 wxPyEndAllowThreads(__tstate);
25376 if (PyErr_Occurred()) SWIG_fail;
25377 }
25378 {
25379 resultobj = SWIG_From_int(static_cast<int >(result));
25380 }
25381 return resultobj;
25382 fail:
25383 return NULL;
25384 }
25385
25386
25387 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25388 PyObject *resultobj = NULL;
25389 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25390 int result;
25391 PyObject * obj0 = 0 ;
25392 char *kwnames[] = {
25393 (char *) "self", NULL
25394 };
25395
25396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25398 if (SWIG_arg_fail(1)) SWIG_fail;
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 result = (int)(arg1)->GetKeyCode();
25402
25403 wxPyEndAllowThreads(__tstate);
25404 if (PyErr_Occurred()) SWIG_fail;
25405 }
25406 {
25407 resultobj = SWIG_From_int(static_cast<int >(result));
25408 }
25409 return resultobj;
25410 fail:
25411 return NULL;
25412 }
25413
25414
25415 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25416 PyObject *resultobj = NULL;
25417 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25418 int result;
25419 PyObject * obj0 = 0 ;
25420 char *kwnames[] = {
25421 (char *) "self", NULL
25422 };
25423
25424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25426 if (SWIG_arg_fail(1)) SWIG_fail;
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (int)(arg1)->GetCommand();
25430
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 {
25435 resultobj = SWIG_From_int(static_cast<int >(result));
25436 }
25437 return resultobj;
25438 fail:
25439 return NULL;
25440 }
25441
25442
25443 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25444 PyObject *obj;
25445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25446 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25447 Py_INCREF(obj);
25448 return Py_BuildValue((char *)"");
25449 }
25450 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj = NULL;
25452 int arg1 ;
25453 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25454 wxAcceleratorTable *result;
25455 PyObject * obj0 = 0 ;
25456 char *kwnames[] = {
25457 (char *) "n", NULL
25458 };
25459
25460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25461 {
25462 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25463 if (arg2) arg1 = PyList_Size(obj0);
25464 else arg1 = 0;
25465 }
25466 {
25467 PyThreadState* __tstate = wxPyBeginAllowThreads();
25468 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25469
25470 wxPyEndAllowThreads(__tstate);
25471 if (PyErr_Occurred()) SWIG_fail;
25472 }
25473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25474 {
25475 delete [] arg2;
25476 }
25477 return resultobj;
25478 fail:
25479 {
25480 delete [] arg2;
25481 }
25482 return NULL;
25483 }
25484
25485
25486 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25487 PyObject *resultobj = NULL;
25488 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25489 PyObject * obj0 = 0 ;
25490 char *kwnames[] = {
25491 (char *) "self", NULL
25492 };
25493
25494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25496 if (SWIG_arg_fail(1)) SWIG_fail;
25497 {
25498 PyThreadState* __tstate = wxPyBeginAllowThreads();
25499 delete arg1;
25500
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 Py_INCREF(Py_None); resultobj = Py_None;
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25512 PyObject *resultobj = NULL;
25513 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25514 bool result;
25515 PyObject * obj0 = 0 ;
25516 char *kwnames[] = {
25517 (char *) "self", NULL
25518 };
25519
25520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25522 if (SWIG_arg_fail(1)) SWIG_fail;
25523 {
25524 PyThreadState* __tstate = wxPyBeginAllowThreads();
25525 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25526
25527 wxPyEndAllowThreads(__tstate);
25528 if (PyErr_Occurred()) SWIG_fail;
25529 }
25530 {
25531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25532 }
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25540 PyObject *obj;
25541 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25542 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25543 Py_INCREF(obj);
25544 return Py_BuildValue((char *)"");
25545 }
25546 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25547 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25548 return 1;
25549 }
25550
25551
25552 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25553 PyObject *pyobj = NULL;
25554
25555 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25556 return pyobj;
25557 }
25558
25559
25560 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25561 PyObject *resultobj = NULL;
25562 wxString *arg1 = 0 ;
25563 wxAcceleratorEntry *result;
25564 bool temp1 = false ;
25565 PyObject * obj0 = 0 ;
25566 char *kwnames[] = {
25567 (char *) "label", NULL
25568 };
25569
25570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25571 {
25572 arg1 = wxString_in_helper(obj0);
25573 if (arg1 == NULL) SWIG_fail;
25574 temp1 = true;
25575 }
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25579
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25584 {
25585 if (temp1)
25586 delete arg1;
25587 }
25588 return resultobj;
25589 fail:
25590 {
25591 if (temp1)
25592 delete arg1;
25593 }
25594 return NULL;
25595 }
25596
25597
25598 static int _wrap_PanelNameStr_set(PyObject *) {
25599 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25600 return 1;
25601 }
25602
25603
25604 static PyObject *_wrap_PanelNameStr_get(void) {
25605 PyObject *pyobj = NULL;
25606
25607 {
25608 #if wxUSE_UNICODE
25609 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25610 #else
25611 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25612 #endif
25613 }
25614 return pyobj;
25615 }
25616
25617
25618 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25619 PyObject *resultobj = NULL;
25620 wxVisualAttributes *result;
25621 char *kwnames[] = {
25622 NULL
25623 };
25624
25625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25626 {
25627 PyThreadState* __tstate = wxPyBeginAllowThreads();
25628 result = (wxVisualAttributes *)new_wxVisualAttributes();
25629
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25641 PyObject *resultobj = NULL;
25642 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25643 PyObject * obj0 = 0 ;
25644 char *kwnames[] = {
25645 (char *) "self", NULL
25646 };
25647
25648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25650 if (SWIG_arg_fail(1)) SWIG_fail;
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 delete_wxVisualAttributes(arg1);
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 Py_INCREF(Py_None); resultobj = Py_None;
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25666 PyObject *resultobj = NULL;
25667 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25668 wxFont *arg2 = (wxFont *) 0 ;
25669 PyObject * obj0 = 0 ;
25670 PyObject * obj1 = 0 ;
25671 char *kwnames[] = {
25672 (char *) "self",(char *) "font", NULL
25673 };
25674
25675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25677 if (SWIG_arg_fail(1)) SWIG_fail;
25678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25679 if (SWIG_arg_fail(2)) SWIG_fail;
25680 if (arg1) (arg1)->font = *arg2;
25681
25682 Py_INCREF(Py_None); resultobj = Py_None;
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25690 PyObject *resultobj = NULL;
25691 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25692 wxFont *result;
25693 PyObject * obj0 = 0 ;
25694 char *kwnames[] = {
25695 (char *) "self", NULL
25696 };
25697
25698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25700 if (SWIG_arg_fail(1)) SWIG_fail;
25701 result = (wxFont *)& ((arg1)->font);
25702
25703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj = NULL;
25712 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25713 wxColour *arg2 = (wxColour *) 0 ;
25714 PyObject * obj0 = 0 ;
25715 PyObject * obj1 = 0 ;
25716 char *kwnames[] = {
25717 (char *) "self",(char *) "colFg", NULL
25718 };
25719
25720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25722 if (SWIG_arg_fail(1)) SWIG_fail;
25723 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25724 if (SWIG_arg_fail(2)) SWIG_fail;
25725 if (arg1) (arg1)->colFg = *arg2;
25726
25727 Py_INCREF(Py_None); resultobj = Py_None;
25728 return resultobj;
25729 fail:
25730 return NULL;
25731 }
25732
25733
25734 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25735 PyObject *resultobj = NULL;
25736 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25737 wxColour *result;
25738 PyObject * obj0 = 0 ;
25739 char *kwnames[] = {
25740 (char *) "self", NULL
25741 };
25742
25743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25745 if (SWIG_arg_fail(1)) SWIG_fail;
25746 result = (wxColour *)& ((arg1)->colFg);
25747
25748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25749 return resultobj;
25750 fail:
25751 return NULL;
25752 }
25753
25754
25755 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25756 PyObject *resultobj = NULL;
25757 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25758 wxColour *arg2 = (wxColour *) 0 ;
25759 PyObject * obj0 = 0 ;
25760 PyObject * obj1 = 0 ;
25761 char *kwnames[] = {
25762 (char *) "self",(char *) "colBg", NULL
25763 };
25764
25765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25767 if (SWIG_arg_fail(1)) SWIG_fail;
25768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25769 if (SWIG_arg_fail(2)) SWIG_fail;
25770 if (arg1) (arg1)->colBg = *arg2;
25771
25772 Py_INCREF(Py_None); resultobj = Py_None;
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25780 PyObject *resultobj = NULL;
25781 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25782 wxColour *result;
25783 PyObject * obj0 = 0 ;
25784 char *kwnames[] = {
25785 (char *) "self", NULL
25786 };
25787
25788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25790 if (SWIG_arg_fail(1)) SWIG_fail;
25791 result = (wxColour *)& ((arg1)->colBg);
25792
25793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25794 return resultobj;
25795 fail:
25796 return NULL;
25797 }
25798
25799
25800 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25801 PyObject *obj;
25802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25803 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25804 Py_INCREF(obj);
25805 return Py_BuildValue((char *)"");
25806 }
25807 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj = NULL;
25809 wxWindow *arg1 = (wxWindow *) 0 ;
25810 int arg2 = (int) (int)-1 ;
25811 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25812 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25813 wxSize const &arg4_defvalue = wxDefaultSize ;
25814 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25815 long arg5 = (long) 0 ;
25816 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25817 wxString *arg6 = (wxString *) &arg6_defvalue ;
25818 wxWindow *result;
25819 wxPoint temp3 ;
25820 wxSize temp4 ;
25821 bool temp6 = false ;
25822 PyObject * obj0 = 0 ;
25823 PyObject * obj1 = 0 ;
25824 PyObject * obj2 = 0 ;
25825 PyObject * obj3 = 0 ;
25826 PyObject * obj4 = 0 ;
25827 PyObject * obj5 = 0 ;
25828 char *kwnames[] = {
25829 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25830 };
25831
25832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25834 if (SWIG_arg_fail(1)) SWIG_fail;
25835 if (obj1) {
25836 {
25837 arg2 = static_cast<int const >(SWIG_As_int(obj1));
25838 if (SWIG_arg_fail(2)) SWIG_fail;
25839 }
25840 }
25841 if (obj2) {
25842 {
25843 arg3 = &temp3;
25844 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25845 }
25846 }
25847 if (obj3) {
25848 {
25849 arg4 = &temp4;
25850 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25851 }
25852 }
25853 if (obj4) {
25854 {
25855 arg5 = static_cast<long >(SWIG_As_long(obj4));
25856 if (SWIG_arg_fail(5)) SWIG_fail;
25857 }
25858 }
25859 if (obj5) {
25860 {
25861 arg6 = wxString_in_helper(obj5);
25862 if (arg6 == NULL) SWIG_fail;
25863 temp6 = true;
25864 }
25865 }
25866 {
25867 if (!wxPyCheckForApp()) SWIG_fail;
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25870
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25875 {
25876 if (temp6)
25877 delete arg6;
25878 }
25879 return resultobj;
25880 fail:
25881 {
25882 if (temp6)
25883 delete arg6;
25884 }
25885 return NULL;
25886 }
25887
25888
25889 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25890 PyObject *resultobj = NULL;
25891 wxWindow *result;
25892 char *kwnames[] = {
25893 NULL
25894 };
25895
25896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25897 {
25898 if (!wxPyCheckForApp()) SWIG_fail;
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 result = (wxWindow *)new wxWindow();
25901
25902 wxPyEndAllowThreads(__tstate);
25903 if (PyErr_Occurred()) SWIG_fail;
25904 }
25905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25906 return resultobj;
25907 fail:
25908 return NULL;
25909 }
25910
25911
25912 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25913 PyObject *resultobj = NULL;
25914 wxWindow *arg1 = (wxWindow *) 0 ;
25915 wxWindow *arg2 = (wxWindow *) 0 ;
25916 int arg3 = (int) (int)-1 ;
25917 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25918 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25919 wxSize const &arg5_defvalue = wxDefaultSize ;
25920 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25921 long arg6 = (long) 0 ;
25922 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25923 wxString *arg7 = (wxString *) &arg7_defvalue ;
25924 bool result;
25925 wxPoint temp4 ;
25926 wxSize temp5 ;
25927 bool temp7 = false ;
25928 PyObject * obj0 = 0 ;
25929 PyObject * obj1 = 0 ;
25930 PyObject * obj2 = 0 ;
25931 PyObject * obj3 = 0 ;
25932 PyObject * obj4 = 0 ;
25933 PyObject * obj5 = 0 ;
25934 PyObject * obj6 = 0 ;
25935 char *kwnames[] = {
25936 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25937 };
25938
25939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25941 if (SWIG_arg_fail(1)) SWIG_fail;
25942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25943 if (SWIG_arg_fail(2)) SWIG_fail;
25944 if (obj2) {
25945 {
25946 arg3 = static_cast<int const >(SWIG_As_int(obj2));
25947 if (SWIG_arg_fail(3)) SWIG_fail;
25948 }
25949 }
25950 if (obj3) {
25951 {
25952 arg4 = &temp4;
25953 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25954 }
25955 }
25956 if (obj4) {
25957 {
25958 arg5 = &temp5;
25959 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25960 }
25961 }
25962 if (obj5) {
25963 {
25964 arg6 = static_cast<long >(SWIG_As_long(obj5));
25965 if (SWIG_arg_fail(6)) SWIG_fail;
25966 }
25967 }
25968 if (obj6) {
25969 {
25970 arg7 = wxString_in_helper(obj6);
25971 if (arg7 == NULL) SWIG_fail;
25972 temp7 = true;
25973 }
25974 }
25975 {
25976 PyThreadState* __tstate = wxPyBeginAllowThreads();
25977 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25978
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 {
25983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25984 }
25985 {
25986 if (temp7)
25987 delete arg7;
25988 }
25989 return resultobj;
25990 fail:
25991 {
25992 if (temp7)
25993 delete arg7;
25994 }
25995 return NULL;
25996 }
25997
25998
25999 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj = NULL;
26001 wxWindow *arg1 = (wxWindow *) 0 ;
26002 bool arg2 = (bool) false ;
26003 bool result;
26004 PyObject * obj0 = 0 ;
26005 PyObject * obj1 = 0 ;
26006 char *kwnames[] = {
26007 (char *) "self",(char *) "force", NULL
26008 };
26009
26010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26012 if (SWIG_arg_fail(1)) SWIG_fail;
26013 if (obj1) {
26014 {
26015 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26016 if (SWIG_arg_fail(2)) SWIG_fail;
26017 }
26018 }
26019 {
26020 PyThreadState* __tstate = wxPyBeginAllowThreads();
26021 result = (bool)(arg1)->Close(arg2);
26022
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 {
26027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26028 }
26029 return resultobj;
26030 fail:
26031 return NULL;
26032 }
26033
26034
26035 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26036 PyObject *resultobj = NULL;
26037 wxWindow *arg1 = (wxWindow *) 0 ;
26038 bool result;
26039 PyObject * obj0 = 0 ;
26040 char *kwnames[] = {
26041 (char *) "self", NULL
26042 };
26043
26044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26046 if (SWIG_arg_fail(1)) SWIG_fail;
26047 {
26048 PyThreadState* __tstate = wxPyBeginAllowThreads();
26049 result = (bool)(arg1)->Destroy();
26050
26051 wxPyEndAllowThreads(__tstate);
26052 if (PyErr_Occurred()) SWIG_fail;
26053 }
26054 {
26055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26056 }
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26064 PyObject *resultobj = NULL;
26065 wxWindow *arg1 = (wxWindow *) 0 ;
26066 bool result;
26067 PyObject * obj0 = 0 ;
26068 char *kwnames[] = {
26069 (char *) "self", NULL
26070 };
26071
26072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26074 if (SWIG_arg_fail(1)) SWIG_fail;
26075 {
26076 PyThreadState* __tstate = wxPyBeginAllowThreads();
26077 result = (bool)(arg1)->DestroyChildren();
26078
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 {
26083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26084 }
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj = NULL;
26093 wxWindow *arg1 = (wxWindow *) 0 ;
26094 bool result;
26095 PyObject * obj0 = 0 ;
26096 char *kwnames[] = {
26097 (char *) "self", NULL
26098 };
26099
26100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26102 if (SWIG_arg_fail(1)) SWIG_fail;
26103 {
26104 PyThreadState* __tstate = wxPyBeginAllowThreads();
26105 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26106
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 {
26111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26112 }
26113 return resultobj;
26114 fail:
26115 return NULL;
26116 }
26117
26118
26119 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26120 PyObject *resultobj = NULL;
26121 wxWindow *arg1 = (wxWindow *) 0 ;
26122 wxString *arg2 = 0 ;
26123 bool temp2 = false ;
26124 PyObject * obj0 = 0 ;
26125 PyObject * obj1 = 0 ;
26126 char *kwnames[] = {
26127 (char *) "self",(char *) "label", NULL
26128 };
26129
26130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26132 if (SWIG_arg_fail(1)) SWIG_fail;
26133 {
26134 arg2 = wxString_in_helper(obj1);
26135 if (arg2 == NULL) SWIG_fail;
26136 temp2 = true;
26137 }
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 (arg1)->SetLabel((wxString const &)*arg2);
26141
26142 wxPyEndAllowThreads(__tstate);
26143 if (PyErr_Occurred()) SWIG_fail;
26144 }
26145 Py_INCREF(Py_None); resultobj = Py_None;
26146 {
26147 if (temp2)
26148 delete arg2;
26149 }
26150 return resultobj;
26151 fail:
26152 {
26153 if (temp2)
26154 delete arg2;
26155 }
26156 return NULL;
26157 }
26158
26159
26160 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj = NULL;
26162 wxWindow *arg1 = (wxWindow *) 0 ;
26163 wxString result;
26164 PyObject * obj0 = 0 ;
26165 char *kwnames[] = {
26166 (char *) "self", NULL
26167 };
26168
26169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26171 if (SWIG_arg_fail(1)) SWIG_fail;
26172 {
26173 PyThreadState* __tstate = wxPyBeginAllowThreads();
26174 result = ((wxWindow const *)arg1)->GetLabel();
26175
26176 wxPyEndAllowThreads(__tstate);
26177 if (PyErr_Occurred()) SWIG_fail;
26178 }
26179 {
26180 #if wxUSE_UNICODE
26181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26182 #else
26183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26184 #endif
26185 }
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26193 PyObject *resultobj = NULL;
26194 wxWindow *arg1 = (wxWindow *) 0 ;
26195 wxString *arg2 = 0 ;
26196 bool temp2 = false ;
26197 PyObject * obj0 = 0 ;
26198 PyObject * obj1 = 0 ;
26199 char *kwnames[] = {
26200 (char *) "self",(char *) "name", NULL
26201 };
26202
26203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26205 if (SWIG_arg_fail(1)) SWIG_fail;
26206 {
26207 arg2 = wxString_in_helper(obj1);
26208 if (arg2 == NULL) SWIG_fail;
26209 temp2 = true;
26210 }
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 (arg1)->SetName((wxString const &)*arg2);
26214
26215 wxPyEndAllowThreads(__tstate);
26216 if (PyErr_Occurred()) SWIG_fail;
26217 }
26218 Py_INCREF(Py_None); resultobj = Py_None;
26219 {
26220 if (temp2)
26221 delete arg2;
26222 }
26223 return resultobj;
26224 fail:
26225 {
26226 if (temp2)
26227 delete arg2;
26228 }
26229 return NULL;
26230 }
26231
26232
26233 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26234 PyObject *resultobj = NULL;
26235 wxWindow *arg1 = (wxWindow *) 0 ;
26236 wxString result;
26237 PyObject * obj0 = 0 ;
26238 char *kwnames[] = {
26239 (char *) "self", NULL
26240 };
26241
26242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26244 if (SWIG_arg_fail(1)) SWIG_fail;
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 result = ((wxWindow const *)arg1)->GetName();
26248
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 {
26253 #if wxUSE_UNICODE
26254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26255 #else
26256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26257 #endif
26258 }
26259 return resultobj;
26260 fail:
26261 return NULL;
26262 }
26263
26264
26265 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26266 PyObject *resultobj = NULL;
26267 wxWindow *arg1 = (wxWindow *) 0 ;
26268 wxWindowVariant arg2 ;
26269 PyObject * obj0 = 0 ;
26270 PyObject * obj1 = 0 ;
26271 char *kwnames[] = {
26272 (char *) "self",(char *) "variant", NULL
26273 };
26274
26275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26277 if (SWIG_arg_fail(1)) SWIG_fail;
26278 {
26279 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26280 if (SWIG_arg_fail(2)) SWIG_fail;
26281 }
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 (arg1)->SetWindowVariant(arg2);
26285
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 Py_INCREF(Py_None); resultobj = Py_None;
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26297 PyObject *resultobj = NULL;
26298 wxWindow *arg1 = (wxWindow *) 0 ;
26299 wxWindowVariant result;
26300 PyObject * obj0 = 0 ;
26301 char *kwnames[] = {
26302 (char *) "self", NULL
26303 };
26304
26305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26307 if (SWIG_arg_fail(1)) SWIG_fail;
26308 {
26309 PyThreadState* __tstate = wxPyBeginAllowThreads();
26310 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26311
26312 wxPyEndAllowThreads(__tstate);
26313 if (PyErr_Occurred()) SWIG_fail;
26314 }
26315 resultobj = SWIG_From_int((result));
26316 return resultobj;
26317 fail:
26318 return NULL;
26319 }
26320
26321
26322 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj = NULL;
26324 wxWindow *arg1 = (wxWindow *) 0 ;
26325 int arg2 ;
26326 PyObject * obj0 = 0 ;
26327 PyObject * obj1 = 0 ;
26328 char *kwnames[] = {
26329 (char *) "self",(char *) "winid", NULL
26330 };
26331
26332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) 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 arg2 = static_cast<int >(SWIG_As_int(obj1));
26337 if (SWIG_arg_fail(2)) SWIG_fail;
26338 }
26339 {
26340 PyThreadState* __tstate = wxPyBeginAllowThreads();
26341 (arg1)->SetId(arg2);
26342
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 Py_INCREF(Py_None); resultobj = Py_None;
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj = NULL;
26355 wxWindow *arg1 = (wxWindow *) 0 ;
26356 int result;
26357 PyObject * obj0 = 0 ;
26358 char *kwnames[] = {
26359 (char *) "self", NULL
26360 };
26361
26362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26364 if (SWIG_arg_fail(1)) SWIG_fail;
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = (int)((wxWindow const *)arg1)->GetId();
26368
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 {
26373 resultobj = SWIG_From_int(static_cast<int >(result));
26374 }
26375 return resultobj;
26376 fail:
26377 return NULL;
26378 }
26379
26380
26381 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26382 PyObject *resultobj = NULL;
26383 int result;
26384 char *kwnames[] = {
26385 NULL
26386 };
26387
26388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26389 {
26390 PyThreadState* __tstate = wxPyBeginAllowThreads();
26391 result = (int)wxWindow::NewControlId();
26392
26393 wxPyEndAllowThreads(__tstate);
26394 if (PyErr_Occurred()) SWIG_fail;
26395 }
26396 {
26397 resultobj = SWIG_From_int(static_cast<int >(result));
26398 }
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26406 PyObject *resultobj = NULL;
26407 int arg1 ;
26408 int result;
26409 PyObject * obj0 = 0 ;
26410 char *kwnames[] = {
26411 (char *) "winid", NULL
26412 };
26413
26414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26415 {
26416 arg1 = static_cast<int >(SWIG_As_int(obj0));
26417 if (SWIG_arg_fail(1)) SWIG_fail;
26418 }
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 result = (int)wxWindow::NextControlId(arg1);
26422
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 {
26427 resultobj = SWIG_From_int(static_cast<int >(result));
26428 }
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26436 PyObject *resultobj = NULL;
26437 int arg1 ;
26438 int result;
26439 PyObject * obj0 = 0 ;
26440 char *kwnames[] = {
26441 (char *) "winid", NULL
26442 };
26443
26444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26445 {
26446 arg1 = static_cast<int >(SWIG_As_int(obj0));
26447 if (SWIG_arg_fail(1)) SWIG_fail;
26448 }
26449 {
26450 PyThreadState* __tstate = wxPyBeginAllowThreads();
26451 result = (int)wxWindow::PrevControlId(arg1);
26452
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 {
26457 resultobj = SWIG_From_int(static_cast<int >(result));
26458 }
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26466 PyObject *resultobj = NULL;
26467 wxWindow *arg1 = (wxWindow *) 0 ;
26468 wxSize *arg2 = 0 ;
26469 wxSize temp2 ;
26470 PyObject * obj0 = 0 ;
26471 PyObject * obj1 = 0 ;
26472 char *kwnames[] = {
26473 (char *) "self",(char *) "size", NULL
26474 };
26475
26476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26478 if (SWIG_arg_fail(1)) SWIG_fail;
26479 {
26480 arg2 = &temp2;
26481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26482 }
26483 {
26484 PyThreadState* __tstate = wxPyBeginAllowThreads();
26485 (arg1)->SetSize((wxSize const &)*arg2);
26486
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 Py_INCREF(Py_None); resultobj = Py_None;
26491 return resultobj;
26492 fail:
26493 return NULL;
26494 }
26495
26496
26497 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26498 PyObject *resultobj = NULL;
26499 wxWindow *arg1 = (wxWindow *) 0 ;
26500 int arg2 ;
26501 int arg3 ;
26502 int arg4 ;
26503 int arg5 ;
26504 int arg6 = (int) wxSIZE_AUTO ;
26505 PyObject * obj0 = 0 ;
26506 PyObject * obj1 = 0 ;
26507 PyObject * obj2 = 0 ;
26508 PyObject * obj3 = 0 ;
26509 PyObject * obj4 = 0 ;
26510 PyObject * obj5 = 0 ;
26511 char *kwnames[] = {
26512 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26513 };
26514
26515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26517 if (SWIG_arg_fail(1)) SWIG_fail;
26518 {
26519 arg2 = static_cast<int >(SWIG_As_int(obj1));
26520 if (SWIG_arg_fail(2)) SWIG_fail;
26521 }
26522 {
26523 arg3 = static_cast<int >(SWIG_As_int(obj2));
26524 if (SWIG_arg_fail(3)) SWIG_fail;
26525 }
26526 {
26527 arg4 = static_cast<int >(SWIG_As_int(obj3));
26528 if (SWIG_arg_fail(4)) SWIG_fail;
26529 }
26530 {
26531 arg5 = static_cast<int >(SWIG_As_int(obj4));
26532 if (SWIG_arg_fail(5)) SWIG_fail;
26533 }
26534 if (obj5) {
26535 {
26536 arg6 = static_cast<int >(SWIG_As_int(obj5));
26537 if (SWIG_arg_fail(6)) SWIG_fail;
26538 }
26539 }
26540 {
26541 PyThreadState* __tstate = wxPyBeginAllowThreads();
26542 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26543
26544 wxPyEndAllowThreads(__tstate);
26545 if (PyErr_Occurred()) SWIG_fail;
26546 }
26547 Py_INCREF(Py_None); resultobj = Py_None;
26548 return resultobj;
26549 fail:
26550 return NULL;
26551 }
26552
26553
26554 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26555 PyObject *resultobj = NULL;
26556 wxWindow *arg1 = (wxWindow *) 0 ;
26557 wxRect *arg2 = 0 ;
26558 int arg3 = (int) wxSIZE_AUTO ;
26559 wxRect temp2 ;
26560 PyObject * obj0 = 0 ;
26561 PyObject * obj1 = 0 ;
26562 PyObject * obj2 = 0 ;
26563 char *kwnames[] = {
26564 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26565 };
26566
26567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26569 if (SWIG_arg_fail(1)) SWIG_fail;
26570 {
26571 arg2 = &temp2;
26572 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26573 }
26574 if (obj2) {
26575 {
26576 arg3 = static_cast<int >(SWIG_As_int(obj2));
26577 if (SWIG_arg_fail(3)) SWIG_fail;
26578 }
26579 }
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26583
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 Py_INCREF(Py_None); resultobj = Py_None;
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26595 PyObject *resultobj = NULL;
26596 wxWindow *arg1 = (wxWindow *) 0 ;
26597 int arg2 ;
26598 int arg3 ;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601 PyObject * obj2 = 0 ;
26602 char *kwnames[] = {
26603 (char *) "self",(char *) "width",(char *) "height", NULL
26604 };
26605
26606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26608 if (SWIG_arg_fail(1)) SWIG_fail;
26609 {
26610 arg2 = static_cast<int >(SWIG_As_int(obj1));
26611 if (SWIG_arg_fail(2)) SWIG_fail;
26612 }
26613 {
26614 arg3 = static_cast<int >(SWIG_As_int(obj2));
26615 if (SWIG_arg_fail(3)) SWIG_fail;
26616 }
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 (arg1)->SetSize(arg2,arg3);
26620
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 Py_INCREF(Py_None); resultobj = Py_None;
26625 return resultobj;
26626 fail:
26627 return NULL;
26628 }
26629
26630
26631 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26632 PyObject *resultobj = NULL;
26633 wxWindow *arg1 = (wxWindow *) 0 ;
26634 wxPoint *arg2 = 0 ;
26635 int arg3 = (int) wxSIZE_USE_EXISTING ;
26636 wxPoint temp2 ;
26637 PyObject * obj0 = 0 ;
26638 PyObject * obj1 = 0 ;
26639 PyObject * obj2 = 0 ;
26640 char *kwnames[] = {
26641 (char *) "self",(char *) "pt",(char *) "flags", NULL
26642 };
26643
26644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26646 if (SWIG_arg_fail(1)) SWIG_fail;
26647 {
26648 arg2 = &temp2;
26649 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26650 }
26651 if (obj2) {
26652 {
26653 arg3 = static_cast<int >(SWIG_As_int(obj2));
26654 if (SWIG_arg_fail(3)) SWIG_fail;
26655 }
26656 }
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 (arg1)->Move((wxPoint const &)*arg2,arg3);
26660
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 Py_INCREF(Py_None); resultobj = Py_None;
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26672 PyObject *resultobj = NULL;
26673 wxWindow *arg1 = (wxWindow *) 0 ;
26674 int arg2 ;
26675 int arg3 ;
26676 int arg4 = (int) wxSIZE_USE_EXISTING ;
26677 PyObject * obj0 = 0 ;
26678 PyObject * obj1 = 0 ;
26679 PyObject * obj2 = 0 ;
26680 PyObject * obj3 = 0 ;
26681 char *kwnames[] = {
26682 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26683 };
26684
26685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26687 if (SWIG_arg_fail(1)) SWIG_fail;
26688 {
26689 arg2 = static_cast<int >(SWIG_As_int(obj1));
26690 if (SWIG_arg_fail(2)) SWIG_fail;
26691 }
26692 {
26693 arg3 = static_cast<int >(SWIG_As_int(obj2));
26694 if (SWIG_arg_fail(3)) SWIG_fail;
26695 }
26696 if (obj3) {
26697 {
26698 arg4 = static_cast<int >(SWIG_As_int(obj3));
26699 if (SWIG_arg_fail(4)) SWIG_fail;
26700 }
26701 }
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 (arg1)->Move(arg2,arg3,arg4);
26705
26706 wxPyEndAllowThreads(__tstate);
26707 if (PyErr_Occurred()) SWIG_fail;
26708 }
26709 Py_INCREF(Py_None); resultobj = Py_None;
26710 return resultobj;
26711 fail:
26712 return NULL;
26713 }
26714
26715
26716 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26717 PyObject *resultobj = NULL;
26718 wxWindow *arg1 = (wxWindow *) 0 ;
26719 wxSize const &arg2_defvalue = wxDefaultSize ;
26720 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26721 wxSize temp2 ;
26722 PyObject * obj0 = 0 ;
26723 PyObject * obj1 = 0 ;
26724 char *kwnames[] = {
26725 (char *) "self",(char *) "size", NULL
26726 };
26727
26728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26730 if (SWIG_arg_fail(1)) SWIG_fail;
26731 if (obj1) {
26732 {
26733 arg2 = &temp2;
26734 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26735 }
26736 }
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26740
26741 wxPyEndAllowThreads(__tstate);
26742 if (PyErr_Occurred()) SWIG_fail;
26743 }
26744 Py_INCREF(Py_None); resultobj = Py_None;
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj = NULL;
26753 wxWindow *arg1 = (wxWindow *) 0 ;
26754 PyObject * obj0 = 0 ;
26755 char *kwnames[] = {
26756 (char *) "self", NULL
26757 };
26758
26759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26761 if (SWIG_arg_fail(1)) SWIG_fail;
26762 {
26763 PyThreadState* __tstate = wxPyBeginAllowThreads();
26764 (arg1)->Raise();
26765
26766 wxPyEndAllowThreads(__tstate);
26767 if (PyErr_Occurred()) SWIG_fail;
26768 }
26769 Py_INCREF(Py_None); resultobj = Py_None;
26770 return resultobj;
26771 fail:
26772 return NULL;
26773 }
26774
26775
26776 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26777 PyObject *resultobj = NULL;
26778 wxWindow *arg1 = (wxWindow *) 0 ;
26779 PyObject * obj0 = 0 ;
26780 char *kwnames[] = {
26781 (char *) "self", NULL
26782 };
26783
26784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26786 if (SWIG_arg_fail(1)) SWIG_fail;
26787 {
26788 PyThreadState* __tstate = wxPyBeginAllowThreads();
26789 (arg1)->Lower();
26790
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 Py_INCREF(Py_None); resultobj = Py_None;
26795 return resultobj;
26796 fail:
26797 return NULL;
26798 }
26799
26800
26801 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26802 PyObject *resultobj = NULL;
26803 wxWindow *arg1 = (wxWindow *) 0 ;
26804 wxSize *arg2 = 0 ;
26805 wxSize temp2 ;
26806 PyObject * obj0 = 0 ;
26807 PyObject * obj1 = 0 ;
26808 char *kwnames[] = {
26809 (char *) "self",(char *) "size", NULL
26810 };
26811
26812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26814 if (SWIG_arg_fail(1)) SWIG_fail;
26815 {
26816 arg2 = &temp2;
26817 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26818 }
26819 {
26820 PyThreadState* __tstate = wxPyBeginAllowThreads();
26821 (arg1)->SetClientSize((wxSize const &)*arg2);
26822
26823 wxPyEndAllowThreads(__tstate);
26824 if (PyErr_Occurred()) SWIG_fail;
26825 }
26826 Py_INCREF(Py_None); resultobj = Py_None;
26827 return resultobj;
26828 fail:
26829 return NULL;
26830 }
26831
26832
26833 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26834 PyObject *resultobj = NULL;
26835 wxWindow *arg1 = (wxWindow *) 0 ;
26836 int arg2 ;
26837 int arg3 ;
26838 PyObject * obj0 = 0 ;
26839 PyObject * obj1 = 0 ;
26840 PyObject * obj2 = 0 ;
26841 char *kwnames[] = {
26842 (char *) "self",(char *) "width",(char *) "height", NULL
26843 };
26844
26845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26847 if (SWIG_arg_fail(1)) SWIG_fail;
26848 {
26849 arg2 = static_cast<int >(SWIG_As_int(obj1));
26850 if (SWIG_arg_fail(2)) SWIG_fail;
26851 }
26852 {
26853 arg3 = static_cast<int >(SWIG_As_int(obj2));
26854 if (SWIG_arg_fail(3)) SWIG_fail;
26855 }
26856 {
26857 PyThreadState* __tstate = wxPyBeginAllowThreads();
26858 (arg1)->SetClientSize(arg2,arg3);
26859
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 Py_INCREF(Py_None); resultobj = Py_None;
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26871 PyObject *resultobj = NULL;
26872 wxWindow *arg1 = (wxWindow *) 0 ;
26873 wxRect *arg2 = 0 ;
26874 wxRect temp2 ;
26875 PyObject * obj0 = 0 ;
26876 PyObject * obj1 = 0 ;
26877 char *kwnames[] = {
26878 (char *) "self",(char *) "rect", NULL
26879 };
26880
26881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26883 if (SWIG_arg_fail(1)) SWIG_fail;
26884 {
26885 arg2 = &temp2;
26886 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26887 }
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 (arg1)->SetClientSize((wxRect const &)*arg2);
26891
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 Py_INCREF(Py_None); resultobj = Py_None;
26896 return resultobj;
26897 fail:
26898 return NULL;
26899 }
26900
26901
26902 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj = NULL;
26904 wxWindow *arg1 = (wxWindow *) 0 ;
26905 wxPoint result;
26906 PyObject * obj0 = 0 ;
26907 char *kwnames[] = {
26908 (char *) "self", NULL
26909 };
26910
26911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26913 if (SWIG_arg_fail(1)) SWIG_fail;
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 result = (arg1)->GetPosition();
26917
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 {
26922 wxPoint * resultptr;
26923 resultptr = new wxPoint(static_cast<wxPoint & >(result));
26924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26925 }
26926 return resultobj;
26927 fail:
26928 return NULL;
26929 }
26930
26931
26932 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26933 PyObject *resultobj = NULL;
26934 wxWindow *arg1 = (wxWindow *) 0 ;
26935 int *arg2 = (int *) 0 ;
26936 int *arg3 = (int *) 0 ;
26937 int temp2 ;
26938 int res2 = 0 ;
26939 int temp3 ;
26940 int res3 = 0 ;
26941 PyObject * obj0 = 0 ;
26942 char *kwnames[] = {
26943 (char *) "self", NULL
26944 };
26945
26946 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26947 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26950 if (SWIG_arg_fail(1)) SWIG_fail;
26951 {
26952 PyThreadState* __tstate = wxPyBeginAllowThreads();
26953 (arg1)->GetPosition(arg2,arg3);
26954
26955 wxPyEndAllowThreads(__tstate);
26956 if (PyErr_Occurred()) SWIG_fail;
26957 }
26958 Py_INCREF(Py_None); resultobj = Py_None;
26959 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26960 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26961 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26962 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26963 return resultobj;
26964 fail:
26965 return NULL;
26966 }
26967
26968
26969 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26970 PyObject *resultobj = NULL;
26971 wxWindow *arg1 = (wxWindow *) 0 ;
26972 wxSize result;
26973 PyObject * obj0 = 0 ;
26974 char *kwnames[] = {
26975 (char *) "self", NULL
26976 };
26977
26978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26980 if (SWIG_arg_fail(1)) SWIG_fail;
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = ((wxWindow const *)arg1)->GetSize();
26984
26985 wxPyEndAllowThreads(__tstate);
26986 if (PyErr_Occurred()) SWIG_fail;
26987 }
26988 {
26989 wxSize * resultptr;
26990 resultptr = new wxSize(static_cast<wxSize & >(result));
26991 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26992 }
26993 return resultobj;
26994 fail:
26995 return NULL;
26996 }
26997
26998
26999 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27000 PyObject *resultobj = NULL;
27001 wxWindow *arg1 = (wxWindow *) 0 ;
27002 int *arg2 = (int *) 0 ;
27003 int *arg3 = (int *) 0 ;
27004 int temp2 ;
27005 int res2 = 0 ;
27006 int temp3 ;
27007 int res3 = 0 ;
27008 PyObject * obj0 = 0 ;
27009 char *kwnames[] = {
27010 (char *) "self", NULL
27011 };
27012
27013 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27014 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27017 if (SWIG_arg_fail(1)) SWIG_fail;
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27021
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 Py_INCREF(Py_None); resultobj = Py_None;
27026 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27027 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27028 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27029 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27037 PyObject *resultobj = NULL;
27038 wxWindow *arg1 = (wxWindow *) 0 ;
27039 wxRect result;
27040 PyObject * obj0 = 0 ;
27041 char *kwnames[] = {
27042 (char *) "self", NULL
27043 };
27044
27045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27047 if (SWIG_arg_fail(1)) SWIG_fail;
27048 {
27049 PyThreadState* __tstate = wxPyBeginAllowThreads();
27050 result = ((wxWindow const *)arg1)->GetRect();
27051
27052 wxPyEndAllowThreads(__tstate);
27053 if (PyErr_Occurred()) SWIG_fail;
27054 }
27055 {
27056 wxRect * resultptr;
27057 resultptr = new wxRect(static_cast<wxRect & >(result));
27058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27059 }
27060 return resultobj;
27061 fail:
27062 return NULL;
27063 }
27064
27065
27066 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27067 PyObject *resultobj = NULL;
27068 wxWindow *arg1 = (wxWindow *) 0 ;
27069 wxSize result;
27070 PyObject * obj0 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 result = ((wxWindow const *)arg1)->GetClientSize();
27081
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 {
27086 wxSize * resultptr;
27087 resultptr = new wxSize(static_cast<wxSize & >(result));
27088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27089 }
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj = NULL;
27098 wxWindow *arg1 = (wxWindow *) 0 ;
27099 int *arg2 = (int *) 0 ;
27100 int *arg3 = (int *) 0 ;
27101 int temp2 ;
27102 int res2 = 0 ;
27103 int temp3 ;
27104 int res3 = 0 ;
27105 PyObject * obj0 = 0 ;
27106 char *kwnames[] = {
27107 (char *) "self", NULL
27108 };
27109
27110 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27111 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27114 if (SWIG_arg_fail(1)) SWIG_fail;
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27118
27119 wxPyEndAllowThreads(__tstate);
27120 if (PyErr_Occurred()) SWIG_fail;
27121 }
27122 Py_INCREF(Py_None); resultobj = Py_None;
27123 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27124 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27125 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27126 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27134 PyObject *resultobj = NULL;
27135 wxWindow *arg1 = (wxWindow *) 0 ;
27136 wxPoint result;
27137 PyObject * obj0 = 0 ;
27138 char *kwnames[] = {
27139 (char *) "self", NULL
27140 };
27141
27142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27144 if (SWIG_arg_fail(1)) SWIG_fail;
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27148
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 {
27153 wxPoint * resultptr;
27154 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27156 }
27157 return resultobj;
27158 fail:
27159 return NULL;
27160 }
27161
27162
27163 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27164 PyObject *resultobj = NULL;
27165 wxWindow *arg1 = (wxWindow *) 0 ;
27166 wxRect result;
27167 PyObject * obj0 = 0 ;
27168 char *kwnames[] = {
27169 (char *) "self", NULL
27170 };
27171
27172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27174 if (SWIG_arg_fail(1)) SWIG_fail;
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = ((wxWindow const *)arg1)->GetClientRect();
27178
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 {
27183 wxRect * resultptr;
27184 resultptr = new wxRect(static_cast<wxRect & >(result));
27185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27186 }
27187 return resultobj;
27188 fail:
27189 return NULL;
27190 }
27191
27192
27193 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27194 PyObject *resultobj = NULL;
27195 wxWindow *arg1 = (wxWindow *) 0 ;
27196 wxSize result;
27197 PyObject * obj0 = 0 ;
27198 char *kwnames[] = {
27199 (char *) "self", NULL
27200 };
27201
27202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27204 if (SWIG_arg_fail(1)) SWIG_fail;
27205 {
27206 PyThreadState* __tstate = wxPyBeginAllowThreads();
27207 result = ((wxWindow const *)arg1)->GetBestSize();
27208
27209 wxPyEndAllowThreads(__tstate);
27210 if (PyErr_Occurred()) SWIG_fail;
27211 }
27212 {
27213 wxSize * resultptr;
27214 resultptr = new wxSize(static_cast<wxSize & >(result));
27215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27216 }
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj = NULL;
27225 wxWindow *arg1 = (wxWindow *) 0 ;
27226 int *arg2 = (int *) 0 ;
27227 int *arg3 = (int *) 0 ;
27228 int temp2 ;
27229 int res2 = 0 ;
27230 int temp3 ;
27231 int res3 = 0 ;
27232 PyObject * obj0 = 0 ;
27233 char *kwnames[] = {
27234 (char *) "self", NULL
27235 };
27236
27237 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27238 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27241 if (SWIG_arg_fail(1)) SWIG_fail;
27242 {
27243 PyThreadState* __tstate = wxPyBeginAllowThreads();
27244 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27245
27246 wxPyEndAllowThreads(__tstate);
27247 if (PyErr_Occurred()) SWIG_fail;
27248 }
27249 Py_INCREF(Py_None); resultobj = Py_None;
27250 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27251 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27252 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27253 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27261 PyObject *resultobj = NULL;
27262 wxWindow *arg1 = (wxWindow *) 0 ;
27263 PyObject * obj0 = 0 ;
27264 char *kwnames[] = {
27265 (char *) "self", NULL
27266 };
27267
27268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27270 if (SWIG_arg_fail(1)) SWIG_fail;
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 (arg1)->InvalidateBestSize();
27274
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 Py_INCREF(Py_None); resultobj = Py_None;
27279 return resultobj;
27280 fail:
27281 return NULL;
27282 }
27283
27284
27285 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27286 PyObject *resultobj = NULL;
27287 wxWindow *arg1 = (wxWindow *) 0 ;
27288 wxSize *arg2 = 0 ;
27289 wxSize temp2 ;
27290 PyObject * obj0 = 0 ;
27291 PyObject * obj1 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self",(char *) "size", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 {
27300 arg2 = &temp2;
27301 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27302 }
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27306
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 Py_INCREF(Py_None); resultobj = Py_None;
27311 return resultobj;
27312 fail:
27313 return NULL;
27314 }
27315
27316
27317 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27318 PyObject *resultobj = NULL;
27319 wxWindow *arg1 = (wxWindow *) 0 ;
27320 wxSize result;
27321 PyObject * obj0 = 0 ;
27322 char *kwnames[] = {
27323 (char *) "self", NULL
27324 };
27325
27326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27328 if (SWIG_arg_fail(1)) SWIG_fail;
27329 {
27330 PyThreadState* __tstate = wxPyBeginAllowThreads();
27331 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27332
27333 wxPyEndAllowThreads(__tstate);
27334 if (PyErr_Occurred()) SWIG_fail;
27335 }
27336 {
27337 wxSize * resultptr;
27338 resultptr = new wxSize(static_cast<wxSize & >(result));
27339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27340 }
27341 return resultobj;
27342 fail:
27343 return NULL;
27344 }
27345
27346
27347 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27348 PyObject *resultobj = NULL;
27349 wxWindow *arg1 = (wxWindow *) 0 ;
27350 wxSize result;
27351 PyObject * obj0 = 0 ;
27352 char *kwnames[] = {
27353 (char *) "self", NULL
27354 };
27355
27356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27358 if (SWIG_arg_fail(1)) SWIG_fail;
27359 {
27360 PyThreadState* __tstate = wxPyBeginAllowThreads();
27361 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27362
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 {
27367 wxSize * resultptr;
27368 resultptr = new wxSize(static_cast<wxSize & >(result));
27369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27370 }
27371 return resultobj;
27372 fail:
27373 return NULL;
27374 }
27375
27376
27377 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27378 PyObject *resultobj = NULL;
27379 wxWindow *arg1 = (wxWindow *) 0 ;
27380 int arg2 = (int) wxBOTH ;
27381 PyObject * obj0 = 0 ;
27382 PyObject * obj1 = 0 ;
27383 char *kwnames[] = {
27384 (char *) "self",(char *) "direction", NULL
27385 };
27386
27387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27389 if (SWIG_arg_fail(1)) SWIG_fail;
27390 if (obj1) {
27391 {
27392 arg2 = static_cast<int >(SWIG_As_int(obj1));
27393 if (SWIG_arg_fail(2)) SWIG_fail;
27394 }
27395 }
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 (arg1)->Center(arg2);
27399
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 Py_INCREF(Py_None); resultobj = Py_None;
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj = NULL;
27412 wxWindow *arg1 = (wxWindow *) 0 ;
27413 int arg2 = (int) wxBOTH ;
27414 PyObject * obj0 = 0 ;
27415 PyObject * obj1 = 0 ;
27416 char *kwnames[] = {
27417 (char *) "self",(char *) "dir", NULL
27418 };
27419
27420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27422 if (SWIG_arg_fail(1)) SWIG_fail;
27423 if (obj1) {
27424 {
27425 arg2 = static_cast<int >(SWIG_As_int(obj1));
27426 if (SWIG_arg_fail(2)) SWIG_fail;
27427 }
27428 }
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 (arg1)->CenterOnScreen(arg2);
27432
27433 wxPyEndAllowThreads(__tstate);
27434 if (PyErr_Occurred()) SWIG_fail;
27435 }
27436 Py_INCREF(Py_None); resultobj = Py_None;
27437 return resultobj;
27438 fail:
27439 return NULL;
27440 }
27441
27442
27443 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27444 PyObject *resultobj = NULL;
27445 wxWindow *arg1 = (wxWindow *) 0 ;
27446 int arg2 = (int) wxBOTH ;
27447 PyObject * obj0 = 0 ;
27448 PyObject * obj1 = 0 ;
27449 char *kwnames[] = {
27450 (char *) "self",(char *) "dir", NULL
27451 };
27452
27453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27455 if (SWIG_arg_fail(1)) SWIG_fail;
27456 if (obj1) {
27457 {
27458 arg2 = static_cast<int >(SWIG_As_int(obj1));
27459 if (SWIG_arg_fail(2)) SWIG_fail;
27460 }
27461 }
27462 {
27463 PyThreadState* __tstate = wxPyBeginAllowThreads();
27464 (arg1)->CenterOnParent(arg2);
27465
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 Py_INCREF(Py_None); resultobj = Py_None;
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27477 PyObject *resultobj = NULL;
27478 wxWindow *arg1 = (wxWindow *) 0 ;
27479 PyObject * obj0 = 0 ;
27480 char *kwnames[] = {
27481 (char *) "self", NULL
27482 };
27483
27484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27486 if (SWIG_arg_fail(1)) SWIG_fail;
27487 {
27488 PyThreadState* __tstate = wxPyBeginAllowThreads();
27489 (arg1)->Fit();
27490
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 Py_INCREF(Py_None); resultobj = Py_None;
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj = NULL;
27503 wxWindow *arg1 = (wxWindow *) 0 ;
27504 PyObject * obj0 = 0 ;
27505 char *kwnames[] = {
27506 (char *) "self", NULL
27507 };
27508
27509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27511 if (SWIG_arg_fail(1)) SWIG_fail;
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 (arg1)->FitInside();
27515
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 Py_INCREF(Py_None); resultobj = Py_None;
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27527 PyObject *resultobj = NULL;
27528 wxWindow *arg1 = (wxWindow *) 0 ;
27529 int arg2 ;
27530 int arg3 ;
27531 int arg4 = (int) -1 ;
27532 int arg5 = (int) -1 ;
27533 int arg6 = (int) -1 ;
27534 int arg7 = (int) -1 ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 PyObject * obj2 = 0 ;
27538 PyObject * obj3 = 0 ;
27539 PyObject * obj4 = 0 ;
27540 PyObject * obj5 = 0 ;
27541 PyObject * obj6 = 0 ;
27542 char *kwnames[] = {
27543 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27544 };
27545
27546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27548 if (SWIG_arg_fail(1)) SWIG_fail;
27549 {
27550 arg2 = static_cast<int >(SWIG_As_int(obj1));
27551 if (SWIG_arg_fail(2)) SWIG_fail;
27552 }
27553 {
27554 arg3 = static_cast<int >(SWIG_As_int(obj2));
27555 if (SWIG_arg_fail(3)) SWIG_fail;
27556 }
27557 if (obj3) {
27558 {
27559 arg4 = static_cast<int >(SWIG_As_int(obj3));
27560 if (SWIG_arg_fail(4)) SWIG_fail;
27561 }
27562 }
27563 if (obj4) {
27564 {
27565 arg5 = static_cast<int >(SWIG_As_int(obj4));
27566 if (SWIG_arg_fail(5)) SWIG_fail;
27567 }
27568 }
27569 if (obj5) {
27570 {
27571 arg6 = static_cast<int >(SWIG_As_int(obj5));
27572 if (SWIG_arg_fail(6)) SWIG_fail;
27573 }
27574 }
27575 if (obj6) {
27576 {
27577 arg7 = static_cast<int >(SWIG_As_int(obj6));
27578 if (SWIG_arg_fail(7)) SWIG_fail;
27579 }
27580 }
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27584
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 Py_INCREF(Py_None); resultobj = Py_None;
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj = NULL;
27597 wxWindow *arg1 = (wxWindow *) 0 ;
27598 wxSize *arg2 = 0 ;
27599 wxSize const &arg3_defvalue = wxDefaultSize ;
27600 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27601 wxSize const &arg4_defvalue = wxDefaultSize ;
27602 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27603 wxSize temp2 ;
27604 wxSize temp3 ;
27605 wxSize temp4 ;
27606 PyObject * obj0 = 0 ;
27607 PyObject * obj1 = 0 ;
27608 PyObject * obj2 = 0 ;
27609 PyObject * obj3 = 0 ;
27610 char *kwnames[] = {
27611 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27612 };
27613
27614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = &temp2;
27619 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27620 }
27621 if (obj2) {
27622 {
27623 arg3 = &temp3;
27624 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27625 }
27626 }
27627 if (obj3) {
27628 {
27629 arg4 = &temp4;
27630 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27631 }
27632 }
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27636
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 Py_INCREF(Py_None); resultobj = Py_None;
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27648 PyObject *resultobj = NULL;
27649 wxWindow *arg1 = (wxWindow *) 0 ;
27650 int arg2 ;
27651 int arg3 ;
27652 int arg4 = (int) -1 ;
27653 int arg5 = (int) -1 ;
27654 PyObject * obj0 = 0 ;
27655 PyObject * obj1 = 0 ;
27656 PyObject * obj2 = 0 ;
27657 PyObject * obj3 = 0 ;
27658 PyObject * obj4 = 0 ;
27659 char *kwnames[] = {
27660 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27661 };
27662
27663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27665 if (SWIG_arg_fail(1)) SWIG_fail;
27666 {
27667 arg2 = static_cast<int >(SWIG_As_int(obj1));
27668 if (SWIG_arg_fail(2)) SWIG_fail;
27669 }
27670 {
27671 arg3 = static_cast<int >(SWIG_As_int(obj2));
27672 if (SWIG_arg_fail(3)) SWIG_fail;
27673 }
27674 if (obj3) {
27675 {
27676 arg4 = static_cast<int >(SWIG_As_int(obj3));
27677 if (SWIG_arg_fail(4)) SWIG_fail;
27678 }
27679 }
27680 if (obj4) {
27681 {
27682 arg5 = static_cast<int >(SWIG_As_int(obj4));
27683 if (SWIG_arg_fail(5)) SWIG_fail;
27684 }
27685 }
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27689
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 Py_INCREF(Py_None); resultobj = Py_None;
27694 return resultobj;
27695 fail:
27696 return NULL;
27697 }
27698
27699
27700 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27701 PyObject *resultobj = NULL;
27702 wxWindow *arg1 = (wxWindow *) 0 ;
27703 wxSize *arg2 = 0 ;
27704 wxSize const &arg3_defvalue = wxDefaultSize ;
27705 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27706 wxSize temp2 ;
27707 wxSize temp3 ;
27708 PyObject * obj0 = 0 ;
27709 PyObject * obj1 = 0 ;
27710 PyObject * obj2 = 0 ;
27711 char *kwnames[] = {
27712 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27713 };
27714
27715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27717 if (SWIG_arg_fail(1)) SWIG_fail;
27718 {
27719 arg2 = &temp2;
27720 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27721 }
27722 if (obj2) {
27723 {
27724 arg3 = &temp3;
27725 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27726 }
27727 }
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27731
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 Py_INCREF(Py_None); resultobj = Py_None;
27736 return resultobj;
27737 fail:
27738 return NULL;
27739 }
27740
27741
27742 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27743 PyObject *resultobj = NULL;
27744 wxWindow *arg1 = (wxWindow *) 0 ;
27745 wxSize result;
27746 PyObject * obj0 = 0 ;
27747 char *kwnames[] = {
27748 (char *) "self", NULL
27749 };
27750
27751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27753 if (SWIG_arg_fail(1)) SWIG_fail;
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 result = ((wxWindow const *)arg1)->GetMaxSize();
27757
27758 wxPyEndAllowThreads(__tstate);
27759 if (PyErr_Occurred()) SWIG_fail;
27760 }
27761 {
27762 wxSize * resultptr;
27763 resultptr = new wxSize(static_cast<wxSize & >(result));
27764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27765 }
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27773 PyObject *resultobj = NULL;
27774 wxWindow *arg1 = (wxWindow *) 0 ;
27775 wxSize result;
27776 PyObject * obj0 = 0 ;
27777 char *kwnames[] = {
27778 (char *) "self", NULL
27779 };
27780
27781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27783 if (SWIG_arg_fail(1)) SWIG_fail;
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 result = ((wxWindow const *)arg1)->GetMinSize();
27787
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 {
27792 wxSize * resultptr;
27793 resultptr = new wxSize(static_cast<wxSize & >(result));
27794 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27795 }
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27803 PyObject *resultobj = NULL;
27804 wxWindow *arg1 = (wxWindow *) 0 ;
27805 wxSize *arg2 = 0 ;
27806 wxSize temp2 ;
27807 PyObject * obj0 = 0 ;
27808 PyObject * obj1 = 0 ;
27809 char *kwnames[] = {
27810 (char *) "self",(char *) "minSize", NULL
27811 };
27812
27813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27815 if (SWIG_arg_fail(1)) SWIG_fail;
27816 {
27817 arg2 = &temp2;
27818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27819 }
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 (arg1)->SetMinSize((wxSize const &)*arg2);
27823
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 Py_INCREF(Py_None); resultobj = Py_None;
27828 return resultobj;
27829 fail:
27830 return NULL;
27831 }
27832
27833
27834 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27835 PyObject *resultobj = NULL;
27836 wxWindow *arg1 = (wxWindow *) 0 ;
27837 wxSize *arg2 = 0 ;
27838 wxSize temp2 ;
27839 PyObject * obj0 = 0 ;
27840 PyObject * obj1 = 0 ;
27841 char *kwnames[] = {
27842 (char *) "self",(char *) "maxSize", NULL
27843 };
27844
27845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) 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 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 (arg1)->SetMaxSize((wxSize const &)*arg2);
27855
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 Py_INCREF(Py_None); resultobj = Py_None;
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27867 PyObject *resultobj = NULL;
27868 wxWindow *arg1 = (wxWindow *) 0 ;
27869 int result;
27870 PyObject * obj0 = 0 ;
27871 char *kwnames[] = {
27872 (char *) "self", NULL
27873 };
27874
27875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27877 if (SWIG_arg_fail(1)) SWIG_fail;
27878 {
27879 PyThreadState* __tstate = wxPyBeginAllowThreads();
27880 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27881
27882 wxPyEndAllowThreads(__tstate);
27883 if (PyErr_Occurred()) SWIG_fail;
27884 }
27885 {
27886 resultobj = SWIG_From_int(static_cast<int >(result));
27887 }
27888 return resultobj;
27889 fail:
27890 return NULL;
27891 }
27892
27893
27894 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27895 PyObject *resultobj = NULL;
27896 wxWindow *arg1 = (wxWindow *) 0 ;
27897 int result;
27898 PyObject * obj0 = 0 ;
27899 char *kwnames[] = {
27900 (char *) "self", NULL
27901 };
27902
27903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27905 if (SWIG_arg_fail(1)) SWIG_fail;
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27909
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 {
27914 resultobj = SWIG_From_int(static_cast<int >(result));
27915 }
27916 return resultobj;
27917 fail:
27918 return NULL;
27919 }
27920
27921
27922 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj = NULL;
27924 wxWindow *arg1 = (wxWindow *) 0 ;
27925 int result;
27926 PyObject * obj0 = 0 ;
27927 char *kwnames[] = {
27928 (char *) "self", NULL
27929 };
27930
27931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27933 if (SWIG_arg_fail(1)) SWIG_fail;
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27937
27938 wxPyEndAllowThreads(__tstate);
27939 if (PyErr_Occurred()) SWIG_fail;
27940 }
27941 {
27942 resultobj = SWIG_From_int(static_cast<int >(result));
27943 }
27944 return resultobj;
27945 fail:
27946 return NULL;
27947 }
27948
27949
27950 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27951 PyObject *resultobj = NULL;
27952 wxWindow *arg1 = (wxWindow *) 0 ;
27953 int result;
27954 PyObject * obj0 = 0 ;
27955 char *kwnames[] = {
27956 (char *) "self", NULL
27957 };
27958
27959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27961 if (SWIG_arg_fail(1)) SWIG_fail;
27962 {
27963 PyThreadState* __tstate = wxPyBeginAllowThreads();
27964 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27965
27966 wxPyEndAllowThreads(__tstate);
27967 if (PyErr_Occurred()) SWIG_fail;
27968 }
27969 {
27970 resultobj = SWIG_From_int(static_cast<int >(result));
27971 }
27972 return resultobj;
27973 fail:
27974 return NULL;
27975 }
27976
27977
27978 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27979 PyObject *resultobj = NULL;
27980 wxWindow *arg1 = (wxWindow *) 0 ;
27981 wxSize *arg2 = 0 ;
27982 wxSize temp2 ;
27983 PyObject * obj0 = 0 ;
27984 PyObject * obj1 = 0 ;
27985 char *kwnames[] = {
27986 (char *) "self",(char *) "size", NULL
27987 };
27988
27989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27991 if (SWIG_arg_fail(1)) SWIG_fail;
27992 {
27993 arg2 = &temp2;
27994 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27995 }
27996 {
27997 PyThreadState* __tstate = wxPyBeginAllowThreads();
27998 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27999
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 Py_INCREF(Py_None); resultobj = Py_None;
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj = NULL;
28012 wxWindow *arg1 = (wxWindow *) 0 ;
28013 int arg2 ;
28014 int arg3 ;
28015 PyObject * obj0 = 0 ;
28016 PyObject * obj1 = 0 ;
28017 PyObject * obj2 = 0 ;
28018 char *kwnames[] = {
28019 (char *) "self",(char *) "w",(char *) "h", NULL
28020 };
28021
28022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28024 if (SWIG_arg_fail(1)) SWIG_fail;
28025 {
28026 arg2 = static_cast<int >(SWIG_As_int(obj1));
28027 if (SWIG_arg_fail(2)) SWIG_fail;
28028 }
28029 {
28030 arg3 = static_cast<int >(SWIG_As_int(obj2));
28031 if (SWIG_arg_fail(3)) SWIG_fail;
28032 }
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 (arg1)->SetVirtualSize(arg2,arg3);
28036
28037 wxPyEndAllowThreads(__tstate);
28038 if (PyErr_Occurred()) SWIG_fail;
28039 }
28040 Py_INCREF(Py_None); resultobj = Py_None;
28041 return resultobj;
28042 fail:
28043 return NULL;
28044 }
28045
28046
28047 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28048 PyObject *resultobj = NULL;
28049 wxWindow *arg1 = (wxWindow *) 0 ;
28050 wxSize result;
28051 PyObject * obj0 = 0 ;
28052 char *kwnames[] = {
28053 (char *) "self", NULL
28054 };
28055
28056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28058 if (SWIG_arg_fail(1)) SWIG_fail;
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 result = ((wxWindow const *)arg1)->GetVirtualSize();
28062
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 {
28067 wxSize * resultptr;
28068 resultptr = new wxSize(static_cast<wxSize & >(result));
28069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28070 }
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28078 PyObject *resultobj = NULL;
28079 wxWindow *arg1 = (wxWindow *) 0 ;
28080 int *arg2 = (int *) 0 ;
28081 int *arg3 = (int *) 0 ;
28082 int temp2 ;
28083 int res2 = 0 ;
28084 int temp3 ;
28085 int res3 = 0 ;
28086 PyObject * obj0 = 0 ;
28087 char *kwnames[] = {
28088 (char *) "self", NULL
28089 };
28090
28091 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28092 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28095 if (SWIG_arg_fail(1)) SWIG_fail;
28096 {
28097 PyThreadState* __tstate = wxPyBeginAllowThreads();
28098 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28099
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 Py_INCREF(Py_None); resultobj = Py_None;
28104 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28105 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28106 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28107 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28115 PyObject *resultobj = NULL;
28116 wxWindow *arg1 = (wxWindow *) 0 ;
28117 wxSize result;
28118 PyObject * obj0 = 0 ;
28119 char *kwnames[] = {
28120 (char *) "self", NULL
28121 };
28122
28123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28125 if (SWIG_arg_fail(1)) SWIG_fail;
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28129
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 {
28134 wxSize * resultptr;
28135 resultptr = new wxSize(static_cast<wxSize & >(result));
28136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28137 }
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj = NULL;
28146 wxWindow *arg1 = (wxWindow *) 0 ;
28147 bool arg2 = (bool) true ;
28148 bool result;
28149 PyObject * obj0 = 0 ;
28150 PyObject * obj1 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self",(char *) "show", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 if (obj1) {
28159 {
28160 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28161 if (SWIG_arg_fail(2)) SWIG_fail;
28162 }
28163 }
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (bool)(arg1)->Show(arg2);
28167
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 {
28172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj = NULL;
28182 wxWindow *arg1 = (wxWindow *) 0 ;
28183 bool result;
28184 PyObject * obj0 = 0 ;
28185 char *kwnames[] = {
28186 (char *) "self", NULL
28187 };
28188
28189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(1)) SWIG_fail;
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 result = (bool)(arg1)->Hide();
28195
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 {
28200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28201 }
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28209 PyObject *resultobj = NULL;
28210 wxWindow *arg1 = (wxWindow *) 0 ;
28211 bool arg2 = (bool) true ;
28212 bool result;
28213 PyObject * obj0 = 0 ;
28214 PyObject * obj1 = 0 ;
28215 char *kwnames[] = {
28216 (char *) "self",(char *) "enable", NULL
28217 };
28218
28219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28221 if (SWIG_arg_fail(1)) SWIG_fail;
28222 if (obj1) {
28223 {
28224 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28225 if (SWIG_arg_fail(2)) SWIG_fail;
28226 }
28227 }
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 result = (bool)(arg1)->Enable(arg2);
28231
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 {
28236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28237 }
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj = NULL;
28246 wxWindow *arg1 = (wxWindow *) 0 ;
28247 bool result;
28248 PyObject * obj0 = 0 ;
28249 char *kwnames[] = {
28250 (char *) "self", NULL
28251 };
28252
28253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",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 = (bool)(arg1)->Disable();
28259
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj = NULL;
28274 wxWindow *arg1 = (wxWindow *) 0 ;
28275 bool result;
28276 PyObject * obj0 = 0 ;
28277 char *kwnames[] = {
28278 (char *) "self", NULL
28279 };
28280
28281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28283 if (SWIG_arg_fail(1)) SWIG_fail;
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 result = (bool)((wxWindow const *)arg1)->IsShown();
28287
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 {
28292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28293 }
28294 return resultobj;
28295 fail:
28296 return NULL;
28297 }
28298
28299
28300 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28301 PyObject *resultobj = NULL;
28302 wxWindow *arg1 = (wxWindow *) 0 ;
28303 bool result;
28304 PyObject * obj0 = 0 ;
28305 char *kwnames[] = {
28306 (char *) "self", NULL
28307 };
28308
28309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28311 if (SWIG_arg_fail(1)) SWIG_fail;
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28315
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 {
28320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28329 PyObject *resultobj = NULL;
28330 wxWindow *arg1 = (wxWindow *) 0 ;
28331 long arg2 ;
28332 PyObject * obj0 = 0 ;
28333 PyObject * obj1 = 0 ;
28334 char *kwnames[] = {
28335 (char *) "self",(char *) "style", NULL
28336 };
28337
28338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28340 if (SWIG_arg_fail(1)) SWIG_fail;
28341 {
28342 arg2 = static_cast<long >(SWIG_As_long(obj1));
28343 if (SWIG_arg_fail(2)) SWIG_fail;
28344 }
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 (arg1)->SetWindowStyleFlag(arg2);
28348
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 Py_INCREF(Py_None); resultobj = Py_None;
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj = NULL;
28361 wxWindow *arg1 = (wxWindow *) 0 ;
28362 long result;
28363 PyObject * obj0 = 0 ;
28364 char *kwnames[] = {
28365 (char *) "self", NULL
28366 };
28367
28368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28370 if (SWIG_arg_fail(1)) SWIG_fail;
28371 {
28372 PyThreadState* __tstate = wxPyBeginAllowThreads();
28373 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28374
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 {
28379 resultobj = SWIG_From_long(static_cast<long >(result));
28380 }
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj = NULL;
28389 wxWindow *arg1 = (wxWindow *) 0 ;
28390 int arg2 ;
28391 bool result;
28392 PyObject * obj0 = 0 ;
28393 PyObject * obj1 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "self",(char *) "flag", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28400 if (SWIG_arg_fail(1)) SWIG_fail;
28401 {
28402 arg2 = static_cast<int >(SWIG_As_int(obj1));
28403 if (SWIG_arg_fail(2)) SWIG_fail;
28404 }
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28408
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 {
28413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28414 }
28415 return resultobj;
28416 fail:
28417 return NULL;
28418 }
28419
28420
28421 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28422 PyObject *resultobj = NULL;
28423 wxWindow *arg1 = (wxWindow *) 0 ;
28424 bool result;
28425 PyObject * obj0 = 0 ;
28426 char *kwnames[] = {
28427 (char *) "self", NULL
28428 };
28429
28430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28432 if (SWIG_arg_fail(1)) SWIG_fail;
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 result = (bool)((wxWindow const *)arg1)->IsRetained();
28436
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 {
28441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28442 }
28443 return resultobj;
28444 fail:
28445 return NULL;
28446 }
28447
28448
28449 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28450 PyObject *resultobj = NULL;
28451 wxWindow *arg1 = (wxWindow *) 0 ;
28452 long arg2 ;
28453 PyObject * obj0 = 0 ;
28454 PyObject * obj1 = 0 ;
28455 char *kwnames[] = {
28456 (char *) "self",(char *) "exStyle", NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28461 if (SWIG_arg_fail(1)) SWIG_fail;
28462 {
28463 arg2 = static_cast<long >(SWIG_As_long(obj1));
28464 if (SWIG_arg_fail(2)) SWIG_fail;
28465 }
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 (arg1)->SetExtraStyle(arg2);
28469
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 Py_INCREF(Py_None); resultobj = Py_None;
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj = NULL;
28482 wxWindow *arg1 = (wxWindow *) 0 ;
28483 long result;
28484 PyObject * obj0 = 0 ;
28485 char *kwnames[] = {
28486 (char *) "self", NULL
28487 };
28488
28489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(1)) SWIG_fail;
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28495
28496 wxPyEndAllowThreads(__tstate);
28497 if (PyErr_Occurred()) SWIG_fail;
28498 }
28499 {
28500 resultobj = SWIG_From_long(static_cast<long >(result));
28501 }
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj = NULL;
28510 wxWindow *arg1 = (wxWindow *) 0 ;
28511 bool arg2 = (bool) true ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "self",(char *) "modal", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 if (obj1) {
28522 {
28523 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28524 if (SWIG_arg_fail(2)) SWIG_fail;
28525 }
28526 }
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 (arg1)->MakeModal(arg2);
28530
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 Py_INCREF(Py_None); resultobj = Py_None;
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28542 PyObject *resultobj = NULL;
28543 wxWindow *arg1 = (wxWindow *) 0 ;
28544 bool arg2 ;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self",(char *) "enableTheme", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 {
28555 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28556 if (SWIG_arg_fail(2)) SWIG_fail;
28557 }
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 (arg1)->SetThemeEnabled(arg2);
28561
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 Py_INCREF(Py_None); resultobj = Py_None;
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj = NULL;
28574 wxWindow *arg1 = (wxWindow *) 0 ;
28575 bool result;
28576 PyObject * obj0 = 0 ;
28577 char *kwnames[] = {
28578 (char *) "self", NULL
28579 };
28580
28581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28583 if (SWIG_arg_fail(1)) SWIG_fail;
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28587
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 {
28592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28593 }
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28601 PyObject *resultobj = NULL;
28602 wxWindow *arg1 = (wxWindow *) 0 ;
28603 PyObject * obj0 = 0 ;
28604 char *kwnames[] = {
28605 (char *) "self", NULL
28606 };
28607
28608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28610 if (SWIG_arg_fail(1)) SWIG_fail;
28611 {
28612 PyThreadState* __tstate = wxPyBeginAllowThreads();
28613 (arg1)->SetFocus();
28614
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 Py_INCREF(Py_None); resultobj = Py_None;
28619 return resultobj;
28620 fail:
28621 return NULL;
28622 }
28623
28624
28625 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28626 PyObject *resultobj = NULL;
28627 wxWindow *arg1 = (wxWindow *) 0 ;
28628 PyObject * obj0 = 0 ;
28629 char *kwnames[] = {
28630 (char *) "self", NULL
28631 };
28632
28633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28635 if (SWIG_arg_fail(1)) SWIG_fail;
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 (arg1)->SetFocusFromKbd();
28639
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 Py_INCREF(Py_None); resultobj = Py_None;
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28651 PyObject *resultobj = NULL;
28652 wxWindow *result;
28653 char *kwnames[] = {
28654 NULL
28655 };
28656
28657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28658 {
28659 if (!wxPyCheckForApp()) SWIG_fail;
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (wxWindow *)wxWindow::FindFocus();
28662
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 {
28667 resultobj = wxPyMake_wxObject(result, 0);
28668 }
28669 return resultobj;
28670 fail:
28671 return NULL;
28672 }
28673
28674
28675 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28676 PyObject *resultobj = NULL;
28677 wxWindow *arg1 = (wxWindow *) 0 ;
28678 bool result;
28679 PyObject * obj0 = 0 ;
28680 char *kwnames[] = {
28681 (char *) "self", NULL
28682 };
28683
28684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28686 if (SWIG_arg_fail(1)) SWIG_fail;
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28690
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 {
28695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28696 }
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj = NULL;
28705 wxWindow *arg1 = (wxWindow *) 0 ;
28706 bool result;
28707 PyObject * obj0 = 0 ;
28708 char *kwnames[] = {
28709 (char *) "self", NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28714 if (SWIG_arg_fail(1)) SWIG_fail;
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28724 }
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28732 PyObject *resultobj = NULL;
28733 wxWindow *arg1 = (wxWindow *) 0 ;
28734 wxWindow *result;
28735 PyObject * obj0 = 0 ;
28736 char *kwnames[] = {
28737 (char *) "self", NULL
28738 };
28739
28740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28742 if (SWIG_arg_fail(1)) SWIG_fail;
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28746
28747 wxPyEndAllowThreads(__tstate);
28748 if (PyErr_Occurred()) SWIG_fail;
28749 }
28750 {
28751 resultobj = wxPyMake_wxObject(result, 0);
28752 }
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28760 PyObject *resultobj = NULL;
28761 wxWindow *arg1 = (wxWindow *) 0 ;
28762 wxWindow *arg2 = (wxWindow *) 0 ;
28763 wxWindow *result;
28764 PyObject * obj0 = 0 ;
28765 PyObject * obj1 = 0 ;
28766 char *kwnames[] = {
28767 (char *) "self",(char *) "child", NULL
28768 };
28769
28770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28772 if (SWIG_arg_fail(1)) SWIG_fail;
28773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28774 if (SWIG_arg_fail(2)) SWIG_fail;
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28778
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 {
28783 resultobj = wxPyMake_wxObject(result, 0);
28784 }
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj = NULL;
28793 wxWindow *arg1 = (wxWindow *) 0 ;
28794 wxWindow *arg2 = (wxWindow *) 0 ;
28795 PyObject * obj0 = 0 ;
28796 PyObject * obj1 = 0 ;
28797 char *kwnames[] = {
28798 (char *) "self",(char *) "win", NULL
28799 };
28800
28801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(1)) SWIG_fail;
28804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28805 if (SWIG_arg_fail(2)) SWIG_fail;
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 (arg1)->SetTmpDefaultItem(arg2);
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 Py_INCREF(Py_None); resultobj = Py_None;
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj = NULL;
28822 wxWindow *arg1 = (wxWindow *) 0 ;
28823 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28824 bool result;
28825 PyObject * obj0 = 0 ;
28826 PyObject * obj1 = 0 ;
28827 char *kwnames[] = {
28828 (char *) "self",(char *) "flags", NULL
28829 };
28830
28831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28833 if (SWIG_arg_fail(1)) SWIG_fail;
28834 if (obj1) {
28835 {
28836 arg2 = static_cast<int >(SWIG_As_int(obj1));
28837 if (SWIG_arg_fail(2)) SWIG_fail;
28838 }
28839 }
28840 {
28841 PyThreadState* __tstate = wxPyBeginAllowThreads();
28842 result = (bool)(arg1)->Navigate(arg2);
28843
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 {
28848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28849 }
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj = NULL;
28858 wxWindow *arg1 = (wxWindow *) 0 ;
28859 wxWindow *arg2 = (wxWindow *) 0 ;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char *kwnames[] = {
28863 (char *) "self",(char *) "win", NULL
28864 };
28865
28866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28868 if (SWIG_arg_fail(1)) SWIG_fail;
28869 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(2)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 (arg1)->MoveAfterInTabOrder(arg2);
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 Py_INCREF(Py_None); resultobj = Py_None;
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj = NULL;
28887 wxWindow *arg1 = (wxWindow *) 0 ;
28888 wxWindow *arg2 = (wxWindow *) 0 ;
28889 PyObject * obj0 = 0 ;
28890 PyObject * obj1 = 0 ;
28891 char *kwnames[] = {
28892 (char *) "self",(char *) "win", NULL
28893 };
28894
28895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28897 if (SWIG_arg_fail(1)) SWIG_fail;
28898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28899 if (SWIG_arg_fail(2)) SWIG_fail;
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 (arg1)->MoveBeforeInTabOrder(arg2);
28903
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 Py_INCREF(Py_None); resultobj = Py_None;
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28915 PyObject *resultobj = NULL;
28916 wxWindow *arg1 = (wxWindow *) 0 ;
28917 PyObject *result;
28918 PyObject * obj0 = 0 ;
28919 char *kwnames[] = {
28920 (char *) "self", NULL
28921 };
28922
28923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28925 if (SWIG_arg_fail(1)) SWIG_fail;
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = (PyObject *)wxWindow_GetChildren(arg1);
28929
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = result;
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28941 PyObject *resultobj = NULL;
28942 wxWindow *arg1 = (wxWindow *) 0 ;
28943 wxWindow *result;
28944 PyObject * obj0 = 0 ;
28945 char *kwnames[] = {
28946 (char *) "self", NULL
28947 };
28948
28949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28951 if (SWIG_arg_fail(1)) SWIG_fail;
28952 {
28953 PyThreadState* __tstate = wxPyBeginAllowThreads();
28954 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28955
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 {
28960 resultobj = wxPyMake_wxObject(result, 0);
28961 }
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj = NULL;
28970 wxWindow *arg1 = (wxWindow *) 0 ;
28971 wxWindow *result;
28972 PyObject * obj0 = 0 ;
28973 char *kwnames[] = {
28974 (char *) "self", NULL
28975 };
28976
28977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28979 if (SWIG_arg_fail(1)) SWIG_fail;
28980 {
28981 PyThreadState* __tstate = wxPyBeginAllowThreads();
28982 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28983
28984 wxPyEndAllowThreads(__tstate);
28985 if (PyErr_Occurred()) SWIG_fail;
28986 }
28987 {
28988 resultobj = wxPyMake_wxObject(result, 0);
28989 }
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28997 PyObject *resultobj = NULL;
28998 wxWindow *arg1 = (wxWindow *) 0 ;
28999 bool result;
29000 PyObject * obj0 = 0 ;
29001 char *kwnames[] = {
29002 (char *) "self", NULL
29003 };
29004
29005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29007 if (SWIG_arg_fail(1)) SWIG_fail;
29008 {
29009 PyThreadState* __tstate = wxPyBeginAllowThreads();
29010 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29011
29012 wxPyEndAllowThreads(__tstate);
29013 if (PyErr_Occurred()) SWIG_fail;
29014 }
29015 {
29016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29017 }
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj = NULL;
29026 wxWindow *arg1 = (wxWindow *) 0 ;
29027 wxWindow *arg2 = (wxWindow *) 0 ;
29028 bool result;
29029 PyObject * obj0 = 0 ;
29030 PyObject * obj1 = 0 ;
29031 char *kwnames[] = {
29032 (char *) "self",(char *) "newParent", NULL
29033 };
29034
29035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29037 if (SWIG_arg_fail(1)) SWIG_fail;
29038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29039 if (SWIG_arg_fail(2)) SWIG_fail;
29040 {
29041 PyThreadState* __tstate = wxPyBeginAllowThreads();
29042 result = (bool)(arg1)->Reparent(arg2);
29043
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 {
29048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29049 }
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj = NULL;
29058 wxWindow *arg1 = (wxWindow *) 0 ;
29059 wxWindow *arg2 = (wxWindow *) 0 ;
29060 PyObject * obj0 = 0 ;
29061 PyObject * obj1 = 0 ;
29062 char *kwnames[] = {
29063 (char *) "self",(char *) "child", NULL
29064 };
29065
29066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29068 if (SWIG_arg_fail(1)) SWIG_fail;
29069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29070 if (SWIG_arg_fail(2)) SWIG_fail;
29071 {
29072 PyThreadState* __tstate = wxPyBeginAllowThreads();
29073 (arg1)->AddChild(arg2);
29074
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 Py_INCREF(Py_None); resultobj = Py_None;
29079 return resultobj;
29080 fail:
29081 return NULL;
29082 }
29083
29084
29085 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29086 PyObject *resultobj = NULL;
29087 wxWindow *arg1 = (wxWindow *) 0 ;
29088 wxWindow *arg2 = (wxWindow *) 0 ;
29089 PyObject * obj0 = 0 ;
29090 PyObject * obj1 = 0 ;
29091 char *kwnames[] = {
29092 (char *) "self",(char *) "child", NULL
29093 };
29094
29095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29097 if (SWIG_arg_fail(1)) SWIG_fail;
29098 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29099 if (SWIG_arg_fail(2)) SWIG_fail;
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 (arg1)->RemoveChild(arg2);
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 Py_INCREF(Py_None); resultobj = Py_None;
29108 return resultobj;
29109 fail:
29110 return NULL;
29111 }
29112
29113
29114 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29115 PyObject *resultobj = NULL;
29116 wxWindow *arg1 = (wxWindow *) 0 ;
29117 long arg2 ;
29118 wxWindow *result;
29119 PyObject * obj0 = 0 ;
29120 PyObject * obj1 = 0 ;
29121 char *kwnames[] = {
29122 (char *) "self",(char *) "winid", NULL
29123 };
29124
29125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29127 if (SWIG_arg_fail(1)) SWIG_fail;
29128 {
29129 arg2 = static_cast<long >(SWIG_As_long(obj1));
29130 if (SWIG_arg_fail(2)) SWIG_fail;
29131 }
29132 {
29133 PyThreadState* __tstate = wxPyBeginAllowThreads();
29134 result = (wxWindow *)(arg1)->FindWindow(arg2);
29135
29136 wxPyEndAllowThreads(__tstate);
29137 if (PyErr_Occurred()) SWIG_fail;
29138 }
29139 {
29140 resultobj = wxPyMake_wxObject(result, 0);
29141 }
29142 return resultobj;
29143 fail:
29144 return NULL;
29145 }
29146
29147
29148 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29149 PyObject *resultobj = NULL;
29150 wxWindow *arg1 = (wxWindow *) 0 ;
29151 wxString *arg2 = 0 ;
29152 wxWindow *result;
29153 bool temp2 = false ;
29154 PyObject * obj0 = 0 ;
29155 PyObject * obj1 = 0 ;
29156 char *kwnames[] = {
29157 (char *) "self",(char *) "name", NULL
29158 };
29159
29160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29162 if (SWIG_arg_fail(1)) SWIG_fail;
29163 {
29164 arg2 = wxString_in_helper(obj1);
29165 if (arg2 == NULL) SWIG_fail;
29166 temp2 = true;
29167 }
29168 {
29169 PyThreadState* __tstate = wxPyBeginAllowThreads();
29170 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29171
29172 wxPyEndAllowThreads(__tstate);
29173 if (PyErr_Occurred()) SWIG_fail;
29174 }
29175 {
29176 resultobj = wxPyMake_wxObject(result, 0);
29177 }
29178 {
29179 if (temp2)
29180 delete arg2;
29181 }
29182 return resultobj;
29183 fail:
29184 {
29185 if (temp2)
29186 delete arg2;
29187 }
29188 return NULL;
29189 }
29190
29191
29192 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29193 PyObject *resultobj = NULL;
29194 wxWindow *arg1 = (wxWindow *) 0 ;
29195 wxEvtHandler *result;
29196 PyObject * obj0 = 0 ;
29197 char *kwnames[] = {
29198 (char *) "self", NULL
29199 };
29200
29201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29203 if (SWIG_arg_fail(1)) SWIG_fail;
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29207
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 {
29212 resultobj = wxPyMake_wxObject(result, 0);
29213 }
29214 return resultobj;
29215 fail:
29216 return NULL;
29217 }
29218
29219
29220 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29221 PyObject *resultobj = NULL;
29222 wxWindow *arg1 = (wxWindow *) 0 ;
29223 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29224 PyObject * obj0 = 0 ;
29225 PyObject * obj1 = 0 ;
29226 char *kwnames[] = {
29227 (char *) "self",(char *) "handler", NULL
29228 };
29229
29230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29232 if (SWIG_arg_fail(1)) SWIG_fail;
29233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29234 if (SWIG_arg_fail(2)) SWIG_fail;
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 (arg1)->SetEventHandler(arg2);
29238
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 Py_INCREF(Py_None); resultobj = Py_None;
29243 return resultobj;
29244 fail:
29245 return NULL;
29246 }
29247
29248
29249 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29250 PyObject *resultobj = NULL;
29251 wxWindow *arg1 = (wxWindow *) 0 ;
29252 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 char *kwnames[] = {
29256 (char *) "self",(char *) "handler", NULL
29257 };
29258
29259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29261 if (SWIG_arg_fail(1)) SWIG_fail;
29262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29263 if (SWIG_arg_fail(2)) SWIG_fail;
29264 {
29265 PyThreadState* __tstate = wxPyBeginAllowThreads();
29266 (arg1)->PushEventHandler(arg2);
29267
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 Py_INCREF(Py_None); resultobj = Py_None;
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29279 PyObject *resultobj = NULL;
29280 wxWindow *arg1 = (wxWindow *) 0 ;
29281 bool arg2 = (bool) false ;
29282 wxEvtHandler *result;
29283 PyObject * obj0 = 0 ;
29284 PyObject * obj1 = 0 ;
29285 char *kwnames[] = {
29286 (char *) "self",(char *) "deleteHandler", NULL
29287 };
29288
29289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29291 if (SWIG_arg_fail(1)) SWIG_fail;
29292 if (obj1) {
29293 {
29294 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29295 if (SWIG_arg_fail(2)) SWIG_fail;
29296 }
29297 }
29298 {
29299 PyThreadState* __tstate = wxPyBeginAllowThreads();
29300 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29301
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 {
29306 resultobj = wxPyMake_wxObject(result, 0);
29307 }
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29315 PyObject *resultobj = NULL;
29316 wxWindow *arg1 = (wxWindow *) 0 ;
29317 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29318 bool result;
29319 PyObject * obj0 = 0 ;
29320 PyObject * obj1 = 0 ;
29321 char *kwnames[] = {
29322 (char *) "self",(char *) "handler", NULL
29323 };
29324
29325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29327 if (SWIG_arg_fail(1)) SWIG_fail;
29328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29329 if (SWIG_arg_fail(2)) SWIG_fail;
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 result = (bool)(arg1)->RemoveEventHandler(arg2);
29333
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 {
29338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29339 }
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29347 PyObject *resultobj = NULL;
29348 wxWindow *arg1 = (wxWindow *) 0 ;
29349 wxValidator *arg2 = 0 ;
29350 PyObject * obj0 = 0 ;
29351 PyObject * obj1 = 0 ;
29352 char *kwnames[] = {
29353 (char *) "self",(char *) "validator", NULL
29354 };
29355
29356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29358 if (SWIG_arg_fail(1)) SWIG_fail;
29359 {
29360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(2)) SWIG_fail;
29362 if (arg2 == NULL) {
29363 SWIG_null_ref("wxValidator");
29364 }
29365 if (SWIG_arg_fail(2)) SWIG_fail;
29366 }
29367 {
29368 PyThreadState* __tstate = wxPyBeginAllowThreads();
29369 (arg1)->SetValidator((wxValidator const &)*arg2);
29370
29371 wxPyEndAllowThreads(__tstate);
29372 if (PyErr_Occurred()) SWIG_fail;
29373 }
29374 Py_INCREF(Py_None); resultobj = Py_None;
29375 return resultobj;
29376 fail:
29377 return NULL;
29378 }
29379
29380
29381 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29382 PyObject *resultobj = NULL;
29383 wxWindow *arg1 = (wxWindow *) 0 ;
29384 wxValidator *result;
29385 PyObject * obj0 = 0 ;
29386 char *kwnames[] = {
29387 (char *) "self", NULL
29388 };
29389
29390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29392 if (SWIG_arg_fail(1)) SWIG_fail;
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (wxValidator *)(arg1)->GetValidator();
29396
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 {
29401 resultobj = wxPyMake_wxObject(result, 0);
29402 }
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29410 PyObject *resultobj = NULL;
29411 wxWindow *arg1 = (wxWindow *) 0 ;
29412 bool result;
29413 PyObject * obj0 = 0 ;
29414 char *kwnames[] = {
29415 (char *) "self", NULL
29416 };
29417
29418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29420 if (SWIG_arg_fail(1)) SWIG_fail;
29421 {
29422 PyThreadState* __tstate = wxPyBeginAllowThreads();
29423 result = (bool)(arg1)->Validate();
29424
29425 wxPyEndAllowThreads(__tstate);
29426 if (PyErr_Occurred()) SWIG_fail;
29427 }
29428 {
29429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29430 }
29431 return resultobj;
29432 fail:
29433 return NULL;
29434 }
29435
29436
29437 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29438 PyObject *resultobj = NULL;
29439 wxWindow *arg1 = (wxWindow *) 0 ;
29440 bool result;
29441 PyObject * obj0 = 0 ;
29442 char *kwnames[] = {
29443 (char *) "self", NULL
29444 };
29445
29446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29448 if (SWIG_arg_fail(1)) SWIG_fail;
29449 {
29450 PyThreadState* __tstate = wxPyBeginAllowThreads();
29451 result = (bool)(arg1)->TransferDataToWindow();
29452
29453 wxPyEndAllowThreads(__tstate);
29454 if (PyErr_Occurred()) SWIG_fail;
29455 }
29456 {
29457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29458 }
29459 return resultobj;
29460 fail:
29461 return NULL;
29462 }
29463
29464
29465 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29466 PyObject *resultobj = NULL;
29467 wxWindow *arg1 = (wxWindow *) 0 ;
29468 bool result;
29469 PyObject * obj0 = 0 ;
29470 char *kwnames[] = {
29471 (char *) "self", NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(1)) SWIG_fail;
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 result = (bool)(arg1)->TransferDataFromWindow();
29480
29481 wxPyEndAllowThreads(__tstate);
29482 if (PyErr_Occurred()) SWIG_fail;
29483 }
29484 {
29485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29486 }
29487 return resultobj;
29488 fail:
29489 return NULL;
29490 }
29491
29492
29493 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29494 PyObject *resultobj = NULL;
29495 wxWindow *arg1 = (wxWindow *) 0 ;
29496 PyObject * obj0 = 0 ;
29497 char *kwnames[] = {
29498 (char *) "self", NULL
29499 };
29500
29501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29503 if (SWIG_arg_fail(1)) SWIG_fail;
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 (arg1)->InitDialog();
29507
29508 wxPyEndAllowThreads(__tstate);
29509 if (PyErr_Occurred()) SWIG_fail;
29510 }
29511 Py_INCREF(Py_None); resultobj = Py_None;
29512 return resultobj;
29513 fail:
29514 return NULL;
29515 }
29516
29517
29518 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29519 PyObject *resultobj = NULL;
29520 wxWindow *arg1 = (wxWindow *) 0 ;
29521 wxAcceleratorTable *arg2 = 0 ;
29522 PyObject * obj0 = 0 ;
29523 PyObject * obj1 = 0 ;
29524 char *kwnames[] = {
29525 (char *) "self",(char *) "accel", NULL
29526 };
29527
29528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29530 if (SWIG_arg_fail(1)) SWIG_fail;
29531 {
29532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29533 if (SWIG_arg_fail(2)) SWIG_fail;
29534 if (arg2 == NULL) {
29535 SWIG_null_ref("wxAcceleratorTable");
29536 }
29537 if (SWIG_arg_fail(2)) SWIG_fail;
29538 }
29539 {
29540 PyThreadState* __tstate = wxPyBeginAllowThreads();
29541 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29542
29543 wxPyEndAllowThreads(__tstate);
29544 if (PyErr_Occurred()) SWIG_fail;
29545 }
29546 Py_INCREF(Py_None); resultobj = Py_None;
29547 return resultobj;
29548 fail:
29549 return NULL;
29550 }
29551
29552
29553 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29554 PyObject *resultobj = NULL;
29555 wxWindow *arg1 = (wxWindow *) 0 ;
29556 wxAcceleratorTable *result;
29557 PyObject * obj0 = 0 ;
29558 char *kwnames[] = {
29559 (char *) "self", NULL
29560 };
29561
29562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29564 if (SWIG_arg_fail(1)) SWIG_fail;
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29568
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29580 PyObject *resultobj = NULL;
29581 wxWindow *arg1 = (wxWindow *) 0 ;
29582 int arg2 ;
29583 int arg3 ;
29584 int arg4 ;
29585 bool result;
29586 PyObject * obj0 = 0 ;
29587 PyObject * obj1 = 0 ;
29588 PyObject * obj2 = 0 ;
29589 PyObject * obj3 = 0 ;
29590 char *kwnames[] = {
29591 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29592 };
29593
29594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29596 if (SWIG_arg_fail(1)) SWIG_fail;
29597 {
29598 arg2 = static_cast<int >(SWIG_As_int(obj1));
29599 if (SWIG_arg_fail(2)) SWIG_fail;
29600 }
29601 {
29602 arg3 = static_cast<int >(SWIG_As_int(obj2));
29603 if (SWIG_arg_fail(3)) SWIG_fail;
29604 }
29605 {
29606 arg4 = static_cast<int >(SWIG_As_int(obj3));
29607 if (SWIG_arg_fail(4)) SWIG_fail;
29608 }
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29612
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 {
29617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29618 }
29619 return resultobj;
29620 fail:
29621 return NULL;
29622 }
29623
29624
29625 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29626 PyObject *resultobj = NULL;
29627 wxWindow *arg1 = (wxWindow *) 0 ;
29628 int arg2 ;
29629 bool result;
29630 PyObject * obj0 = 0 ;
29631 PyObject * obj1 = 0 ;
29632 char *kwnames[] = {
29633 (char *) "self",(char *) "hotkeyId", NULL
29634 };
29635
29636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29638 if (SWIG_arg_fail(1)) SWIG_fail;
29639 {
29640 arg2 = static_cast<int >(SWIG_As_int(obj1));
29641 if (SWIG_arg_fail(2)) SWIG_fail;
29642 }
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29646
29647 wxPyEndAllowThreads(__tstate);
29648 if (PyErr_Occurred()) SWIG_fail;
29649 }
29650 {
29651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29652 }
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29660 PyObject *resultobj = NULL;
29661 wxWindow *arg1 = (wxWindow *) 0 ;
29662 wxPoint *arg2 = 0 ;
29663 wxPoint result;
29664 wxPoint temp2 ;
29665 PyObject * obj0 = 0 ;
29666 PyObject * obj1 = 0 ;
29667 char *kwnames[] = {
29668 (char *) "self",(char *) "pt", NULL
29669 };
29670
29671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29673 if (SWIG_arg_fail(1)) SWIG_fail;
29674 {
29675 arg2 = &temp2;
29676 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29677 }
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 wxPoint * resultptr;
29687 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29688 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29689 }
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29697 PyObject *resultobj = NULL;
29698 wxWindow *arg1 = (wxWindow *) 0 ;
29699 wxSize *arg2 = 0 ;
29700 wxSize result;
29701 wxSize temp2 ;
29702 PyObject * obj0 = 0 ;
29703 PyObject * obj1 = 0 ;
29704 char *kwnames[] = {
29705 (char *) "self",(char *) "sz", NULL
29706 };
29707
29708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29710 if (SWIG_arg_fail(1)) SWIG_fail;
29711 {
29712 arg2 = &temp2;
29713 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29714 }
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29718
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 {
29723 wxSize * resultptr;
29724 resultptr = new wxSize(static_cast<wxSize & >(result));
29725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29726 }
29727 return resultobj;
29728 fail:
29729 return NULL;
29730 }
29731
29732
29733 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29734 PyObject *resultobj = NULL;
29735 wxWindow *arg1 = (wxWindow *) 0 ;
29736 wxPoint *arg2 = 0 ;
29737 wxPoint result;
29738 wxPoint temp2 ;
29739 PyObject * obj0 = 0 ;
29740 PyObject * obj1 = 0 ;
29741 char *kwnames[] = {
29742 (char *) "self",(char *) "pt", NULL
29743 };
29744
29745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29747 if (SWIG_arg_fail(1)) SWIG_fail;
29748 {
29749 arg2 = &temp2;
29750 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29751 }
29752 {
29753 PyThreadState* __tstate = wxPyBeginAllowThreads();
29754 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29755
29756 wxPyEndAllowThreads(__tstate);
29757 if (PyErr_Occurred()) SWIG_fail;
29758 }
29759 {
29760 wxPoint * resultptr;
29761 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29763 }
29764 return resultobj;
29765 fail:
29766 return NULL;
29767 }
29768
29769
29770 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29771 PyObject *resultobj = NULL;
29772 wxWindow *arg1 = (wxWindow *) 0 ;
29773 wxSize *arg2 = 0 ;
29774 wxSize result;
29775 wxSize temp2 ;
29776 PyObject * obj0 = 0 ;
29777 PyObject * obj1 = 0 ;
29778 char *kwnames[] = {
29779 (char *) "self",(char *) "sz", NULL
29780 };
29781
29782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29784 if (SWIG_arg_fail(1)) SWIG_fail;
29785 {
29786 arg2 = &temp2;
29787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29788 }
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29792
29793 wxPyEndAllowThreads(__tstate);
29794 if (PyErr_Occurred()) SWIG_fail;
29795 }
29796 {
29797 wxSize * resultptr;
29798 resultptr = new wxSize(static_cast<wxSize & >(result));
29799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29800 }
29801 return resultobj;
29802 fail:
29803 return NULL;
29804 }
29805
29806
29807 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29808 PyObject *resultobj = NULL;
29809 wxWindow *arg1 = (wxWindow *) 0 ;
29810 wxPoint *arg2 = 0 ;
29811 wxPoint result;
29812 wxPoint temp2 ;
29813 PyObject * obj0 = 0 ;
29814 PyObject * obj1 = 0 ;
29815 char *kwnames[] = {
29816 (char *) "self",(char *) "pt", NULL
29817 };
29818
29819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29821 if (SWIG_arg_fail(1)) SWIG_fail;
29822 {
29823 arg2 = &temp2;
29824 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29825 }
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29829
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 {
29834 wxPoint * resultptr;
29835 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29837 }
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29845 PyObject *resultobj = NULL;
29846 wxWindow *arg1 = (wxWindow *) 0 ;
29847 wxSize *arg2 = 0 ;
29848 wxSize result;
29849 wxSize temp2 ;
29850 PyObject * obj0 = 0 ;
29851 PyObject * obj1 = 0 ;
29852 char *kwnames[] = {
29853 (char *) "self",(char *) "sz", NULL
29854 };
29855
29856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29858 if (SWIG_arg_fail(1)) SWIG_fail;
29859 {
29860 arg2 = &temp2;
29861 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29862 }
29863 {
29864 PyThreadState* __tstate = wxPyBeginAllowThreads();
29865 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29866
29867 wxPyEndAllowThreads(__tstate);
29868 if (PyErr_Occurred()) SWIG_fail;
29869 }
29870 {
29871 wxSize * resultptr;
29872 resultptr = new wxSize(static_cast<wxSize & >(result));
29873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29874 }
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29882 PyObject *resultobj = NULL;
29883 wxWindow *arg1 = (wxWindow *) 0 ;
29884 int arg2 ;
29885 int arg3 ;
29886 PyObject * obj0 = 0 ;
29887 PyObject * obj1 = 0 ;
29888 PyObject * obj2 = 0 ;
29889 char *kwnames[] = {
29890 (char *) "self",(char *) "x",(char *) "y", NULL
29891 };
29892
29893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29895 if (SWIG_arg_fail(1)) SWIG_fail;
29896 {
29897 arg2 = static_cast<int >(SWIG_As_int(obj1));
29898 if (SWIG_arg_fail(2)) SWIG_fail;
29899 }
29900 {
29901 arg3 = static_cast<int >(SWIG_As_int(obj2));
29902 if (SWIG_arg_fail(3)) SWIG_fail;
29903 }
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 (arg1)->WarpPointer(arg2,arg3);
29907
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 Py_INCREF(Py_None); resultobj = Py_None;
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29919 PyObject *resultobj = NULL;
29920 wxWindow *arg1 = (wxWindow *) 0 ;
29921 PyObject * obj0 = 0 ;
29922 char *kwnames[] = {
29923 (char *) "self", NULL
29924 };
29925
29926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29928 if (SWIG_arg_fail(1)) SWIG_fail;
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 (arg1)->CaptureMouse();
29932
29933 wxPyEndAllowThreads(__tstate);
29934 if (PyErr_Occurred()) SWIG_fail;
29935 }
29936 Py_INCREF(Py_None); resultobj = Py_None;
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj = NULL;
29945 wxWindow *arg1 = (wxWindow *) 0 ;
29946 PyObject * obj0 = 0 ;
29947 char *kwnames[] = {
29948 (char *) "self", NULL
29949 };
29950
29951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29953 if (SWIG_arg_fail(1)) SWIG_fail;
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 (arg1)->ReleaseMouse();
29957
29958 wxPyEndAllowThreads(__tstate);
29959 if (PyErr_Occurred()) SWIG_fail;
29960 }
29961 Py_INCREF(Py_None); resultobj = Py_None;
29962 return resultobj;
29963 fail:
29964 return NULL;
29965 }
29966
29967
29968 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29969 PyObject *resultobj = NULL;
29970 wxWindow *result;
29971 char *kwnames[] = {
29972 NULL
29973 };
29974
29975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29976 {
29977 if (!wxPyCheckForApp()) SWIG_fail;
29978 PyThreadState* __tstate = wxPyBeginAllowThreads();
29979 result = (wxWindow *)wxWindow::GetCapture();
29980
29981 wxPyEndAllowThreads(__tstate);
29982 if (PyErr_Occurred()) SWIG_fail;
29983 }
29984 {
29985 resultobj = wxPyMake_wxObject(result, 0);
29986 }
29987 return resultobj;
29988 fail:
29989 return NULL;
29990 }
29991
29992
29993 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29994 PyObject *resultobj = NULL;
29995 wxWindow *arg1 = (wxWindow *) 0 ;
29996 bool result;
29997 PyObject * obj0 = 0 ;
29998 char *kwnames[] = {
29999 (char *) "self", NULL
30000 };
30001
30002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
30003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30004 if (SWIG_arg_fail(1)) SWIG_fail;
30005 {
30006 PyThreadState* __tstate = wxPyBeginAllowThreads();
30007 result = (bool)((wxWindow const *)arg1)->HasCapture();
30008
30009 wxPyEndAllowThreads(__tstate);
30010 if (PyErr_Occurred()) SWIG_fail;
30011 }
30012 {
30013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30014 }
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30022 PyObject *resultobj = NULL;
30023 wxWindow *arg1 = (wxWindow *) 0 ;
30024 bool arg2 = (bool) true ;
30025 wxRect *arg3 = (wxRect *) NULL ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 PyObject * obj2 = 0 ;
30029 char *kwnames[] = {
30030 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30031 };
30032
30033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30035 if (SWIG_arg_fail(1)) SWIG_fail;
30036 if (obj1) {
30037 {
30038 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30039 if (SWIG_arg_fail(2)) SWIG_fail;
30040 }
30041 }
30042 if (obj2) {
30043 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30044 if (SWIG_arg_fail(3)) SWIG_fail;
30045 }
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30049
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 Py_INCREF(Py_None); resultobj = Py_None;
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj = NULL;
30062 wxWindow *arg1 = (wxWindow *) 0 ;
30063 wxRect *arg2 = 0 ;
30064 bool arg3 = (bool) true ;
30065 wxRect temp2 ;
30066 PyObject * obj0 = 0 ;
30067 PyObject * obj1 = 0 ;
30068 PyObject * obj2 = 0 ;
30069 char *kwnames[] = {
30070 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30071 };
30072
30073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30075 if (SWIG_arg_fail(1)) SWIG_fail;
30076 {
30077 arg2 = &temp2;
30078 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30079 }
30080 if (obj2) {
30081 {
30082 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30083 if (SWIG_arg_fail(3)) SWIG_fail;
30084 }
30085 }
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30089
30090 wxPyEndAllowThreads(__tstate);
30091 if (PyErr_Occurred()) SWIG_fail;
30092 }
30093 Py_INCREF(Py_None); resultobj = Py_None;
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30101 PyObject *resultobj = NULL;
30102 wxWindow *arg1 = (wxWindow *) 0 ;
30103 PyObject * obj0 = 0 ;
30104 char *kwnames[] = {
30105 (char *) "self", NULL
30106 };
30107
30108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30110 if (SWIG_arg_fail(1)) SWIG_fail;
30111 {
30112 PyThreadState* __tstate = wxPyBeginAllowThreads();
30113 (arg1)->Update();
30114
30115 wxPyEndAllowThreads(__tstate);
30116 if (PyErr_Occurred()) SWIG_fail;
30117 }
30118 Py_INCREF(Py_None); resultobj = Py_None;
30119 return resultobj;
30120 fail:
30121 return NULL;
30122 }
30123
30124
30125 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj = NULL;
30127 wxWindow *arg1 = (wxWindow *) 0 ;
30128 PyObject * obj0 = 0 ;
30129 char *kwnames[] = {
30130 (char *) "self", NULL
30131 };
30132
30133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30135 if (SWIG_arg_fail(1)) SWIG_fail;
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 (arg1)->ClearBackground();
30139
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 Py_INCREF(Py_None); resultobj = Py_None;
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30151 PyObject *resultobj = NULL;
30152 wxWindow *arg1 = (wxWindow *) 0 ;
30153 PyObject * obj0 = 0 ;
30154 char *kwnames[] = {
30155 (char *) "self", NULL
30156 };
30157
30158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30160 if (SWIG_arg_fail(1)) SWIG_fail;
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 (arg1)->Freeze();
30164
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 Py_INCREF(Py_None); resultobj = Py_None;
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj = NULL;
30177 wxWindow *arg1 = (wxWindow *) 0 ;
30178 PyObject * obj0 = 0 ;
30179 char *kwnames[] = {
30180 (char *) "self", NULL
30181 };
30182
30183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30185 if (SWIG_arg_fail(1)) SWIG_fail;
30186 {
30187 PyThreadState* __tstate = wxPyBeginAllowThreads();
30188 (arg1)->Thaw();
30189
30190 wxPyEndAllowThreads(__tstate);
30191 if (PyErr_Occurred()) SWIG_fail;
30192 }
30193 Py_INCREF(Py_None); resultobj = Py_None;
30194 return resultobj;
30195 fail:
30196 return NULL;
30197 }
30198
30199
30200 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30201 PyObject *resultobj = NULL;
30202 wxWindow *arg1 = (wxWindow *) 0 ;
30203 wxDC *arg2 = 0 ;
30204 PyObject * obj0 = 0 ;
30205 PyObject * obj1 = 0 ;
30206 char *kwnames[] = {
30207 (char *) "self",(char *) "dc", NULL
30208 };
30209
30210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30212 if (SWIG_arg_fail(1)) SWIG_fail;
30213 {
30214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30215 if (SWIG_arg_fail(2)) SWIG_fail;
30216 if (arg2 == NULL) {
30217 SWIG_null_ref("wxDC");
30218 }
30219 if (SWIG_arg_fail(2)) SWIG_fail;
30220 }
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 (arg1)->PrepareDC(*arg2);
30224
30225 wxPyEndAllowThreads(__tstate);
30226 if (PyErr_Occurred()) SWIG_fail;
30227 }
30228 Py_INCREF(Py_None); resultobj = Py_None;
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj = NULL;
30237 wxWindow *arg1 = (wxWindow *) 0 ;
30238 wxRegion *result;
30239 PyObject * obj0 = 0 ;
30240 char *kwnames[] = {
30241 (char *) "self", NULL
30242 };
30243
30244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30246 if (SWIG_arg_fail(1)) SWIG_fail;
30247 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 {
30250 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30251 result = (wxRegion *) &_result_ref;
30252 }
30253
30254 wxPyEndAllowThreads(__tstate);
30255 if (PyErr_Occurred()) SWIG_fail;
30256 }
30257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30258 return resultobj;
30259 fail:
30260 return NULL;
30261 }
30262
30263
30264 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30265 PyObject *resultobj = NULL;
30266 wxWindow *arg1 = (wxWindow *) 0 ;
30267 wxRect result;
30268 PyObject * obj0 = 0 ;
30269 char *kwnames[] = {
30270 (char *) "self", NULL
30271 };
30272
30273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30275 if (SWIG_arg_fail(1)) SWIG_fail;
30276 {
30277 PyThreadState* __tstate = wxPyBeginAllowThreads();
30278 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30279
30280 wxPyEndAllowThreads(__tstate);
30281 if (PyErr_Occurred()) SWIG_fail;
30282 }
30283 {
30284 wxRect * resultptr;
30285 resultptr = new wxRect(static_cast<wxRect & >(result));
30286 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30287 }
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj = NULL;
30296 wxWindow *arg1 = (wxWindow *) 0 ;
30297 int arg2 ;
30298 int arg3 ;
30299 int arg4 = (int) 1 ;
30300 int arg5 = (int) 1 ;
30301 bool result;
30302 PyObject * obj0 = 0 ;
30303 PyObject * obj1 = 0 ;
30304 PyObject * obj2 = 0 ;
30305 PyObject * obj3 = 0 ;
30306 PyObject * obj4 = 0 ;
30307 char *kwnames[] = {
30308 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30309 };
30310
30311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30313 if (SWIG_arg_fail(1)) SWIG_fail;
30314 {
30315 arg2 = static_cast<int >(SWIG_As_int(obj1));
30316 if (SWIG_arg_fail(2)) SWIG_fail;
30317 }
30318 {
30319 arg3 = static_cast<int >(SWIG_As_int(obj2));
30320 if (SWIG_arg_fail(3)) SWIG_fail;
30321 }
30322 if (obj3) {
30323 {
30324 arg4 = static_cast<int >(SWIG_As_int(obj3));
30325 if (SWIG_arg_fail(4)) SWIG_fail;
30326 }
30327 }
30328 if (obj4) {
30329 {
30330 arg5 = static_cast<int >(SWIG_As_int(obj4));
30331 if (SWIG_arg_fail(5)) SWIG_fail;
30332 }
30333 }
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30337
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 {
30342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30343 }
30344 return resultobj;
30345 fail:
30346 return NULL;
30347 }
30348
30349
30350 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30351 PyObject *resultobj = NULL;
30352 wxWindow *arg1 = (wxWindow *) 0 ;
30353 wxPoint *arg2 = 0 ;
30354 bool result;
30355 wxPoint temp2 ;
30356 PyObject * obj0 = 0 ;
30357 PyObject * obj1 = 0 ;
30358 char *kwnames[] = {
30359 (char *) "self",(char *) "pt", NULL
30360 };
30361
30362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30364 if (SWIG_arg_fail(1)) SWIG_fail;
30365 {
30366 arg2 = &temp2;
30367 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30368 }
30369 {
30370 PyThreadState* __tstate = wxPyBeginAllowThreads();
30371 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30372
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 {
30377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30378 }
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30386 PyObject *resultobj = NULL;
30387 wxWindow *arg1 = (wxWindow *) 0 ;
30388 wxRect *arg2 = 0 ;
30389 bool result;
30390 wxRect temp2 ;
30391 PyObject * obj0 = 0 ;
30392 PyObject * obj1 = 0 ;
30393 char *kwnames[] = {
30394 (char *) "self",(char *) "rect", NULL
30395 };
30396
30397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30399 if (SWIG_arg_fail(1)) SWIG_fail;
30400 {
30401 arg2 = &temp2;
30402 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30403 }
30404 {
30405 PyThreadState* __tstate = wxPyBeginAllowThreads();
30406 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30407
30408 wxPyEndAllowThreads(__tstate);
30409 if (PyErr_Occurred()) SWIG_fail;
30410 }
30411 {
30412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30413 }
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30421 PyObject *resultobj = NULL;
30422 wxWindow *arg1 = (wxWindow *) 0 ;
30423 wxVisualAttributes result;
30424 PyObject * obj0 = 0 ;
30425 char *kwnames[] = {
30426 (char *) "self", NULL
30427 };
30428
30429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30431 if (SWIG_arg_fail(1)) SWIG_fail;
30432 {
30433 PyThreadState* __tstate = wxPyBeginAllowThreads();
30434 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30435
30436 wxPyEndAllowThreads(__tstate);
30437 if (PyErr_Occurred()) SWIG_fail;
30438 }
30439 {
30440 wxVisualAttributes * resultptr;
30441 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30443 }
30444 return resultobj;
30445 fail:
30446 return NULL;
30447 }
30448
30449
30450 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30451 PyObject *resultobj = NULL;
30452 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30453 wxVisualAttributes result;
30454 PyObject * obj0 = 0 ;
30455 char *kwnames[] = {
30456 (char *) "variant", NULL
30457 };
30458
30459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30460 if (obj0) {
30461 {
30462 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30463 if (SWIG_arg_fail(1)) SWIG_fail;
30464 }
30465 }
30466 {
30467 if (!wxPyCheckForApp()) SWIG_fail;
30468 PyThreadState* __tstate = wxPyBeginAllowThreads();
30469 result = wxWindow::GetClassDefaultAttributes(arg1);
30470
30471 wxPyEndAllowThreads(__tstate);
30472 if (PyErr_Occurred()) SWIG_fail;
30473 }
30474 {
30475 wxVisualAttributes * resultptr;
30476 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30478 }
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30486 PyObject *resultobj = NULL;
30487 wxWindow *arg1 = (wxWindow *) 0 ;
30488 wxColour *arg2 = 0 ;
30489 bool result;
30490 wxColour temp2 ;
30491 PyObject * obj0 = 0 ;
30492 PyObject * obj1 = 0 ;
30493 char *kwnames[] = {
30494 (char *) "self",(char *) "colour", NULL
30495 };
30496
30497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 arg2 = &temp2;
30502 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30503 }
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30507
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 {
30512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30513 }
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj = NULL;
30522 wxWindow *arg1 = (wxWindow *) 0 ;
30523 wxColour *arg2 = 0 ;
30524 wxColour temp2 ;
30525 PyObject * obj0 = 0 ;
30526 PyObject * obj1 = 0 ;
30527 char *kwnames[] = {
30528 (char *) "self",(char *) "colour", NULL
30529 };
30530
30531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30533 if (SWIG_arg_fail(1)) SWIG_fail;
30534 {
30535 arg2 = &temp2;
30536 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30537 }
30538 {
30539 PyThreadState* __tstate = wxPyBeginAllowThreads();
30540 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30541
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 Py_INCREF(Py_None); resultobj = Py_None;
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj = NULL;
30554 wxWindow *arg1 = (wxWindow *) 0 ;
30555 wxColour *arg2 = 0 ;
30556 bool result;
30557 wxColour temp2 ;
30558 PyObject * obj0 = 0 ;
30559 PyObject * obj1 = 0 ;
30560 char *kwnames[] = {
30561 (char *) "self",(char *) "colour", NULL
30562 };
30563
30564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30566 if (SWIG_arg_fail(1)) SWIG_fail;
30567 {
30568 arg2 = &temp2;
30569 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30570 }
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30574
30575 wxPyEndAllowThreads(__tstate);
30576 if (PyErr_Occurred()) SWIG_fail;
30577 }
30578 {
30579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30580 }
30581 return resultobj;
30582 fail:
30583 return NULL;
30584 }
30585
30586
30587 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30588 PyObject *resultobj = NULL;
30589 wxWindow *arg1 = (wxWindow *) 0 ;
30590 wxColour *arg2 = 0 ;
30591 wxColour temp2 ;
30592 PyObject * obj0 = 0 ;
30593 PyObject * obj1 = 0 ;
30594 char *kwnames[] = {
30595 (char *) "self",(char *) "colour", NULL
30596 };
30597
30598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30600 if (SWIG_arg_fail(1)) SWIG_fail;
30601 {
30602 arg2 = &temp2;
30603 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30604 }
30605 {
30606 PyThreadState* __tstate = wxPyBeginAllowThreads();
30607 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30608
30609 wxPyEndAllowThreads(__tstate);
30610 if (PyErr_Occurred()) SWIG_fail;
30611 }
30612 Py_INCREF(Py_None); resultobj = Py_None;
30613 return resultobj;
30614 fail:
30615 return NULL;
30616 }
30617
30618
30619 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30620 PyObject *resultobj = NULL;
30621 wxWindow *arg1 = (wxWindow *) 0 ;
30622 wxColour result;
30623 PyObject * obj0 = 0 ;
30624 char *kwnames[] = {
30625 (char *) "self", NULL
30626 };
30627
30628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 {
30632 PyThreadState* __tstate = wxPyBeginAllowThreads();
30633 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30634
30635 wxPyEndAllowThreads(__tstate);
30636 if (PyErr_Occurred()) SWIG_fail;
30637 }
30638 {
30639 wxColour * resultptr;
30640 resultptr = new wxColour(static_cast<wxColour & >(result));
30641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30642 }
30643 return resultobj;
30644 fail:
30645 return NULL;
30646 }
30647
30648
30649 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30650 PyObject *resultobj = NULL;
30651 wxWindow *arg1 = (wxWindow *) 0 ;
30652 wxColour result;
30653 PyObject * obj0 = 0 ;
30654 char *kwnames[] = {
30655 (char *) "self", NULL
30656 };
30657
30658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30660 if (SWIG_arg_fail(1)) SWIG_fail;
30661 {
30662 PyThreadState* __tstate = wxPyBeginAllowThreads();
30663 result = ((wxWindow const *)arg1)->GetForegroundColour();
30664
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 {
30669 wxColour * resultptr;
30670 resultptr = new wxColour(static_cast<wxColour & >(result));
30671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30672 }
30673 return resultobj;
30674 fail:
30675 return NULL;
30676 }
30677
30678
30679 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30680 PyObject *resultobj = NULL;
30681 wxWindow *arg1 = (wxWindow *) 0 ;
30682 bool result;
30683 PyObject * obj0 = 0 ;
30684 char *kwnames[] = {
30685 (char *) "self", NULL
30686 };
30687
30688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30690 if (SWIG_arg_fail(1)) SWIG_fail;
30691 {
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30694
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 {
30699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30700 }
30701 return resultobj;
30702 fail:
30703 return NULL;
30704 }
30705
30706
30707 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30708 PyObject *resultobj = NULL;
30709 wxWindow *arg1 = (wxWindow *) 0 ;
30710 bool result;
30711 PyObject * obj0 = 0 ;
30712 char *kwnames[] = {
30713 (char *) "self", NULL
30714 };
30715
30716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30718 if (SWIG_arg_fail(1)) SWIG_fail;
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30722
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 {
30727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30728 }
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30736 PyObject *resultobj = NULL;
30737 wxWindow *arg1 = (wxWindow *) 0 ;
30738 wxBackgroundStyle arg2 ;
30739 bool result;
30740 PyObject * obj0 = 0 ;
30741 PyObject * obj1 = 0 ;
30742 char *kwnames[] = {
30743 (char *) "self",(char *) "style", NULL
30744 };
30745
30746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30748 if (SWIG_arg_fail(1)) SWIG_fail;
30749 {
30750 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30751 if (SWIG_arg_fail(2)) SWIG_fail;
30752 }
30753 {
30754 PyThreadState* __tstate = wxPyBeginAllowThreads();
30755 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30756
30757 wxPyEndAllowThreads(__tstate);
30758 if (PyErr_Occurred()) SWIG_fail;
30759 }
30760 {
30761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30762 }
30763 return resultobj;
30764 fail:
30765 return NULL;
30766 }
30767
30768
30769 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30770 PyObject *resultobj = NULL;
30771 wxWindow *arg1 = (wxWindow *) 0 ;
30772 wxBackgroundStyle result;
30773 PyObject * obj0 = 0 ;
30774 char *kwnames[] = {
30775 (char *) "self", NULL
30776 };
30777
30778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30780 if (SWIG_arg_fail(1)) SWIG_fail;
30781 {
30782 PyThreadState* __tstate = wxPyBeginAllowThreads();
30783 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30784
30785 wxPyEndAllowThreads(__tstate);
30786 if (PyErr_Occurred()) SWIG_fail;
30787 }
30788 resultobj = SWIG_From_int((result));
30789 return resultobj;
30790 fail:
30791 return NULL;
30792 }
30793
30794
30795 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30796 PyObject *resultobj = NULL;
30797 wxWindow *arg1 = (wxWindow *) 0 ;
30798 bool result;
30799 PyObject * obj0 = 0 ;
30800 char *kwnames[] = {
30801 (char *) "self", NULL
30802 };
30803
30804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30806 if (SWIG_arg_fail(1)) SWIG_fail;
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 result = (bool)(arg1)->HasTransparentBackground();
30810
30811 wxPyEndAllowThreads(__tstate);
30812 if (PyErr_Occurred()) SWIG_fail;
30813 }
30814 {
30815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30816 }
30817 return resultobj;
30818 fail:
30819 return NULL;
30820 }
30821
30822
30823 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30824 PyObject *resultobj = NULL;
30825 wxWindow *arg1 = (wxWindow *) 0 ;
30826 wxCursor *arg2 = 0 ;
30827 bool result;
30828 PyObject * obj0 = 0 ;
30829 PyObject * obj1 = 0 ;
30830 char *kwnames[] = {
30831 (char *) "self",(char *) "cursor", NULL
30832 };
30833
30834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30836 if (SWIG_arg_fail(1)) SWIG_fail;
30837 {
30838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30839 if (SWIG_arg_fail(2)) SWIG_fail;
30840 if (arg2 == NULL) {
30841 SWIG_null_ref("wxCursor");
30842 }
30843 if (SWIG_arg_fail(2)) SWIG_fail;
30844 }
30845 {
30846 PyThreadState* __tstate = wxPyBeginAllowThreads();
30847 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30848
30849 wxPyEndAllowThreads(__tstate);
30850 if (PyErr_Occurred()) SWIG_fail;
30851 }
30852 {
30853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30854 }
30855 return resultobj;
30856 fail:
30857 return NULL;
30858 }
30859
30860
30861 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30862 PyObject *resultobj = NULL;
30863 wxWindow *arg1 = (wxWindow *) 0 ;
30864 wxCursor result;
30865 PyObject * obj0 = 0 ;
30866 char *kwnames[] = {
30867 (char *) "self", NULL
30868 };
30869
30870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30872 if (SWIG_arg_fail(1)) SWIG_fail;
30873 {
30874 PyThreadState* __tstate = wxPyBeginAllowThreads();
30875 result = (arg1)->GetCursor();
30876
30877 wxPyEndAllowThreads(__tstate);
30878 if (PyErr_Occurred()) SWIG_fail;
30879 }
30880 {
30881 wxCursor * resultptr;
30882 resultptr = new wxCursor(static_cast<wxCursor & >(result));
30883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30884 }
30885 return resultobj;
30886 fail:
30887 return NULL;
30888 }
30889
30890
30891 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30892 PyObject *resultobj = NULL;
30893 wxWindow *arg1 = (wxWindow *) 0 ;
30894 wxFont *arg2 = 0 ;
30895 bool result;
30896 PyObject * obj0 = 0 ;
30897 PyObject * obj1 = 0 ;
30898 char *kwnames[] = {
30899 (char *) "self",(char *) "font", NULL
30900 };
30901
30902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30904 if (SWIG_arg_fail(1)) SWIG_fail;
30905 {
30906 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30907 if (SWIG_arg_fail(2)) SWIG_fail;
30908 if (arg2 == NULL) {
30909 SWIG_null_ref("wxFont");
30910 }
30911 if (SWIG_arg_fail(2)) SWIG_fail;
30912 }
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30916
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 {
30921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30922 }
30923 return resultobj;
30924 fail:
30925 return NULL;
30926 }
30927
30928
30929 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30930 PyObject *resultobj = NULL;
30931 wxWindow *arg1 = (wxWindow *) 0 ;
30932 wxFont *arg2 = 0 ;
30933 PyObject * obj0 = 0 ;
30934 PyObject * obj1 = 0 ;
30935 char *kwnames[] = {
30936 (char *) "self",(char *) "font", NULL
30937 };
30938
30939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30941 if (SWIG_arg_fail(1)) SWIG_fail;
30942 {
30943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30944 if (SWIG_arg_fail(2)) SWIG_fail;
30945 if (arg2 == NULL) {
30946 SWIG_null_ref("wxFont");
30947 }
30948 if (SWIG_arg_fail(2)) SWIG_fail;
30949 }
30950 {
30951 PyThreadState* __tstate = wxPyBeginAllowThreads();
30952 (arg1)->SetOwnFont((wxFont const &)*arg2);
30953
30954 wxPyEndAllowThreads(__tstate);
30955 if (PyErr_Occurred()) SWIG_fail;
30956 }
30957 Py_INCREF(Py_None); resultobj = Py_None;
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj = NULL;
30966 wxWindow *arg1 = (wxWindow *) 0 ;
30967 wxFont result;
30968 PyObject * obj0 = 0 ;
30969 char *kwnames[] = {
30970 (char *) "self", NULL
30971 };
30972
30973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30975 if (SWIG_arg_fail(1)) SWIG_fail;
30976 {
30977 PyThreadState* __tstate = wxPyBeginAllowThreads();
30978 result = (arg1)->GetFont();
30979
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 {
30984 wxFont * resultptr;
30985 resultptr = new wxFont(static_cast<wxFont & >(result));
30986 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30987 }
30988 return resultobj;
30989 fail:
30990 return NULL;
30991 }
30992
30993
30994 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30995 PyObject *resultobj = NULL;
30996 wxWindow *arg1 = (wxWindow *) 0 ;
30997 wxCaret *arg2 = (wxCaret *) 0 ;
30998 PyObject * obj0 = 0 ;
30999 PyObject * obj1 = 0 ;
31000 char *kwnames[] = {
31001 (char *) "self",(char *) "caret", NULL
31002 };
31003
31004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
31005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31006 if (SWIG_arg_fail(1)) SWIG_fail;
31007 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
31008 if (SWIG_arg_fail(2)) SWIG_fail;
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 (arg1)->SetCaret(arg2);
31012
31013 wxPyEndAllowThreads(__tstate);
31014 if (PyErr_Occurred()) SWIG_fail;
31015 }
31016 Py_INCREF(Py_None); resultobj = Py_None;
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31024 PyObject *resultobj = NULL;
31025 wxWindow *arg1 = (wxWindow *) 0 ;
31026 wxCaret *result;
31027 PyObject * obj0 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj = NULL;
31051 wxWindow *arg1 = (wxWindow *) 0 ;
31052 int result;
31053 PyObject * obj0 = 0 ;
31054 char *kwnames[] = {
31055 (char *) "self", NULL
31056 };
31057
31058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31060 if (SWIG_arg_fail(1)) SWIG_fail;
31061 {
31062 PyThreadState* __tstate = wxPyBeginAllowThreads();
31063 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31064
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 {
31069 resultobj = SWIG_From_int(static_cast<int >(result));
31070 }
31071 return resultobj;
31072 fail:
31073 return NULL;
31074 }
31075
31076
31077 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31078 PyObject *resultobj = NULL;
31079 wxWindow *arg1 = (wxWindow *) 0 ;
31080 int result;
31081 PyObject * obj0 = 0 ;
31082 char *kwnames[] = {
31083 (char *) "self", NULL
31084 };
31085
31086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31088 if (SWIG_arg_fail(1)) SWIG_fail;
31089 {
31090 PyThreadState* __tstate = wxPyBeginAllowThreads();
31091 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31092
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 {
31097 resultobj = SWIG_From_int(static_cast<int >(result));
31098 }
31099 return resultobj;
31100 fail:
31101 return NULL;
31102 }
31103
31104
31105 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31106 PyObject *resultobj = NULL;
31107 wxWindow *arg1 = (wxWindow *) 0 ;
31108 wxString *arg2 = 0 ;
31109 int *arg3 = (int *) 0 ;
31110 int *arg4 = (int *) 0 ;
31111 bool temp2 = false ;
31112 int temp3 ;
31113 int res3 = 0 ;
31114 int temp4 ;
31115 int res4 = 0 ;
31116 PyObject * obj0 = 0 ;
31117 PyObject * obj1 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self",(char *) "string", NULL
31120 };
31121
31122 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31123 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31126 if (SWIG_arg_fail(1)) SWIG_fail;
31127 {
31128 arg2 = wxString_in_helper(obj1);
31129 if (arg2 == NULL) SWIG_fail;
31130 temp2 = true;
31131 }
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31135
31136 wxPyEndAllowThreads(__tstate);
31137 if (PyErr_Occurred()) SWIG_fail;
31138 }
31139 Py_INCREF(Py_None); resultobj = Py_None;
31140 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31141 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31142 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31143 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31144 {
31145 if (temp2)
31146 delete arg2;
31147 }
31148 return resultobj;
31149 fail:
31150 {
31151 if (temp2)
31152 delete arg2;
31153 }
31154 return NULL;
31155 }
31156
31157
31158 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31159 PyObject *resultobj = NULL;
31160 wxWindow *arg1 = (wxWindow *) 0 ;
31161 wxString *arg2 = 0 ;
31162 int *arg3 = (int *) 0 ;
31163 int *arg4 = (int *) 0 ;
31164 int *arg5 = (int *) 0 ;
31165 int *arg6 = (int *) 0 ;
31166 wxFont *arg7 = (wxFont *) NULL ;
31167 bool temp2 = false ;
31168 int temp3 ;
31169 int res3 = 0 ;
31170 int temp4 ;
31171 int res4 = 0 ;
31172 int temp5 ;
31173 int res5 = 0 ;
31174 int temp6 ;
31175 int res6 = 0 ;
31176 PyObject * obj0 = 0 ;
31177 PyObject * obj1 = 0 ;
31178 PyObject * obj2 = 0 ;
31179 char *kwnames[] = {
31180 (char *) "self",(char *) "string",(char *) "font", NULL
31181 };
31182
31183 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31184 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31185 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31186 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31189 if (SWIG_arg_fail(1)) SWIG_fail;
31190 {
31191 arg2 = wxString_in_helper(obj1);
31192 if (arg2 == NULL) SWIG_fail;
31193 temp2 = true;
31194 }
31195 if (obj2) {
31196 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31197 if (SWIG_arg_fail(7)) SWIG_fail;
31198 }
31199 {
31200 PyThreadState* __tstate = wxPyBeginAllowThreads();
31201 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31202
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 Py_INCREF(Py_None); resultobj = Py_None;
31207 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31208 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31209 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31210 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31211 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31212 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31213 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31214 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31215 {
31216 if (temp2)
31217 delete arg2;
31218 }
31219 return resultobj;
31220 fail:
31221 {
31222 if (temp2)
31223 delete arg2;
31224 }
31225 return NULL;
31226 }
31227
31228
31229 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj = NULL;
31231 wxWindow *arg1 = (wxWindow *) 0 ;
31232 int *arg2 = (int *) 0 ;
31233 int *arg3 = (int *) 0 ;
31234 int temp2 ;
31235 int res2 = 0 ;
31236 int temp3 ;
31237 int res3 = 0 ;
31238 PyObject * obj0 = 0 ;
31239 PyObject * obj1 = 0 ;
31240 PyObject * obj2 = 0 ;
31241 char *kwnames[] = {
31242 (char *) "self",(char *) "x",(char *) "y", NULL
31243 };
31244
31245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31247 if (SWIG_arg_fail(1)) SWIG_fail;
31248 {
31249 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31250 temp2 = SWIG_As_int(obj1);
31251 if (SWIG_arg_fail(2)) SWIG_fail;
31252 arg2 = &temp2;
31253 res2 = SWIG_NEWOBJ;
31254 }
31255 }
31256 {
31257 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31258 temp3 = SWIG_As_int(obj2);
31259 if (SWIG_arg_fail(3)) SWIG_fail;
31260 arg3 = &temp3;
31261 res3 = SWIG_NEWOBJ;
31262 }
31263 }
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31267
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 Py_INCREF(Py_None); resultobj = Py_None;
31272 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31273 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31274 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31275 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31283 PyObject *resultobj = NULL;
31284 wxWindow *arg1 = (wxWindow *) 0 ;
31285 int *arg2 = (int *) 0 ;
31286 int *arg3 = (int *) 0 ;
31287 int temp2 ;
31288 int res2 = 0 ;
31289 int temp3 ;
31290 int res3 = 0 ;
31291 PyObject * obj0 = 0 ;
31292 PyObject * obj1 = 0 ;
31293 PyObject * obj2 = 0 ;
31294 char *kwnames[] = {
31295 (char *) "self",(char *) "x",(char *) "y", NULL
31296 };
31297
31298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31300 if (SWIG_arg_fail(1)) SWIG_fail;
31301 {
31302 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31303 temp2 = SWIG_As_int(obj1);
31304 if (SWIG_arg_fail(2)) SWIG_fail;
31305 arg2 = &temp2;
31306 res2 = SWIG_NEWOBJ;
31307 }
31308 }
31309 {
31310 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31311 temp3 = SWIG_As_int(obj2);
31312 if (SWIG_arg_fail(3)) SWIG_fail;
31313 arg3 = &temp3;
31314 res3 = SWIG_NEWOBJ;
31315 }
31316 }
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31320
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 Py_INCREF(Py_None); resultobj = Py_None;
31325 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31326 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31327 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31328 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31329 return resultobj;
31330 fail:
31331 return NULL;
31332 }
31333
31334
31335 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31336 PyObject *resultobj = NULL;
31337 wxWindow *arg1 = (wxWindow *) 0 ;
31338 wxPoint *arg2 = 0 ;
31339 wxPoint result;
31340 wxPoint temp2 ;
31341 PyObject * obj0 = 0 ;
31342 PyObject * obj1 = 0 ;
31343 char *kwnames[] = {
31344 (char *) "self",(char *) "pt", NULL
31345 };
31346
31347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31349 if (SWIG_arg_fail(1)) SWIG_fail;
31350 {
31351 arg2 = &temp2;
31352 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31353 }
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31357
31358 wxPyEndAllowThreads(__tstate);
31359 if (PyErr_Occurred()) SWIG_fail;
31360 }
31361 {
31362 wxPoint * resultptr;
31363 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31365 }
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31373 PyObject *resultobj = NULL;
31374 wxWindow *arg1 = (wxWindow *) 0 ;
31375 wxPoint *arg2 = 0 ;
31376 wxPoint result;
31377 wxPoint temp2 ;
31378 PyObject * obj0 = 0 ;
31379 PyObject * obj1 = 0 ;
31380 char *kwnames[] = {
31381 (char *) "self",(char *) "pt", NULL
31382 };
31383
31384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31386 if (SWIG_arg_fail(1)) SWIG_fail;
31387 {
31388 arg2 = &temp2;
31389 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31390 }
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31394
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 {
31399 wxPoint * resultptr;
31400 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31401 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31402 }
31403 return resultobj;
31404 fail:
31405 return NULL;
31406 }
31407
31408
31409 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31410 PyObject *resultobj = NULL;
31411 wxWindow *arg1 = (wxWindow *) 0 ;
31412 int arg2 ;
31413 int arg3 ;
31414 wxHitTest result;
31415 PyObject * obj0 = 0 ;
31416 PyObject * obj1 = 0 ;
31417 PyObject * obj2 = 0 ;
31418 char *kwnames[] = {
31419 (char *) "self",(char *) "x",(char *) "y", NULL
31420 };
31421
31422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31424 if (SWIG_arg_fail(1)) SWIG_fail;
31425 {
31426 arg2 = static_cast<int >(SWIG_As_int(obj1));
31427 if (SWIG_arg_fail(2)) SWIG_fail;
31428 }
31429 {
31430 arg3 = static_cast<int >(SWIG_As_int(obj2));
31431 if (SWIG_arg_fail(3)) SWIG_fail;
31432 }
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31436
31437 wxPyEndAllowThreads(__tstate);
31438 if (PyErr_Occurred()) SWIG_fail;
31439 }
31440 resultobj = SWIG_From_int((result));
31441 return resultobj;
31442 fail:
31443 return NULL;
31444 }
31445
31446
31447 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31448 PyObject *resultobj = NULL;
31449 wxWindow *arg1 = (wxWindow *) 0 ;
31450 wxPoint *arg2 = 0 ;
31451 wxHitTest result;
31452 wxPoint temp2 ;
31453 PyObject * obj0 = 0 ;
31454 PyObject * obj1 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self",(char *) "pt", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 {
31463 arg2 = &temp2;
31464 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31465 }
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31469
31470 wxPyEndAllowThreads(__tstate);
31471 if (PyErr_Occurred()) SWIG_fail;
31472 }
31473 resultobj = SWIG_From_int((result));
31474 return resultobj;
31475 fail:
31476 return NULL;
31477 }
31478
31479
31480 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31481 PyObject *resultobj = NULL;
31482 wxWindow *arg1 = (wxWindow *) 0 ;
31483 long arg2 ;
31484 wxBorder result;
31485 PyObject * obj0 = 0 ;
31486 PyObject * obj1 = 0 ;
31487
31488 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31490 if (SWIG_arg_fail(1)) SWIG_fail;
31491 {
31492 arg2 = static_cast<long >(SWIG_As_long(obj1));
31493 if (SWIG_arg_fail(2)) SWIG_fail;
31494 }
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31498
31499 wxPyEndAllowThreads(__tstate);
31500 if (PyErr_Occurred()) SWIG_fail;
31501 }
31502 resultobj = SWIG_From_int((result));
31503 return resultobj;
31504 fail:
31505 return NULL;
31506 }
31507
31508
31509 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31510 PyObject *resultobj = NULL;
31511 wxWindow *arg1 = (wxWindow *) 0 ;
31512 wxBorder result;
31513 PyObject * obj0 = 0 ;
31514
31515 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31517 if (SWIG_arg_fail(1)) SWIG_fail;
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31521
31522 wxPyEndAllowThreads(__tstate);
31523 if (PyErr_Occurred()) SWIG_fail;
31524 }
31525 resultobj = SWIG_From_int((result));
31526 return resultobj;
31527 fail:
31528 return NULL;
31529 }
31530
31531
31532 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31533 int argc;
31534 PyObject *argv[3];
31535 int ii;
31536
31537 argc = PyObject_Length(args);
31538 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31539 argv[ii] = PyTuple_GetItem(args,ii);
31540 }
31541 if (argc == 1) {
31542 int _v;
31543 {
31544 void *ptr;
31545 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31546 _v = 0;
31547 PyErr_Clear();
31548 } else {
31549 _v = 1;
31550 }
31551 }
31552 if (_v) {
31553 return _wrap_Window_GetBorder__SWIG_1(self,args);
31554 }
31555 }
31556 if (argc == 2) {
31557 int _v;
31558 {
31559 void *ptr;
31560 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31561 _v = 0;
31562 PyErr_Clear();
31563 } else {
31564 _v = 1;
31565 }
31566 }
31567 if (_v) {
31568 _v = SWIG_Check_long(argv[1]);
31569 if (_v) {
31570 return _wrap_Window_GetBorder__SWIG_0(self,args);
31571 }
31572 }
31573 }
31574
31575 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31576 return NULL;
31577 }
31578
31579
31580 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31581 PyObject *resultobj = NULL;
31582 wxWindow *arg1 = (wxWindow *) 0 ;
31583 long arg2 = (long) wxUPDATE_UI_NONE ;
31584 PyObject * obj0 = 0 ;
31585 PyObject * obj1 = 0 ;
31586 char *kwnames[] = {
31587 (char *) "self",(char *) "flags", NULL
31588 };
31589
31590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31592 if (SWIG_arg_fail(1)) SWIG_fail;
31593 if (obj1) {
31594 {
31595 arg2 = static_cast<long >(SWIG_As_long(obj1));
31596 if (SWIG_arg_fail(2)) SWIG_fail;
31597 }
31598 }
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 (arg1)->UpdateWindowUI(arg2);
31602
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 Py_INCREF(Py_None); resultobj = Py_None;
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31614 PyObject *resultobj = NULL;
31615 wxWindow *arg1 = (wxWindow *) 0 ;
31616 wxMenu *arg2 = (wxMenu *) 0 ;
31617 int arg3 = (int) -1 ;
31618 int arg4 = (int) -1 ;
31619 bool result;
31620 PyObject * obj0 = 0 ;
31621 PyObject * obj1 = 0 ;
31622 PyObject * obj2 = 0 ;
31623 PyObject * obj3 = 0 ;
31624 char *kwnames[] = {
31625 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31626 };
31627
31628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31630 if (SWIG_arg_fail(1)) SWIG_fail;
31631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31632 if (SWIG_arg_fail(2)) SWIG_fail;
31633 if (obj2) {
31634 {
31635 arg3 = static_cast<int >(SWIG_As_int(obj2));
31636 if (SWIG_arg_fail(3)) SWIG_fail;
31637 }
31638 }
31639 if (obj3) {
31640 {
31641 arg4 = static_cast<int >(SWIG_As_int(obj3));
31642 if (SWIG_arg_fail(4)) SWIG_fail;
31643 }
31644 }
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31648
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 {
31653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31654 }
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj = NULL;
31663 wxWindow *arg1 = (wxWindow *) 0 ;
31664 wxMenu *arg2 = (wxMenu *) 0 ;
31665 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31666 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31667 bool result;
31668 wxPoint temp3 ;
31669 PyObject * obj0 = 0 ;
31670 PyObject * obj1 = 0 ;
31671 PyObject * obj2 = 0 ;
31672 char *kwnames[] = {
31673 (char *) "self",(char *) "menu",(char *) "pos", NULL
31674 };
31675
31676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31678 if (SWIG_arg_fail(1)) SWIG_fail;
31679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31680 if (SWIG_arg_fail(2)) SWIG_fail;
31681 if (obj2) {
31682 {
31683 arg3 = &temp3;
31684 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31685 }
31686 }
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31690
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 {
31695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31696 }
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31704 PyObject *resultobj = NULL;
31705 wxWindow *arg1 = (wxWindow *) 0 ;
31706 long result;
31707 PyObject * obj0 = 0 ;
31708 char *kwnames[] = {
31709 (char *) "self", NULL
31710 };
31711
31712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31714 if (SWIG_arg_fail(1)) SWIG_fail;
31715 {
31716 PyThreadState* __tstate = wxPyBeginAllowThreads();
31717 result = (long)wxWindow_GetHandle(arg1);
31718
31719 wxPyEndAllowThreads(__tstate);
31720 if (PyErr_Occurred()) SWIG_fail;
31721 }
31722 {
31723 resultobj = SWIG_From_long(static_cast<long >(result));
31724 }
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31732 PyObject *resultobj = NULL;
31733 wxWindow *arg1 = (wxWindow *) 0 ;
31734 long arg2 ;
31735 PyObject * obj0 = 0 ;
31736 PyObject * obj1 = 0 ;
31737 char *kwnames[] = {
31738 (char *) "self",(char *) "handle", NULL
31739 };
31740
31741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31743 if (SWIG_arg_fail(1)) SWIG_fail;
31744 {
31745 arg2 = static_cast<long >(SWIG_As_long(obj1));
31746 if (SWIG_arg_fail(2)) SWIG_fail;
31747 }
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 wxWindow_AssociateHandle(arg1,arg2);
31751
31752 wxPyEndAllowThreads(__tstate);
31753 if (PyErr_Occurred()) SWIG_fail;
31754 }
31755 Py_INCREF(Py_None); resultobj = Py_None;
31756 return resultobj;
31757 fail:
31758 return NULL;
31759 }
31760
31761
31762 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31763 PyObject *resultobj = NULL;
31764 wxWindow *arg1 = (wxWindow *) 0 ;
31765 PyObject * obj0 = 0 ;
31766 char *kwnames[] = {
31767 (char *) "self", NULL
31768 };
31769
31770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31772 if (SWIG_arg_fail(1)) SWIG_fail;
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 (arg1)->DissociateHandle();
31776
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 Py_INCREF(Py_None); resultobj = Py_None;
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31788 PyObject *resultobj = NULL;
31789 wxWindow *arg1 = (wxWindow *) 0 ;
31790 int arg2 ;
31791 bool result;
31792 PyObject * obj0 = 0 ;
31793 PyObject * obj1 = 0 ;
31794 char *kwnames[] = {
31795 (char *) "self",(char *) "orient", NULL
31796 };
31797
31798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31800 if (SWIG_arg_fail(1)) SWIG_fail;
31801 {
31802 arg2 = static_cast<int >(SWIG_As_int(obj1));
31803 if (SWIG_arg_fail(2)) SWIG_fail;
31804 }
31805 {
31806 PyThreadState* __tstate = wxPyBeginAllowThreads();
31807 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31808
31809 wxPyEndAllowThreads(__tstate);
31810 if (PyErr_Occurred()) SWIG_fail;
31811 }
31812 {
31813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31814 }
31815 return resultobj;
31816 fail:
31817 return NULL;
31818 }
31819
31820
31821 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31822 PyObject *resultobj = NULL;
31823 wxWindow *arg1 = (wxWindow *) 0 ;
31824 int arg2 ;
31825 int arg3 ;
31826 int arg4 ;
31827 int arg5 ;
31828 bool arg6 = (bool) true ;
31829 PyObject * obj0 = 0 ;
31830 PyObject * obj1 = 0 ;
31831 PyObject * obj2 = 0 ;
31832 PyObject * obj3 = 0 ;
31833 PyObject * obj4 = 0 ;
31834 PyObject * obj5 = 0 ;
31835 char *kwnames[] = {
31836 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31837 };
31838
31839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31841 if (SWIG_arg_fail(1)) SWIG_fail;
31842 {
31843 arg2 = static_cast<int >(SWIG_As_int(obj1));
31844 if (SWIG_arg_fail(2)) SWIG_fail;
31845 }
31846 {
31847 arg3 = static_cast<int >(SWIG_As_int(obj2));
31848 if (SWIG_arg_fail(3)) SWIG_fail;
31849 }
31850 {
31851 arg4 = static_cast<int >(SWIG_As_int(obj3));
31852 if (SWIG_arg_fail(4)) SWIG_fail;
31853 }
31854 {
31855 arg5 = static_cast<int >(SWIG_As_int(obj4));
31856 if (SWIG_arg_fail(5)) SWIG_fail;
31857 }
31858 if (obj5) {
31859 {
31860 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31861 if (SWIG_arg_fail(6)) SWIG_fail;
31862 }
31863 }
31864 {
31865 PyThreadState* __tstate = wxPyBeginAllowThreads();
31866 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31867
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 Py_INCREF(Py_None); resultobj = Py_None;
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31879 PyObject *resultobj = NULL;
31880 wxWindow *arg1 = (wxWindow *) 0 ;
31881 int arg2 ;
31882 int arg3 ;
31883 bool arg4 = (bool) true ;
31884 PyObject * obj0 = 0 ;
31885 PyObject * obj1 = 0 ;
31886 PyObject * obj2 = 0 ;
31887 PyObject * obj3 = 0 ;
31888 char *kwnames[] = {
31889 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31890 };
31891
31892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31894 if (SWIG_arg_fail(1)) SWIG_fail;
31895 {
31896 arg2 = static_cast<int >(SWIG_As_int(obj1));
31897 if (SWIG_arg_fail(2)) SWIG_fail;
31898 }
31899 {
31900 arg3 = static_cast<int >(SWIG_As_int(obj2));
31901 if (SWIG_arg_fail(3)) SWIG_fail;
31902 }
31903 if (obj3) {
31904 {
31905 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
31906 if (SWIG_arg_fail(4)) SWIG_fail;
31907 }
31908 }
31909 {
31910 PyThreadState* __tstate = wxPyBeginAllowThreads();
31911 (arg1)->SetScrollPos(arg2,arg3,arg4);
31912
31913 wxPyEndAllowThreads(__tstate);
31914 if (PyErr_Occurred()) SWIG_fail;
31915 }
31916 Py_INCREF(Py_None); resultobj = Py_None;
31917 return resultobj;
31918 fail:
31919 return NULL;
31920 }
31921
31922
31923 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31924 PyObject *resultobj = NULL;
31925 wxWindow *arg1 = (wxWindow *) 0 ;
31926 int arg2 ;
31927 int result;
31928 PyObject * obj0 = 0 ;
31929 PyObject * obj1 = 0 ;
31930 char *kwnames[] = {
31931 (char *) "self",(char *) "orientation", NULL
31932 };
31933
31934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31936 if (SWIG_arg_fail(1)) SWIG_fail;
31937 {
31938 arg2 = static_cast<int >(SWIG_As_int(obj1));
31939 if (SWIG_arg_fail(2)) SWIG_fail;
31940 }
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31944
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 {
31949 resultobj = SWIG_From_int(static_cast<int >(result));
31950 }
31951 return resultobj;
31952 fail:
31953 return NULL;
31954 }
31955
31956
31957 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31958 PyObject *resultobj = NULL;
31959 wxWindow *arg1 = (wxWindow *) 0 ;
31960 int arg2 ;
31961 int result;
31962 PyObject * obj0 = 0 ;
31963 PyObject * obj1 = 0 ;
31964 char *kwnames[] = {
31965 (char *) "self",(char *) "orientation", NULL
31966 };
31967
31968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31970 if (SWIG_arg_fail(1)) SWIG_fail;
31971 {
31972 arg2 = static_cast<int >(SWIG_As_int(obj1));
31973 if (SWIG_arg_fail(2)) SWIG_fail;
31974 }
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31978
31979 wxPyEndAllowThreads(__tstate);
31980 if (PyErr_Occurred()) SWIG_fail;
31981 }
31982 {
31983 resultobj = SWIG_From_int(static_cast<int >(result));
31984 }
31985 return resultobj;
31986 fail:
31987 return NULL;
31988 }
31989
31990
31991 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31992 PyObject *resultobj = NULL;
31993 wxWindow *arg1 = (wxWindow *) 0 ;
31994 int arg2 ;
31995 int result;
31996 PyObject * obj0 = 0 ;
31997 PyObject * obj1 = 0 ;
31998 char *kwnames[] = {
31999 (char *) "self",(char *) "orientation", NULL
32000 };
32001
32002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32004 if (SWIG_arg_fail(1)) SWIG_fail;
32005 {
32006 arg2 = static_cast<int >(SWIG_As_int(obj1));
32007 if (SWIG_arg_fail(2)) SWIG_fail;
32008 }
32009 {
32010 PyThreadState* __tstate = wxPyBeginAllowThreads();
32011 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32012
32013 wxPyEndAllowThreads(__tstate);
32014 if (PyErr_Occurred()) SWIG_fail;
32015 }
32016 {
32017 resultobj = SWIG_From_int(static_cast<int >(result));
32018 }
32019 return resultobj;
32020 fail:
32021 return NULL;
32022 }
32023
32024
32025 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32026 PyObject *resultobj = NULL;
32027 wxWindow *arg1 = (wxWindow *) 0 ;
32028 int arg2 ;
32029 int arg3 ;
32030 wxRect *arg4 = (wxRect *) NULL ;
32031 PyObject * obj0 = 0 ;
32032 PyObject * obj1 = 0 ;
32033 PyObject * obj2 = 0 ;
32034 PyObject * obj3 = 0 ;
32035 char *kwnames[] = {
32036 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32037 };
32038
32039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32041 if (SWIG_arg_fail(1)) SWIG_fail;
32042 {
32043 arg2 = static_cast<int >(SWIG_As_int(obj1));
32044 if (SWIG_arg_fail(2)) SWIG_fail;
32045 }
32046 {
32047 arg3 = static_cast<int >(SWIG_As_int(obj2));
32048 if (SWIG_arg_fail(3)) SWIG_fail;
32049 }
32050 if (obj3) {
32051 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32052 if (SWIG_arg_fail(4)) SWIG_fail;
32053 }
32054 {
32055 PyThreadState* __tstate = wxPyBeginAllowThreads();
32056 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32057
32058 wxPyEndAllowThreads(__tstate);
32059 if (PyErr_Occurred()) SWIG_fail;
32060 }
32061 Py_INCREF(Py_None); resultobj = Py_None;
32062 return resultobj;
32063 fail:
32064 return NULL;
32065 }
32066
32067
32068 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32069 PyObject *resultobj = NULL;
32070 wxWindow *arg1 = (wxWindow *) 0 ;
32071 int arg2 ;
32072 bool result;
32073 PyObject * obj0 = 0 ;
32074 PyObject * obj1 = 0 ;
32075 char *kwnames[] = {
32076 (char *) "self",(char *) "lines", NULL
32077 };
32078
32079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32081 if (SWIG_arg_fail(1)) SWIG_fail;
32082 {
32083 arg2 = static_cast<int >(SWIG_As_int(obj1));
32084 if (SWIG_arg_fail(2)) SWIG_fail;
32085 }
32086 {
32087 PyThreadState* __tstate = wxPyBeginAllowThreads();
32088 result = (bool)(arg1)->ScrollLines(arg2);
32089
32090 wxPyEndAllowThreads(__tstate);
32091 if (PyErr_Occurred()) SWIG_fail;
32092 }
32093 {
32094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32095 }
32096 return resultobj;
32097 fail:
32098 return NULL;
32099 }
32100
32101
32102 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32103 PyObject *resultobj = NULL;
32104 wxWindow *arg1 = (wxWindow *) 0 ;
32105 int arg2 ;
32106 bool result;
32107 PyObject * obj0 = 0 ;
32108 PyObject * obj1 = 0 ;
32109 char *kwnames[] = {
32110 (char *) "self",(char *) "pages", NULL
32111 };
32112
32113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32115 if (SWIG_arg_fail(1)) SWIG_fail;
32116 {
32117 arg2 = static_cast<int >(SWIG_As_int(obj1));
32118 if (SWIG_arg_fail(2)) SWIG_fail;
32119 }
32120 {
32121 PyThreadState* __tstate = wxPyBeginAllowThreads();
32122 result = (bool)(arg1)->ScrollPages(arg2);
32123
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 {
32128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32129 }
32130 return resultobj;
32131 fail:
32132 return NULL;
32133 }
32134
32135
32136 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32137 PyObject *resultobj = NULL;
32138 wxWindow *arg1 = (wxWindow *) 0 ;
32139 bool result;
32140 PyObject * obj0 = 0 ;
32141 char *kwnames[] = {
32142 (char *) "self", NULL
32143 };
32144
32145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32147 if (SWIG_arg_fail(1)) SWIG_fail;
32148 {
32149 PyThreadState* __tstate = wxPyBeginAllowThreads();
32150 result = (bool)(arg1)->LineUp();
32151
32152 wxPyEndAllowThreads(__tstate);
32153 if (PyErr_Occurred()) SWIG_fail;
32154 }
32155 {
32156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32157 }
32158 return resultobj;
32159 fail:
32160 return NULL;
32161 }
32162
32163
32164 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32165 PyObject *resultobj = NULL;
32166 wxWindow *arg1 = (wxWindow *) 0 ;
32167 bool result;
32168 PyObject * obj0 = 0 ;
32169 char *kwnames[] = {
32170 (char *) "self", NULL
32171 };
32172
32173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32175 if (SWIG_arg_fail(1)) SWIG_fail;
32176 {
32177 PyThreadState* __tstate = wxPyBeginAllowThreads();
32178 result = (bool)(arg1)->LineDown();
32179
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 {
32184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32185 }
32186 return resultobj;
32187 fail:
32188 return NULL;
32189 }
32190
32191
32192 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32193 PyObject *resultobj = NULL;
32194 wxWindow *arg1 = (wxWindow *) 0 ;
32195 bool result;
32196 PyObject * obj0 = 0 ;
32197 char *kwnames[] = {
32198 (char *) "self", NULL
32199 };
32200
32201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32203 if (SWIG_arg_fail(1)) SWIG_fail;
32204 {
32205 PyThreadState* __tstate = wxPyBeginAllowThreads();
32206 result = (bool)(arg1)->PageUp();
32207
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 {
32212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32213 }
32214 return resultobj;
32215 fail:
32216 return NULL;
32217 }
32218
32219
32220 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32221 PyObject *resultobj = NULL;
32222 wxWindow *arg1 = (wxWindow *) 0 ;
32223 bool result;
32224 PyObject * obj0 = 0 ;
32225 char *kwnames[] = {
32226 (char *) "self", NULL
32227 };
32228
32229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32231 if (SWIG_arg_fail(1)) SWIG_fail;
32232 {
32233 PyThreadState* __tstate = wxPyBeginAllowThreads();
32234 result = (bool)(arg1)->PageDown();
32235
32236 wxPyEndAllowThreads(__tstate);
32237 if (PyErr_Occurred()) SWIG_fail;
32238 }
32239 {
32240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32241 }
32242 return resultobj;
32243 fail:
32244 return NULL;
32245 }
32246
32247
32248 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32249 PyObject *resultobj = NULL;
32250 wxWindow *arg1 = (wxWindow *) 0 ;
32251 wxString *arg2 = 0 ;
32252 bool temp2 = false ;
32253 PyObject * obj0 = 0 ;
32254 PyObject * obj1 = 0 ;
32255 char *kwnames[] = {
32256 (char *) "self",(char *) "text", NULL
32257 };
32258
32259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32261 if (SWIG_arg_fail(1)) SWIG_fail;
32262 {
32263 arg2 = wxString_in_helper(obj1);
32264 if (arg2 == NULL) SWIG_fail;
32265 temp2 = true;
32266 }
32267 {
32268 PyThreadState* __tstate = wxPyBeginAllowThreads();
32269 (arg1)->SetHelpText((wxString const &)*arg2);
32270
32271 wxPyEndAllowThreads(__tstate);
32272 if (PyErr_Occurred()) SWIG_fail;
32273 }
32274 Py_INCREF(Py_None); resultobj = Py_None;
32275 {
32276 if (temp2)
32277 delete arg2;
32278 }
32279 return resultobj;
32280 fail:
32281 {
32282 if (temp2)
32283 delete arg2;
32284 }
32285 return NULL;
32286 }
32287
32288
32289 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32290 PyObject *resultobj = NULL;
32291 wxWindow *arg1 = (wxWindow *) 0 ;
32292 wxString *arg2 = 0 ;
32293 bool temp2 = false ;
32294 PyObject * obj0 = 0 ;
32295 PyObject * obj1 = 0 ;
32296 char *kwnames[] = {
32297 (char *) "self",(char *) "text", NULL
32298 };
32299
32300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32302 if (SWIG_arg_fail(1)) SWIG_fail;
32303 {
32304 arg2 = wxString_in_helper(obj1);
32305 if (arg2 == NULL) SWIG_fail;
32306 temp2 = true;
32307 }
32308 {
32309 PyThreadState* __tstate = wxPyBeginAllowThreads();
32310 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32311
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 Py_INCREF(Py_None); resultobj = Py_None;
32316 {
32317 if (temp2)
32318 delete arg2;
32319 }
32320 return resultobj;
32321 fail:
32322 {
32323 if (temp2)
32324 delete arg2;
32325 }
32326 return NULL;
32327 }
32328
32329
32330 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32331 PyObject *resultobj = NULL;
32332 wxWindow *arg1 = (wxWindow *) 0 ;
32333 wxString result;
32334 PyObject * obj0 = 0 ;
32335 char *kwnames[] = {
32336 (char *) "self", NULL
32337 };
32338
32339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32341 if (SWIG_arg_fail(1)) SWIG_fail;
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 result = ((wxWindow const *)arg1)->GetHelpText();
32345
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 {
32350 #if wxUSE_UNICODE
32351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32352 #else
32353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32354 #endif
32355 }
32356 return resultobj;
32357 fail:
32358 return NULL;
32359 }
32360
32361
32362 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32363 PyObject *resultobj = NULL;
32364 wxWindow *arg1 = (wxWindow *) 0 ;
32365 wxString *arg2 = 0 ;
32366 bool temp2 = false ;
32367 PyObject * obj0 = 0 ;
32368 PyObject * obj1 = 0 ;
32369 char *kwnames[] = {
32370 (char *) "self",(char *) "tip", NULL
32371 };
32372
32373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32375 if (SWIG_arg_fail(1)) SWIG_fail;
32376 {
32377 arg2 = wxString_in_helper(obj1);
32378 if (arg2 == NULL) SWIG_fail;
32379 temp2 = true;
32380 }
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 (arg1)->SetToolTip((wxString const &)*arg2);
32384
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 Py_INCREF(Py_None); resultobj = Py_None;
32389 {
32390 if (temp2)
32391 delete arg2;
32392 }
32393 return resultobj;
32394 fail:
32395 {
32396 if (temp2)
32397 delete arg2;
32398 }
32399 return NULL;
32400 }
32401
32402
32403 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32404 PyObject *resultobj = NULL;
32405 wxWindow *arg1 = (wxWindow *) 0 ;
32406 wxToolTip *arg2 = (wxToolTip *) 0 ;
32407 PyObject * obj0 = 0 ;
32408 PyObject * obj1 = 0 ;
32409 char *kwnames[] = {
32410 (char *) "self",(char *) "tip", NULL
32411 };
32412
32413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32415 if (SWIG_arg_fail(1)) SWIG_fail;
32416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32417 if (SWIG_arg_fail(2)) SWIG_fail;
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 (arg1)->SetToolTip(arg2);
32421
32422 wxPyEndAllowThreads(__tstate);
32423 if (PyErr_Occurred()) SWIG_fail;
32424 }
32425 Py_INCREF(Py_None); resultobj = Py_None;
32426 return resultobj;
32427 fail:
32428 return NULL;
32429 }
32430
32431
32432 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32433 PyObject *resultobj = NULL;
32434 wxWindow *arg1 = (wxWindow *) 0 ;
32435 wxToolTip *result;
32436 PyObject * obj0 = 0 ;
32437 char *kwnames[] = {
32438 (char *) "self", NULL
32439 };
32440
32441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32443 if (SWIG_arg_fail(1)) SWIG_fail;
32444 {
32445 PyThreadState* __tstate = wxPyBeginAllowThreads();
32446 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32447
32448 wxPyEndAllowThreads(__tstate);
32449 if (PyErr_Occurred()) SWIG_fail;
32450 }
32451 {
32452 resultobj = wxPyMake_wxObject(result, 0);
32453 }
32454 return resultobj;
32455 fail:
32456 return NULL;
32457 }
32458
32459
32460 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32461 PyObject *resultobj = NULL;
32462 wxWindow *arg1 = (wxWindow *) 0 ;
32463 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32464 PyObject * obj0 = 0 ;
32465 PyObject * obj1 = 0 ;
32466 char *kwnames[] = {
32467 (char *) "self",(char *) "dropTarget", NULL
32468 };
32469
32470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32472 if (SWIG_arg_fail(1)) SWIG_fail;
32473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32474 if (SWIG_arg_fail(2)) SWIG_fail;
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 (arg1)->SetDropTarget(arg2);
32478
32479 wxPyEndAllowThreads(__tstate);
32480 if (PyErr_Occurred()) SWIG_fail;
32481 }
32482 Py_INCREF(Py_None); resultobj = Py_None;
32483 return resultobj;
32484 fail:
32485 return NULL;
32486 }
32487
32488
32489 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32490 PyObject *resultobj = NULL;
32491 wxWindow *arg1 = (wxWindow *) 0 ;
32492 wxPyDropTarget *result;
32493 PyObject * obj0 = 0 ;
32494 char *kwnames[] = {
32495 (char *) "self", NULL
32496 };
32497
32498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32500 if (SWIG_arg_fail(1)) SWIG_fail;
32501 {
32502 PyThreadState* __tstate = wxPyBeginAllowThreads();
32503 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32504
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32516 PyObject *resultobj = NULL;
32517 wxWindow *arg1 = (wxWindow *) 0 ;
32518 bool arg2 ;
32519 PyObject * obj0 = 0 ;
32520 PyObject * obj1 = 0 ;
32521 char *kwnames[] = {
32522 (char *) "self",(char *) "accept", NULL
32523 };
32524
32525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32527 if (SWIG_arg_fail(1)) SWIG_fail;
32528 {
32529 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32530 if (SWIG_arg_fail(2)) SWIG_fail;
32531 }
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 wxWindow_DragAcceptFiles(arg1,arg2);
32535
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 Py_INCREF(Py_None); resultobj = Py_None;
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32547 PyObject *resultobj = NULL;
32548 wxWindow *arg1 = (wxWindow *) 0 ;
32549 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32550 PyObject * obj0 = 0 ;
32551 PyObject * obj1 = 0 ;
32552 char *kwnames[] = {
32553 (char *) "self",(char *) "constraints", NULL
32554 };
32555
32556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32558 if (SWIG_arg_fail(1)) SWIG_fail;
32559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32560 if (SWIG_arg_fail(2)) SWIG_fail;
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 (arg1)->SetConstraints(arg2);
32564
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 Py_INCREF(Py_None); resultobj = Py_None;
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32576 PyObject *resultobj = NULL;
32577 wxWindow *arg1 = (wxWindow *) 0 ;
32578 wxLayoutConstraints *result;
32579 PyObject * obj0 = 0 ;
32580 char *kwnames[] = {
32581 (char *) "self", NULL
32582 };
32583
32584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32586 if (SWIG_arg_fail(1)) SWIG_fail;
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32590
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj = NULL;
32603 wxWindow *arg1 = (wxWindow *) 0 ;
32604 bool arg2 ;
32605 PyObject * obj0 = 0 ;
32606 PyObject * obj1 = 0 ;
32607 char *kwnames[] = {
32608 (char *) "self",(char *) "autoLayout", NULL
32609 };
32610
32611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32613 if (SWIG_arg_fail(1)) SWIG_fail;
32614 {
32615 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32616 if (SWIG_arg_fail(2)) SWIG_fail;
32617 }
32618 {
32619 PyThreadState* __tstate = wxPyBeginAllowThreads();
32620 (arg1)->SetAutoLayout(arg2);
32621
32622 wxPyEndAllowThreads(__tstate);
32623 if (PyErr_Occurred()) SWIG_fail;
32624 }
32625 Py_INCREF(Py_None); resultobj = Py_None;
32626 return resultobj;
32627 fail:
32628 return NULL;
32629 }
32630
32631
32632 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32633 PyObject *resultobj = NULL;
32634 wxWindow *arg1 = (wxWindow *) 0 ;
32635 bool result;
32636 PyObject * obj0 = 0 ;
32637 char *kwnames[] = {
32638 (char *) "self", NULL
32639 };
32640
32641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32643 if (SWIG_arg_fail(1)) SWIG_fail;
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32647
32648 wxPyEndAllowThreads(__tstate);
32649 if (PyErr_Occurred()) SWIG_fail;
32650 }
32651 {
32652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32653 }
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32661 PyObject *resultobj = NULL;
32662 wxWindow *arg1 = (wxWindow *) 0 ;
32663 bool result;
32664 PyObject * obj0 = 0 ;
32665 char *kwnames[] = {
32666 (char *) "self", NULL
32667 };
32668
32669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32671 if (SWIG_arg_fail(1)) SWIG_fail;
32672 {
32673 PyThreadState* __tstate = wxPyBeginAllowThreads();
32674 result = (bool)(arg1)->Layout();
32675
32676 wxPyEndAllowThreads(__tstate);
32677 if (PyErr_Occurred()) SWIG_fail;
32678 }
32679 {
32680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32681 }
32682 return resultobj;
32683 fail:
32684 return NULL;
32685 }
32686
32687
32688 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32689 PyObject *resultobj = NULL;
32690 wxWindow *arg1 = (wxWindow *) 0 ;
32691 wxSizer *arg2 = (wxSizer *) 0 ;
32692 bool arg3 = (bool) true ;
32693 PyObject * obj0 = 0 ;
32694 PyObject * obj1 = 0 ;
32695 PyObject * obj2 = 0 ;
32696 char *kwnames[] = {
32697 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32698 };
32699
32700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32702 if (SWIG_arg_fail(1)) SWIG_fail;
32703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32704 if (SWIG_arg_fail(2)) SWIG_fail;
32705 if (obj2) {
32706 {
32707 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32708 if (SWIG_arg_fail(3)) SWIG_fail;
32709 }
32710 }
32711 {
32712 PyThreadState* __tstate = wxPyBeginAllowThreads();
32713 (arg1)->SetSizer(arg2,arg3);
32714
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 Py_INCREF(Py_None); resultobj = Py_None;
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj = NULL;
32727 wxWindow *arg1 = (wxWindow *) 0 ;
32728 wxSizer *arg2 = (wxSizer *) 0 ;
32729 bool arg3 = (bool) true ;
32730 PyObject * obj0 = 0 ;
32731 PyObject * obj1 = 0 ;
32732 PyObject * obj2 = 0 ;
32733 char *kwnames[] = {
32734 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32735 };
32736
32737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32739 if (SWIG_arg_fail(1)) SWIG_fail;
32740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32741 if (SWIG_arg_fail(2)) SWIG_fail;
32742 if (obj2) {
32743 {
32744 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32745 if (SWIG_arg_fail(3)) SWIG_fail;
32746 }
32747 }
32748 {
32749 PyThreadState* __tstate = wxPyBeginAllowThreads();
32750 (arg1)->SetSizerAndFit(arg2,arg3);
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_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32763 PyObject *resultobj = NULL;
32764 wxWindow *arg1 = (wxWindow *) 0 ;
32765 wxSizer *result;
32766 PyObject * obj0 = 0 ;
32767 char *kwnames[] = {
32768 (char *) "self", NULL
32769 };
32770
32771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",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 = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32777
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 {
32782 resultobj = wxPyMake_wxObject(result, 0);
32783 }
32784 return resultobj;
32785 fail:
32786 return NULL;
32787 }
32788
32789
32790 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32791 PyObject *resultobj = NULL;
32792 wxWindow *arg1 = (wxWindow *) 0 ;
32793 wxSizer *arg2 = (wxSizer *) 0 ;
32794 PyObject * obj0 = 0 ;
32795 PyObject * obj1 = 0 ;
32796 char *kwnames[] = {
32797 (char *) "self",(char *) "sizer", NULL
32798 };
32799
32800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32802 if (SWIG_arg_fail(1)) SWIG_fail;
32803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32804 if (SWIG_arg_fail(2)) SWIG_fail;
32805 {
32806 PyThreadState* __tstate = wxPyBeginAllowThreads();
32807 (arg1)->SetContainingSizer(arg2);
32808
32809 wxPyEndAllowThreads(__tstate);
32810 if (PyErr_Occurred()) SWIG_fail;
32811 }
32812 Py_INCREF(Py_None); resultobj = Py_None;
32813 return resultobj;
32814 fail:
32815 return NULL;
32816 }
32817
32818
32819 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32820 PyObject *resultobj = NULL;
32821 wxWindow *arg1 = (wxWindow *) 0 ;
32822 wxSizer *result;
32823 PyObject * obj0 = 0 ;
32824 char *kwnames[] = {
32825 (char *) "self", NULL
32826 };
32827
32828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32830 if (SWIG_arg_fail(1)) SWIG_fail;
32831 {
32832 PyThreadState* __tstate = wxPyBeginAllowThreads();
32833 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32834
32835 wxPyEndAllowThreads(__tstate);
32836 if (PyErr_Occurred()) SWIG_fail;
32837 }
32838 {
32839 resultobj = wxPyMake_wxObject(result, 0);
32840 }
32841 return resultobj;
32842 fail:
32843 return NULL;
32844 }
32845
32846
32847 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32848 PyObject *resultobj = NULL;
32849 wxWindow *arg1 = (wxWindow *) 0 ;
32850 PyObject * obj0 = 0 ;
32851 char *kwnames[] = {
32852 (char *) "self", NULL
32853 };
32854
32855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32857 if (SWIG_arg_fail(1)) SWIG_fail;
32858 {
32859 PyThreadState* __tstate = wxPyBeginAllowThreads();
32860 (arg1)->InheritAttributes();
32861
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 Py_INCREF(Py_None); resultobj = Py_None;
32866 return resultobj;
32867 fail:
32868 return NULL;
32869 }
32870
32871
32872 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32873 PyObject *resultobj = NULL;
32874 wxWindow *arg1 = (wxWindow *) 0 ;
32875 bool result;
32876 PyObject * obj0 = 0 ;
32877 char *kwnames[] = {
32878 (char *) "self", NULL
32879 };
32880
32881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32883 if (SWIG_arg_fail(1)) SWIG_fail;
32884 {
32885 PyThreadState* __tstate = wxPyBeginAllowThreads();
32886 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32887
32888 wxPyEndAllowThreads(__tstate);
32889 if (PyErr_Occurred()) SWIG_fail;
32890 }
32891 {
32892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32893 }
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32901 PyObject *obj;
32902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32903 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32904 Py_INCREF(obj);
32905 return Py_BuildValue((char *)"");
32906 }
32907 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32908 PyObject *resultobj = NULL;
32909 long arg1 ;
32910 wxWindow *arg2 = (wxWindow *) NULL ;
32911 wxWindow *result;
32912 PyObject * obj0 = 0 ;
32913 PyObject * obj1 = 0 ;
32914 char *kwnames[] = {
32915 (char *) "id",(char *) "parent", NULL
32916 };
32917
32918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32919 {
32920 arg1 = static_cast<long >(SWIG_As_long(obj0));
32921 if (SWIG_arg_fail(1)) SWIG_fail;
32922 }
32923 if (obj1) {
32924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32925 if (SWIG_arg_fail(2)) SWIG_fail;
32926 }
32927 {
32928 if (!wxPyCheckForApp()) SWIG_fail;
32929 PyThreadState* __tstate = wxPyBeginAllowThreads();
32930 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32931
32932 wxPyEndAllowThreads(__tstate);
32933 if (PyErr_Occurred()) SWIG_fail;
32934 }
32935 {
32936 resultobj = wxPyMake_wxObject(result, 0);
32937 }
32938 return resultobj;
32939 fail:
32940 return NULL;
32941 }
32942
32943
32944 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32945 PyObject *resultobj = NULL;
32946 wxString *arg1 = 0 ;
32947 wxWindow *arg2 = (wxWindow *) NULL ;
32948 wxWindow *result;
32949 bool temp1 = false ;
32950 PyObject * obj0 = 0 ;
32951 PyObject * obj1 = 0 ;
32952 char *kwnames[] = {
32953 (char *) "name",(char *) "parent", NULL
32954 };
32955
32956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32957 {
32958 arg1 = wxString_in_helper(obj0);
32959 if (arg1 == NULL) SWIG_fail;
32960 temp1 = true;
32961 }
32962 if (obj1) {
32963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32964 if (SWIG_arg_fail(2)) SWIG_fail;
32965 }
32966 {
32967 if (!wxPyCheckForApp()) SWIG_fail;
32968 PyThreadState* __tstate = wxPyBeginAllowThreads();
32969 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32970
32971 wxPyEndAllowThreads(__tstate);
32972 if (PyErr_Occurred()) SWIG_fail;
32973 }
32974 {
32975 resultobj = wxPyMake_wxObject(result, 0);
32976 }
32977 {
32978 if (temp1)
32979 delete arg1;
32980 }
32981 return resultobj;
32982 fail:
32983 {
32984 if (temp1)
32985 delete arg1;
32986 }
32987 return NULL;
32988 }
32989
32990
32991 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32992 PyObject *resultobj = NULL;
32993 wxString *arg1 = 0 ;
32994 wxWindow *arg2 = (wxWindow *) NULL ;
32995 wxWindow *result;
32996 bool temp1 = false ;
32997 PyObject * obj0 = 0 ;
32998 PyObject * obj1 = 0 ;
32999 char *kwnames[] = {
33000 (char *) "label",(char *) "parent", NULL
33001 };
33002
33003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33004 {
33005 arg1 = wxString_in_helper(obj0);
33006 if (arg1 == NULL) SWIG_fail;
33007 temp1 = true;
33008 }
33009 if (obj1) {
33010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33011 if (SWIG_arg_fail(2)) SWIG_fail;
33012 }
33013 {
33014 if (!wxPyCheckForApp()) SWIG_fail;
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33017
33018 wxPyEndAllowThreads(__tstate);
33019 if (PyErr_Occurred()) SWIG_fail;
33020 }
33021 {
33022 resultobj = wxPyMake_wxObject(result, 0);
33023 }
33024 {
33025 if (temp1)
33026 delete arg1;
33027 }
33028 return resultobj;
33029 fail:
33030 {
33031 if (temp1)
33032 delete arg1;
33033 }
33034 return NULL;
33035 }
33036
33037
33038 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33039 PyObject *resultobj = NULL;
33040 wxWindow *arg1 = (wxWindow *) 0 ;
33041 unsigned long arg2 ;
33042 wxWindow *result;
33043 PyObject * obj0 = 0 ;
33044 PyObject * obj1 = 0 ;
33045 char *kwnames[] = {
33046 (char *) "parent",(char *) "_hWnd", NULL
33047 };
33048
33049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33051 if (SWIG_arg_fail(1)) SWIG_fail;
33052 {
33053 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33054 if (SWIG_arg_fail(2)) SWIG_fail;
33055 }
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33059
33060 wxPyEndAllowThreads(__tstate);
33061 if (PyErr_Occurred()) SWIG_fail;
33062 }
33063 {
33064 resultobj = wxPyMake_wxObject(result, 0);
33065 }
33066 return resultobj;
33067 fail:
33068 return NULL;
33069 }
33070
33071
33072 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33073 PyObject *resultobj = NULL;
33074 PyObject *result;
33075 char *kwnames[] = {
33076 NULL
33077 };
33078
33079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 result = (PyObject *)GetTopLevelWindows();
33083
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 resultobj = result;
33088 return resultobj;
33089 fail:
33090 return NULL;
33091 }
33092
33093
33094 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33095 PyObject *resultobj = NULL;
33096 wxValidator *result;
33097 char *kwnames[] = {
33098 NULL
33099 };
33100
33101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 result = (wxValidator *)new wxValidator();
33105
33106 wxPyEndAllowThreads(__tstate);
33107 if (PyErr_Occurred()) SWIG_fail;
33108 }
33109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33110 return resultobj;
33111 fail:
33112 return NULL;
33113 }
33114
33115
33116 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33117 PyObject *resultobj = NULL;
33118 wxValidator *arg1 = (wxValidator *) 0 ;
33119 wxValidator *result;
33120 PyObject * obj0 = 0 ;
33121 char *kwnames[] = {
33122 (char *) "self", NULL
33123 };
33124
33125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33127 if (SWIG_arg_fail(1)) SWIG_fail;
33128 {
33129 PyThreadState* __tstate = wxPyBeginAllowThreads();
33130 result = (wxValidator *)(arg1)->Clone();
33131
33132 wxPyEndAllowThreads(__tstate);
33133 if (PyErr_Occurred()) SWIG_fail;
33134 }
33135 {
33136 resultobj = wxPyMake_wxObject(result, 0);
33137 }
33138 return resultobj;
33139 fail:
33140 return NULL;
33141 }
33142
33143
33144 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33145 PyObject *resultobj = NULL;
33146 wxValidator *arg1 = (wxValidator *) 0 ;
33147 wxWindow *arg2 = (wxWindow *) 0 ;
33148 bool result;
33149 PyObject * obj0 = 0 ;
33150 PyObject * obj1 = 0 ;
33151 char *kwnames[] = {
33152 (char *) "self",(char *) "parent", NULL
33153 };
33154
33155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33157 if (SWIG_arg_fail(1)) SWIG_fail;
33158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33159 if (SWIG_arg_fail(2)) SWIG_fail;
33160 {
33161 PyThreadState* __tstate = wxPyBeginAllowThreads();
33162 result = (bool)(arg1)->Validate(arg2);
33163
33164 wxPyEndAllowThreads(__tstate);
33165 if (PyErr_Occurred()) SWIG_fail;
33166 }
33167 {
33168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33169 }
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33177 PyObject *resultobj = NULL;
33178 wxValidator *arg1 = (wxValidator *) 0 ;
33179 bool result;
33180 PyObject * obj0 = 0 ;
33181 char *kwnames[] = {
33182 (char *) "self", NULL
33183 };
33184
33185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33187 if (SWIG_arg_fail(1)) SWIG_fail;
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 result = (bool)(arg1)->TransferToWindow();
33191
33192 wxPyEndAllowThreads(__tstate);
33193 if (PyErr_Occurred()) SWIG_fail;
33194 }
33195 {
33196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33197 }
33198 return resultobj;
33199 fail:
33200 return NULL;
33201 }
33202
33203
33204 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33205 PyObject *resultobj = NULL;
33206 wxValidator *arg1 = (wxValidator *) 0 ;
33207 bool result;
33208 PyObject * obj0 = 0 ;
33209 char *kwnames[] = {
33210 (char *) "self", NULL
33211 };
33212
33213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33215 if (SWIG_arg_fail(1)) SWIG_fail;
33216 {
33217 PyThreadState* __tstate = wxPyBeginAllowThreads();
33218 result = (bool)(arg1)->TransferFromWindow();
33219
33220 wxPyEndAllowThreads(__tstate);
33221 if (PyErr_Occurred()) SWIG_fail;
33222 }
33223 {
33224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33225 }
33226 return resultobj;
33227 fail:
33228 return NULL;
33229 }
33230
33231
33232 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33233 PyObject *resultobj = NULL;
33234 wxValidator *arg1 = (wxValidator *) 0 ;
33235 wxWindow *result;
33236 PyObject * obj0 = 0 ;
33237 char *kwnames[] = {
33238 (char *) "self", NULL
33239 };
33240
33241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33243 if (SWIG_arg_fail(1)) SWIG_fail;
33244 {
33245 PyThreadState* __tstate = wxPyBeginAllowThreads();
33246 result = (wxWindow *)(arg1)->GetWindow();
33247
33248 wxPyEndAllowThreads(__tstate);
33249 if (PyErr_Occurred()) SWIG_fail;
33250 }
33251 {
33252 resultobj = wxPyMake_wxObject(result, 0);
33253 }
33254 return resultobj;
33255 fail:
33256 return NULL;
33257 }
33258
33259
33260 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33261 PyObject *resultobj = NULL;
33262 wxValidator *arg1 = (wxValidator *) 0 ;
33263 wxWindow *arg2 = (wxWindow *) 0 ;
33264 PyObject * obj0 = 0 ;
33265 PyObject * obj1 = 0 ;
33266 char *kwnames[] = {
33267 (char *) "self",(char *) "window", NULL
33268 };
33269
33270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33272 if (SWIG_arg_fail(1)) SWIG_fail;
33273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33274 if (SWIG_arg_fail(2)) SWIG_fail;
33275 {
33276 PyThreadState* __tstate = wxPyBeginAllowThreads();
33277 (arg1)->SetWindow(arg2);
33278
33279 wxPyEndAllowThreads(__tstate);
33280 if (PyErr_Occurred()) SWIG_fail;
33281 }
33282 Py_INCREF(Py_None); resultobj = Py_None;
33283 return resultobj;
33284 fail:
33285 return NULL;
33286 }
33287
33288
33289 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33290 PyObject *resultobj = NULL;
33291 bool result;
33292 char *kwnames[] = {
33293 NULL
33294 };
33295
33296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33297 {
33298 PyThreadState* __tstate = wxPyBeginAllowThreads();
33299 result = (bool)wxValidator::IsSilent();
33300
33301 wxPyEndAllowThreads(__tstate);
33302 if (PyErr_Occurred()) SWIG_fail;
33303 }
33304 {
33305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33306 }
33307 return resultobj;
33308 fail:
33309 return NULL;
33310 }
33311
33312
33313 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33314 PyObject *resultobj = NULL;
33315 int arg1 = (int) true ;
33316 PyObject * obj0 = 0 ;
33317 char *kwnames[] = {
33318 (char *) "doIt", NULL
33319 };
33320
33321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33322 if (obj0) {
33323 {
33324 arg1 = static_cast<int >(SWIG_As_int(obj0));
33325 if (SWIG_arg_fail(1)) SWIG_fail;
33326 }
33327 }
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 wxValidator::SetBellOnError(arg1);
33331
33332 wxPyEndAllowThreads(__tstate);
33333 if (PyErr_Occurred()) SWIG_fail;
33334 }
33335 Py_INCREF(Py_None); resultobj = Py_None;
33336 return resultobj;
33337 fail:
33338 return NULL;
33339 }
33340
33341
33342 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33343 PyObject *obj;
33344 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33345 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33346 Py_INCREF(obj);
33347 return Py_BuildValue((char *)"");
33348 }
33349 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33350 PyObject *resultobj = NULL;
33351 wxPyValidator *result;
33352 char *kwnames[] = {
33353 NULL
33354 };
33355
33356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 result = (wxPyValidator *)new wxPyValidator();
33360
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33365 return resultobj;
33366 fail:
33367 return NULL;
33368 }
33369
33370
33371 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33372 PyObject *resultobj = NULL;
33373 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33374 PyObject *arg2 = (PyObject *) 0 ;
33375 PyObject *arg3 = (PyObject *) 0 ;
33376 int arg4 = (int) true ;
33377 PyObject * obj0 = 0 ;
33378 PyObject * obj1 = 0 ;
33379 PyObject * obj2 = 0 ;
33380 PyObject * obj3 = 0 ;
33381 char *kwnames[] = {
33382 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33383 };
33384
33385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33387 if (SWIG_arg_fail(1)) SWIG_fail;
33388 arg2 = obj1;
33389 arg3 = obj2;
33390 if (obj3) {
33391 {
33392 arg4 = static_cast<int >(SWIG_As_int(obj3));
33393 if (SWIG_arg_fail(4)) SWIG_fail;
33394 }
33395 }
33396 {
33397 PyThreadState* __tstate = wxPyBeginAllowThreads();
33398 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33399
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 Py_INCREF(Py_None); resultobj = Py_None;
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33411 PyObject *obj;
33412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33413 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33414 Py_INCREF(obj);
33415 return Py_BuildValue((char *)"");
33416 }
33417 static int _wrap_DefaultValidator_set(PyObject *) {
33418 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33419 return 1;
33420 }
33421
33422
33423 static PyObject *_wrap_DefaultValidator_get(void) {
33424 PyObject *pyobj = NULL;
33425
33426 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33427 return pyobj;
33428 }
33429
33430
33431 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33432 PyObject *resultobj = NULL;
33433 wxString const &arg1_defvalue = wxPyEmptyString ;
33434 wxString *arg1 = (wxString *) &arg1_defvalue ;
33435 long arg2 = (long) 0 ;
33436 wxMenu *result;
33437 bool temp1 = false ;
33438 PyObject * obj0 = 0 ;
33439 PyObject * obj1 = 0 ;
33440 char *kwnames[] = {
33441 (char *) "title",(char *) "style", NULL
33442 };
33443
33444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33445 if (obj0) {
33446 {
33447 arg1 = wxString_in_helper(obj0);
33448 if (arg1 == NULL) SWIG_fail;
33449 temp1 = true;
33450 }
33451 }
33452 if (obj1) {
33453 {
33454 arg2 = static_cast<long >(SWIG_As_long(obj1));
33455 if (SWIG_arg_fail(2)) SWIG_fail;
33456 }
33457 }
33458 {
33459 if (!wxPyCheckForApp()) SWIG_fail;
33460 PyThreadState* __tstate = wxPyBeginAllowThreads();
33461 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33462
33463 wxPyEndAllowThreads(__tstate);
33464 if (PyErr_Occurred()) SWIG_fail;
33465 }
33466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33467 {
33468 if (temp1)
33469 delete arg1;
33470 }
33471 return resultobj;
33472 fail:
33473 {
33474 if (temp1)
33475 delete arg1;
33476 }
33477 return NULL;
33478 }
33479
33480
33481 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33482 PyObject *resultobj = NULL;
33483 wxMenu *arg1 = (wxMenu *) 0 ;
33484 int arg2 ;
33485 wxString *arg3 = 0 ;
33486 wxString const &arg4_defvalue = wxPyEmptyString ;
33487 wxString *arg4 = (wxString *) &arg4_defvalue ;
33488 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33489 wxMenuItem *result;
33490 bool temp3 = false ;
33491 bool temp4 = false ;
33492 PyObject * obj0 = 0 ;
33493 PyObject * obj1 = 0 ;
33494 PyObject * obj2 = 0 ;
33495 PyObject * obj3 = 0 ;
33496 PyObject * obj4 = 0 ;
33497 char *kwnames[] = {
33498 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33499 };
33500
33501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33503 if (SWIG_arg_fail(1)) SWIG_fail;
33504 {
33505 arg2 = static_cast<int >(SWIG_As_int(obj1));
33506 if (SWIG_arg_fail(2)) SWIG_fail;
33507 }
33508 {
33509 arg3 = wxString_in_helper(obj2);
33510 if (arg3 == NULL) SWIG_fail;
33511 temp3 = true;
33512 }
33513 if (obj3) {
33514 {
33515 arg4 = wxString_in_helper(obj3);
33516 if (arg4 == NULL) SWIG_fail;
33517 temp4 = true;
33518 }
33519 }
33520 if (obj4) {
33521 {
33522 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33523 if (SWIG_arg_fail(5)) SWIG_fail;
33524 }
33525 }
33526 {
33527 PyThreadState* __tstate = wxPyBeginAllowThreads();
33528 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33529
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 {
33534 resultobj = wxPyMake_wxObject(result, 0);
33535 }
33536 {
33537 if (temp3)
33538 delete arg3;
33539 }
33540 {
33541 if (temp4)
33542 delete arg4;
33543 }
33544 return resultobj;
33545 fail:
33546 {
33547 if (temp3)
33548 delete arg3;
33549 }
33550 {
33551 if (temp4)
33552 delete arg4;
33553 }
33554 return NULL;
33555 }
33556
33557
33558 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33559 PyObject *resultobj = NULL;
33560 wxMenu *arg1 = (wxMenu *) 0 ;
33561 wxMenuItem *result;
33562 PyObject * obj0 = 0 ;
33563 char *kwnames[] = {
33564 (char *) "self", NULL
33565 };
33566
33567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33569 if (SWIG_arg_fail(1)) SWIG_fail;
33570 {
33571 PyThreadState* __tstate = wxPyBeginAllowThreads();
33572 result = (wxMenuItem *)(arg1)->AppendSeparator();
33573
33574 wxPyEndAllowThreads(__tstate);
33575 if (PyErr_Occurred()) SWIG_fail;
33576 }
33577 {
33578 resultobj = wxPyMake_wxObject(result, 0);
33579 }
33580 return resultobj;
33581 fail:
33582 return NULL;
33583 }
33584
33585
33586 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33587 PyObject *resultobj = NULL;
33588 wxMenu *arg1 = (wxMenu *) 0 ;
33589 int arg2 ;
33590 wxString *arg3 = 0 ;
33591 wxString const &arg4_defvalue = wxPyEmptyString ;
33592 wxString *arg4 = (wxString *) &arg4_defvalue ;
33593 wxMenuItem *result;
33594 bool temp3 = false ;
33595 bool temp4 = false ;
33596 PyObject * obj0 = 0 ;
33597 PyObject * obj1 = 0 ;
33598 PyObject * obj2 = 0 ;
33599 PyObject * obj3 = 0 ;
33600 char *kwnames[] = {
33601 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33602 };
33603
33604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33606 if (SWIG_arg_fail(1)) SWIG_fail;
33607 {
33608 arg2 = static_cast<int >(SWIG_As_int(obj1));
33609 if (SWIG_arg_fail(2)) SWIG_fail;
33610 }
33611 {
33612 arg3 = wxString_in_helper(obj2);
33613 if (arg3 == NULL) SWIG_fail;
33614 temp3 = true;
33615 }
33616 if (obj3) {
33617 {
33618 arg4 = wxString_in_helper(obj3);
33619 if (arg4 == NULL) SWIG_fail;
33620 temp4 = true;
33621 }
33622 }
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33626
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 {
33631 resultobj = wxPyMake_wxObject(result, 0);
33632 }
33633 {
33634 if (temp3)
33635 delete arg3;
33636 }
33637 {
33638 if (temp4)
33639 delete arg4;
33640 }
33641 return resultobj;
33642 fail:
33643 {
33644 if (temp3)
33645 delete arg3;
33646 }
33647 {
33648 if (temp4)
33649 delete arg4;
33650 }
33651 return NULL;
33652 }
33653
33654
33655 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj = NULL;
33657 wxMenu *arg1 = (wxMenu *) 0 ;
33658 int arg2 ;
33659 wxString *arg3 = 0 ;
33660 wxString const &arg4_defvalue = wxPyEmptyString ;
33661 wxString *arg4 = (wxString *) &arg4_defvalue ;
33662 wxMenuItem *result;
33663 bool temp3 = false ;
33664 bool temp4 = false ;
33665 PyObject * obj0 = 0 ;
33666 PyObject * obj1 = 0 ;
33667 PyObject * obj2 = 0 ;
33668 PyObject * obj3 = 0 ;
33669 char *kwnames[] = {
33670 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33671 };
33672
33673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33675 if (SWIG_arg_fail(1)) SWIG_fail;
33676 {
33677 arg2 = static_cast<int >(SWIG_As_int(obj1));
33678 if (SWIG_arg_fail(2)) SWIG_fail;
33679 }
33680 {
33681 arg3 = wxString_in_helper(obj2);
33682 if (arg3 == NULL) SWIG_fail;
33683 temp3 = true;
33684 }
33685 if (obj3) {
33686 {
33687 arg4 = wxString_in_helper(obj3);
33688 if (arg4 == NULL) SWIG_fail;
33689 temp4 = true;
33690 }
33691 }
33692 {
33693 PyThreadState* __tstate = wxPyBeginAllowThreads();
33694 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33695
33696 wxPyEndAllowThreads(__tstate);
33697 if (PyErr_Occurred()) SWIG_fail;
33698 }
33699 {
33700 resultobj = wxPyMake_wxObject(result, 0);
33701 }
33702 {
33703 if (temp3)
33704 delete arg3;
33705 }
33706 {
33707 if (temp4)
33708 delete arg4;
33709 }
33710 return resultobj;
33711 fail:
33712 {
33713 if (temp3)
33714 delete arg3;
33715 }
33716 {
33717 if (temp4)
33718 delete arg4;
33719 }
33720 return NULL;
33721 }
33722
33723
33724 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj = NULL;
33726 wxMenu *arg1 = (wxMenu *) 0 ;
33727 int arg2 ;
33728 wxString *arg3 = 0 ;
33729 wxMenu *arg4 = (wxMenu *) 0 ;
33730 wxString const &arg5_defvalue = wxPyEmptyString ;
33731 wxString *arg5 = (wxString *) &arg5_defvalue ;
33732 wxMenuItem *result;
33733 bool temp3 = false ;
33734 bool temp5 = false ;
33735 PyObject * obj0 = 0 ;
33736 PyObject * obj1 = 0 ;
33737 PyObject * obj2 = 0 ;
33738 PyObject * obj3 = 0 ;
33739 PyObject * obj4 = 0 ;
33740 char *kwnames[] = {
33741 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33742 };
33743
33744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33746 if (SWIG_arg_fail(1)) SWIG_fail;
33747 {
33748 arg2 = static_cast<int >(SWIG_As_int(obj1));
33749 if (SWIG_arg_fail(2)) SWIG_fail;
33750 }
33751 {
33752 arg3 = wxString_in_helper(obj2);
33753 if (arg3 == NULL) SWIG_fail;
33754 temp3 = true;
33755 }
33756 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33757 if (SWIG_arg_fail(4)) SWIG_fail;
33758 if (obj4) {
33759 {
33760 arg5 = wxString_in_helper(obj4);
33761 if (arg5 == NULL) SWIG_fail;
33762 temp5 = true;
33763 }
33764 }
33765 {
33766 PyThreadState* __tstate = wxPyBeginAllowThreads();
33767 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33768
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 {
33773 resultobj = wxPyMake_wxObject(result, 0);
33774 }
33775 {
33776 if (temp3)
33777 delete arg3;
33778 }
33779 {
33780 if (temp5)
33781 delete arg5;
33782 }
33783 return resultobj;
33784 fail:
33785 {
33786 if (temp3)
33787 delete arg3;
33788 }
33789 {
33790 if (temp5)
33791 delete arg5;
33792 }
33793 return NULL;
33794 }
33795
33796
33797 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33798 PyObject *resultobj = NULL;
33799 wxMenu *arg1 = (wxMenu *) 0 ;
33800 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33801 wxMenuItem *result;
33802 PyObject * obj0 = 0 ;
33803 PyObject * obj1 = 0 ;
33804 char *kwnames[] = {
33805 (char *) "self",(char *) "item", NULL
33806 };
33807
33808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33810 if (SWIG_arg_fail(1)) SWIG_fail;
33811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33812 if (SWIG_arg_fail(2)) SWIG_fail;
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 result = (wxMenuItem *)(arg1)->Append(arg2);
33816
33817 wxPyEndAllowThreads(__tstate);
33818 if (PyErr_Occurred()) SWIG_fail;
33819 }
33820 {
33821 resultobj = wxPyMake_wxObject(result, 0);
33822 }
33823 return resultobj;
33824 fail:
33825 return NULL;
33826 }
33827
33828
33829 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33830 PyObject *resultobj = NULL;
33831 wxMenu *arg1 = (wxMenu *) 0 ;
33832 PyObject * obj0 = 0 ;
33833 char *kwnames[] = {
33834 (char *) "self", NULL
33835 };
33836
33837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33839 if (SWIG_arg_fail(1)) SWIG_fail;
33840 {
33841 PyThreadState* __tstate = wxPyBeginAllowThreads();
33842 (arg1)->Break();
33843
33844 wxPyEndAllowThreads(__tstate);
33845 if (PyErr_Occurred()) SWIG_fail;
33846 }
33847 Py_INCREF(Py_None); resultobj = Py_None;
33848 return resultobj;
33849 fail:
33850 return NULL;
33851 }
33852
33853
33854 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33855 PyObject *resultobj = NULL;
33856 wxMenu *arg1 = (wxMenu *) 0 ;
33857 size_t arg2 ;
33858 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33859 wxMenuItem *result;
33860 PyObject * obj0 = 0 ;
33861 PyObject * obj1 = 0 ;
33862 PyObject * obj2 = 0 ;
33863 char *kwnames[] = {
33864 (char *) "self",(char *) "pos",(char *) "item", NULL
33865 };
33866
33867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33869 if (SWIG_arg_fail(1)) SWIG_fail;
33870 {
33871 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33872 if (SWIG_arg_fail(2)) SWIG_fail;
33873 }
33874 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33875 if (SWIG_arg_fail(3)) SWIG_fail;
33876 {
33877 PyThreadState* __tstate = wxPyBeginAllowThreads();
33878 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33879
33880 wxPyEndAllowThreads(__tstate);
33881 if (PyErr_Occurred()) SWIG_fail;
33882 }
33883 {
33884 resultobj = wxPyMake_wxObject(result, 0);
33885 }
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33893 PyObject *resultobj = NULL;
33894 wxMenu *arg1 = (wxMenu *) 0 ;
33895 size_t arg2 ;
33896 int arg3 ;
33897 wxString *arg4 = 0 ;
33898 wxString const &arg5_defvalue = wxPyEmptyString ;
33899 wxString *arg5 = (wxString *) &arg5_defvalue ;
33900 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33901 wxMenuItem *result;
33902 bool temp4 = false ;
33903 bool temp5 = false ;
33904 PyObject * obj0 = 0 ;
33905 PyObject * obj1 = 0 ;
33906 PyObject * obj2 = 0 ;
33907 PyObject * obj3 = 0 ;
33908 PyObject * obj4 = 0 ;
33909 PyObject * obj5 = 0 ;
33910 char *kwnames[] = {
33911 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33912 };
33913
33914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33916 if (SWIG_arg_fail(1)) SWIG_fail;
33917 {
33918 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33919 if (SWIG_arg_fail(2)) SWIG_fail;
33920 }
33921 {
33922 arg3 = static_cast<int >(SWIG_As_int(obj2));
33923 if (SWIG_arg_fail(3)) SWIG_fail;
33924 }
33925 {
33926 arg4 = wxString_in_helper(obj3);
33927 if (arg4 == NULL) SWIG_fail;
33928 temp4 = true;
33929 }
33930 if (obj4) {
33931 {
33932 arg5 = wxString_in_helper(obj4);
33933 if (arg5 == NULL) SWIG_fail;
33934 temp5 = true;
33935 }
33936 }
33937 if (obj5) {
33938 {
33939 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
33940 if (SWIG_arg_fail(6)) SWIG_fail;
33941 }
33942 }
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
33946
33947 wxPyEndAllowThreads(__tstate);
33948 if (PyErr_Occurred()) SWIG_fail;
33949 }
33950 {
33951 resultobj = wxPyMake_wxObject(result, 0);
33952 }
33953 {
33954 if (temp4)
33955 delete arg4;
33956 }
33957 {
33958 if (temp5)
33959 delete arg5;
33960 }
33961 return resultobj;
33962 fail:
33963 {
33964 if (temp4)
33965 delete arg4;
33966 }
33967 {
33968 if (temp5)
33969 delete arg5;
33970 }
33971 return NULL;
33972 }
33973
33974
33975 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33976 PyObject *resultobj = NULL;
33977 wxMenu *arg1 = (wxMenu *) 0 ;
33978 size_t arg2 ;
33979 wxMenuItem *result;
33980 PyObject * obj0 = 0 ;
33981 PyObject * obj1 = 0 ;
33982 char *kwnames[] = {
33983 (char *) "self",(char *) "pos", NULL
33984 };
33985
33986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33988 if (SWIG_arg_fail(1)) SWIG_fail;
33989 {
33990 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33991 if (SWIG_arg_fail(2)) SWIG_fail;
33992 }
33993 {
33994 PyThreadState* __tstate = wxPyBeginAllowThreads();
33995 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33996
33997 wxPyEndAllowThreads(__tstate);
33998 if (PyErr_Occurred()) SWIG_fail;
33999 }
34000 {
34001 resultobj = wxPyMake_wxObject(result, 0);
34002 }
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = NULL;
34011 wxMenu *arg1 = (wxMenu *) 0 ;
34012 size_t arg2 ;
34013 int arg3 ;
34014 wxString *arg4 = 0 ;
34015 wxString const &arg5_defvalue = wxPyEmptyString ;
34016 wxString *arg5 = (wxString *) &arg5_defvalue ;
34017 wxMenuItem *result;
34018 bool temp4 = false ;
34019 bool temp5 = false ;
34020 PyObject * obj0 = 0 ;
34021 PyObject * obj1 = 0 ;
34022 PyObject * obj2 = 0 ;
34023 PyObject * obj3 = 0 ;
34024 PyObject * obj4 = 0 ;
34025 char *kwnames[] = {
34026 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34027 };
34028
34029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34031 if (SWIG_arg_fail(1)) SWIG_fail;
34032 {
34033 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34034 if (SWIG_arg_fail(2)) SWIG_fail;
34035 }
34036 {
34037 arg3 = static_cast<int >(SWIG_As_int(obj2));
34038 if (SWIG_arg_fail(3)) SWIG_fail;
34039 }
34040 {
34041 arg4 = wxString_in_helper(obj3);
34042 if (arg4 == NULL) SWIG_fail;
34043 temp4 = true;
34044 }
34045 if (obj4) {
34046 {
34047 arg5 = wxString_in_helper(obj4);
34048 if (arg5 == NULL) SWIG_fail;
34049 temp5 = true;
34050 }
34051 }
34052 {
34053 PyThreadState* __tstate = wxPyBeginAllowThreads();
34054 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34055
34056 wxPyEndAllowThreads(__tstate);
34057 if (PyErr_Occurred()) SWIG_fail;
34058 }
34059 {
34060 resultobj = wxPyMake_wxObject(result, 0);
34061 }
34062 {
34063 if (temp4)
34064 delete arg4;
34065 }
34066 {
34067 if (temp5)
34068 delete arg5;
34069 }
34070 return resultobj;
34071 fail:
34072 {
34073 if (temp4)
34074 delete arg4;
34075 }
34076 {
34077 if (temp5)
34078 delete arg5;
34079 }
34080 return NULL;
34081 }
34082
34083
34084 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34085 PyObject *resultobj = NULL;
34086 wxMenu *arg1 = (wxMenu *) 0 ;
34087 size_t arg2 ;
34088 int arg3 ;
34089 wxString *arg4 = 0 ;
34090 wxString const &arg5_defvalue = wxPyEmptyString ;
34091 wxString *arg5 = (wxString *) &arg5_defvalue ;
34092 wxMenuItem *result;
34093 bool temp4 = false ;
34094 bool temp5 = false ;
34095 PyObject * obj0 = 0 ;
34096 PyObject * obj1 = 0 ;
34097 PyObject * obj2 = 0 ;
34098 PyObject * obj3 = 0 ;
34099 PyObject * obj4 = 0 ;
34100 char *kwnames[] = {
34101 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34102 };
34103
34104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34106 if (SWIG_arg_fail(1)) SWIG_fail;
34107 {
34108 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34109 if (SWIG_arg_fail(2)) SWIG_fail;
34110 }
34111 {
34112 arg3 = static_cast<int >(SWIG_As_int(obj2));
34113 if (SWIG_arg_fail(3)) SWIG_fail;
34114 }
34115 {
34116 arg4 = wxString_in_helper(obj3);
34117 if (arg4 == NULL) SWIG_fail;
34118 temp4 = true;
34119 }
34120 if (obj4) {
34121 {
34122 arg5 = wxString_in_helper(obj4);
34123 if (arg5 == NULL) SWIG_fail;
34124 temp5 = true;
34125 }
34126 }
34127 {
34128 PyThreadState* __tstate = wxPyBeginAllowThreads();
34129 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34130
34131 wxPyEndAllowThreads(__tstate);
34132 if (PyErr_Occurred()) SWIG_fail;
34133 }
34134 {
34135 resultobj = wxPyMake_wxObject(result, 0);
34136 }
34137 {
34138 if (temp4)
34139 delete arg4;
34140 }
34141 {
34142 if (temp5)
34143 delete arg5;
34144 }
34145 return resultobj;
34146 fail:
34147 {
34148 if (temp4)
34149 delete arg4;
34150 }
34151 {
34152 if (temp5)
34153 delete arg5;
34154 }
34155 return NULL;
34156 }
34157
34158
34159 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34160 PyObject *resultobj = NULL;
34161 wxMenu *arg1 = (wxMenu *) 0 ;
34162 size_t arg2 ;
34163 int arg3 ;
34164 wxString *arg4 = 0 ;
34165 wxMenu *arg5 = (wxMenu *) 0 ;
34166 wxString const &arg6_defvalue = wxPyEmptyString ;
34167 wxString *arg6 = (wxString *) &arg6_defvalue ;
34168 wxMenuItem *result;
34169 bool temp4 = false ;
34170 bool temp6 = false ;
34171 PyObject * obj0 = 0 ;
34172 PyObject * obj1 = 0 ;
34173 PyObject * obj2 = 0 ;
34174 PyObject * obj3 = 0 ;
34175 PyObject * obj4 = 0 ;
34176 PyObject * obj5 = 0 ;
34177 char *kwnames[] = {
34178 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34179 };
34180
34181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34183 if (SWIG_arg_fail(1)) SWIG_fail;
34184 {
34185 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34186 if (SWIG_arg_fail(2)) SWIG_fail;
34187 }
34188 {
34189 arg3 = static_cast<int >(SWIG_As_int(obj2));
34190 if (SWIG_arg_fail(3)) SWIG_fail;
34191 }
34192 {
34193 arg4 = wxString_in_helper(obj3);
34194 if (arg4 == NULL) SWIG_fail;
34195 temp4 = true;
34196 }
34197 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34198 if (SWIG_arg_fail(5)) SWIG_fail;
34199 if (obj5) {
34200 {
34201 arg6 = wxString_in_helper(obj5);
34202 if (arg6 == NULL) SWIG_fail;
34203 temp6 = true;
34204 }
34205 }
34206 {
34207 PyThreadState* __tstate = wxPyBeginAllowThreads();
34208 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34209
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 {
34214 resultobj = wxPyMake_wxObject(result, 0);
34215 }
34216 {
34217 if (temp4)
34218 delete arg4;
34219 }
34220 {
34221 if (temp6)
34222 delete arg6;
34223 }
34224 return resultobj;
34225 fail:
34226 {
34227 if (temp4)
34228 delete arg4;
34229 }
34230 {
34231 if (temp6)
34232 delete arg6;
34233 }
34234 return NULL;
34235 }
34236
34237
34238 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34239 PyObject *resultobj = NULL;
34240 wxMenu *arg1 = (wxMenu *) 0 ;
34241 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34242 wxMenuItem *result;
34243 PyObject * obj0 = 0 ;
34244 PyObject * obj1 = 0 ;
34245 char *kwnames[] = {
34246 (char *) "self",(char *) "item", NULL
34247 };
34248
34249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34251 if (SWIG_arg_fail(1)) SWIG_fail;
34252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34253 if (SWIG_arg_fail(2)) SWIG_fail;
34254 {
34255 PyThreadState* __tstate = wxPyBeginAllowThreads();
34256 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34257
34258 wxPyEndAllowThreads(__tstate);
34259 if (PyErr_Occurred()) SWIG_fail;
34260 }
34261 {
34262 resultobj = wxPyMake_wxObject(result, 0);
34263 }
34264 return resultobj;
34265 fail:
34266 return NULL;
34267 }
34268
34269
34270 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34271 PyObject *resultobj = NULL;
34272 wxMenu *arg1 = (wxMenu *) 0 ;
34273 int arg2 ;
34274 wxString *arg3 = 0 ;
34275 wxString const &arg4_defvalue = wxPyEmptyString ;
34276 wxString *arg4 = (wxString *) &arg4_defvalue ;
34277 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34278 wxMenuItem *result;
34279 bool temp3 = false ;
34280 bool temp4 = false ;
34281 PyObject * obj0 = 0 ;
34282 PyObject * obj1 = 0 ;
34283 PyObject * obj2 = 0 ;
34284 PyObject * obj3 = 0 ;
34285 PyObject * obj4 = 0 ;
34286 char *kwnames[] = {
34287 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34288 };
34289
34290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34292 if (SWIG_arg_fail(1)) SWIG_fail;
34293 {
34294 arg2 = static_cast<int >(SWIG_As_int(obj1));
34295 if (SWIG_arg_fail(2)) SWIG_fail;
34296 }
34297 {
34298 arg3 = wxString_in_helper(obj2);
34299 if (arg3 == NULL) SWIG_fail;
34300 temp3 = true;
34301 }
34302 if (obj3) {
34303 {
34304 arg4 = wxString_in_helper(obj3);
34305 if (arg4 == NULL) SWIG_fail;
34306 temp4 = true;
34307 }
34308 }
34309 if (obj4) {
34310 {
34311 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34312 if (SWIG_arg_fail(5)) SWIG_fail;
34313 }
34314 }
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34318
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 {
34323 resultobj = wxPyMake_wxObject(result, 0);
34324 }
34325 {
34326 if (temp3)
34327 delete arg3;
34328 }
34329 {
34330 if (temp4)
34331 delete arg4;
34332 }
34333 return resultobj;
34334 fail:
34335 {
34336 if (temp3)
34337 delete arg3;
34338 }
34339 {
34340 if (temp4)
34341 delete arg4;
34342 }
34343 return NULL;
34344 }
34345
34346
34347 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34348 PyObject *resultobj = NULL;
34349 wxMenu *arg1 = (wxMenu *) 0 ;
34350 wxMenuItem *result;
34351 PyObject * obj0 = 0 ;
34352 char *kwnames[] = {
34353 (char *) "self", NULL
34354 };
34355
34356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34358 if (SWIG_arg_fail(1)) SWIG_fail;
34359 {
34360 PyThreadState* __tstate = wxPyBeginAllowThreads();
34361 result = (wxMenuItem *)(arg1)->PrependSeparator();
34362
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 {
34367 resultobj = wxPyMake_wxObject(result, 0);
34368 }
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34376 PyObject *resultobj = NULL;
34377 wxMenu *arg1 = (wxMenu *) 0 ;
34378 int arg2 ;
34379 wxString *arg3 = 0 ;
34380 wxString const &arg4_defvalue = wxPyEmptyString ;
34381 wxString *arg4 = (wxString *) &arg4_defvalue ;
34382 wxMenuItem *result;
34383 bool temp3 = false ;
34384 bool temp4 = false ;
34385 PyObject * obj0 = 0 ;
34386 PyObject * obj1 = 0 ;
34387 PyObject * obj2 = 0 ;
34388 PyObject * obj3 = 0 ;
34389 char *kwnames[] = {
34390 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34391 };
34392
34393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34395 if (SWIG_arg_fail(1)) SWIG_fail;
34396 {
34397 arg2 = static_cast<int >(SWIG_As_int(obj1));
34398 if (SWIG_arg_fail(2)) SWIG_fail;
34399 }
34400 {
34401 arg3 = wxString_in_helper(obj2);
34402 if (arg3 == NULL) SWIG_fail;
34403 temp3 = true;
34404 }
34405 if (obj3) {
34406 {
34407 arg4 = wxString_in_helper(obj3);
34408 if (arg4 == NULL) SWIG_fail;
34409 temp4 = true;
34410 }
34411 }
34412 {
34413 PyThreadState* __tstate = wxPyBeginAllowThreads();
34414 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34415
34416 wxPyEndAllowThreads(__tstate);
34417 if (PyErr_Occurred()) SWIG_fail;
34418 }
34419 {
34420 resultobj = wxPyMake_wxObject(result, 0);
34421 }
34422 {
34423 if (temp3)
34424 delete arg3;
34425 }
34426 {
34427 if (temp4)
34428 delete arg4;
34429 }
34430 return resultobj;
34431 fail:
34432 {
34433 if (temp3)
34434 delete arg3;
34435 }
34436 {
34437 if (temp4)
34438 delete arg4;
34439 }
34440 return NULL;
34441 }
34442
34443
34444 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj = NULL;
34446 wxMenu *arg1 = (wxMenu *) 0 ;
34447 int arg2 ;
34448 wxString *arg3 = 0 ;
34449 wxString const &arg4_defvalue = wxPyEmptyString ;
34450 wxString *arg4 = (wxString *) &arg4_defvalue ;
34451 wxMenuItem *result;
34452 bool temp3 = false ;
34453 bool temp4 = false ;
34454 PyObject * obj0 = 0 ;
34455 PyObject * obj1 = 0 ;
34456 PyObject * obj2 = 0 ;
34457 PyObject * obj3 = 0 ;
34458 char *kwnames[] = {
34459 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34460 };
34461
34462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34464 if (SWIG_arg_fail(1)) SWIG_fail;
34465 {
34466 arg2 = static_cast<int >(SWIG_As_int(obj1));
34467 if (SWIG_arg_fail(2)) SWIG_fail;
34468 }
34469 {
34470 arg3 = wxString_in_helper(obj2);
34471 if (arg3 == NULL) SWIG_fail;
34472 temp3 = true;
34473 }
34474 if (obj3) {
34475 {
34476 arg4 = wxString_in_helper(obj3);
34477 if (arg4 == NULL) SWIG_fail;
34478 temp4 = true;
34479 }
34480 }
34481 {
34482 PyThreadState* __tstate = wxPyBeginAllowThreads();
34483 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34484
34485 wxPyEndAllowThreads(__tstate);
34486 if (PyErr_Occurred()) SWIG_fail;
34487 }
34488 {
34489 resultobj = wxPyMake_wxObject(result, 0);
34490 }
34491 {
34492 if (temp3)
34493 delete arg3;
34494 }
34495 {
34496 if (temp4)
34497 delete arg4;
34498 }
34499 return resultobj;
34500 fail:
34501 {
34502 if (temp3)
34503 delete arg3;
34504 }
34505 {
34506 if (temp4)
34507 delete arg4;
34508 }
34509 return NULL;
34510 }
34511
34512
34513 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34514 PyObject *resultobj = NULL;
34515 wxMenu *arg1 = (wxMenu *) 0 ;
34516 int arg2 ;
34517 wxString *arg3 = 0 ;
34518 wxMenu *arg4 = (wxMenu *) 0 ;
34519 wxString const &arg5_defvalue = wxPyEmptyString ;
34520 wxString *arg5 = (wxString *) &arg5_defvalue ;
34521 wxMenuItem *result;
34522 bool temp3 = false ;
34523 bool temp5 = false ;
34524 PyObject * obj0 = 0 ;
34525 PyObject * obj1 = 0 ;
34526 PyObject * obj2 = 0 ;
34527 PyObject * obj3 = 0 ;
34528 PyObject * obj4 = 0 ;
34529 char *kwnames[] = {
34530 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34531 };
34532
34533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34535 if (SWIG_arg_fail(1)) SWIG_fail;
34536 {
34537 arg2 = static_cast<int >(SWIG_As_int(obj1));
34538 if (SWIG_arg_fail(2)) SWIG_fail;
34539 }
34540 {
34541 arg3 = wxString_in_helper(obj2);
34542 if (arg3 == NULL) SWIG_fail;
34543 temp3 = true;
34544 }
34545 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34546 if (SWIG_arg_fail(4)) SWIG_fail;
34547 if (obj4) {
34548 {
34549 arg5 = wxString_in_helper(obj4);
34550 if (arg5 == NULL) SWIG_fail;
34551 temp5 = true;
34552 }
34553 }
34554 {
34555 PyThreadState* __tstate = wxPyBeginAllowThreads();
34556 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34557
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 {
34562 resultobj = wxPyMake_wxObject(result, 0);
34563 }
34564 {
34565 if (temp3)
34566 delete arg3;
34567 }
34568 {
34569 if (temp5)
34570 delete arg5;
34571 }
34572 return resultobj;
34573 fail:
34574 {
34575 if (temp3)
34576 delete arg3;
34577 }
34578 {
34579 if (temp5)
34580 delete arg5;
34581 }
34582 return NULL;
34583 }
34584
34585
34586 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34587 PyObject *resultobj = NULL;
34588 wxMenu *arg1 = (wxMenu *) 0 ;
34589 int arg2 ;
34590 wxMenuItem *result;
34591 PyObject * obj0 = 0 ;
34592 PyObject * obj1 = 0 ;
34593 char *kwnames[] = {
34594 (char *) "self",(char *) "id", NULL
34595 };
34596
34597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34599 if (SWIG_arg_fail(1)) SWIG_fail;
34600 {
34601 arg2 = static_cast<int >(SWIG_As_int(obj1));
34602 if (SWIG_arg_fail(2)) SWIG_fail;
34603 }
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = (wxMenuItem *)(arg1)->Remove(arg2);
34607
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 {
34612 resultobj = wxPyMake_wxObject(result, 0);
34613 }
34614 return resultobj;
34615 fail:
34616 return NULL;
34617 }
34618
34619
34620 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34621 PyObject *resultobj = NULL;
34622 wxMenu *arg1 = (wxMenu *) 0 ;
34623 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34624 wxMenuItem *result;
34625 PyObject * obj0 = 0 ;
34626 PyObject * obj1 = 0 ;
34627 char *kwnames[] = {
34628 (char *) "self",(char *) "item", NULL
34629 };
34630
34631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34633 if (SWIG_arg_fail(1)) SWIG_fail;
34634 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34635 if (SWIG_arg_fail(2)) SWIG_fail;
34636 {
34637 PyThreadState* __tstate = wxPyBeginAllowThreads();
34638 result = (wxMenuItem *)(arg1)->Remove(arg2);
34639
34640 wxPyEndAllowThreads(__tstate);
34641 if (PyErr_Occurred()) SWIG_fail;
34642 }
34643 {
34644 resultobj = wxPyMake_wxObject(result, 0);
34645 }
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34653 PyObject *resultobj = NULL;
34654 wxMenu *arg1 = (wxMenu *) 0 ;
34655 int arg2 ;
34656 bool result;
34657 PyObject * obj0 = 0 ;
34658 PyObject * obj1 = 0 ;
34659 char *kwnames[] = {
34660 (char *) "self",(char *) "id", NULL
34661 };
34662
34663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
34672 result = (bool)(arg1)->Delete(arg2);
34673
34674 wxPyEndAllowThreads(__tstate);
34675 if (PyErr_Occurred()) SWIG_fail;
34676 }
34677 {
34678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34679 }
34680 return resultobj;
34681 fail:
34682 return NULL;
34683 }
34684
34685
34686 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34687 PyObject *resultobj = NULL;
34688 wxMenu *arg1 = (wxMenu *) 0 ;
34689 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34690 bool result;
34691 PyObject * obj0 = 0 ;
34692 PyObject * obj1 = 0 ;
34693 char *kwnames[] = {
34694 (char *) "self",(char *) "item", NULL
34695 };
34696
34697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34699 if (SWIG_arg_fail(1)) SWIG_fail;
34700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34701 if (SWIG_arg_fail(2)) SWIG_fail;
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 result = (bool)(arg1)->Delete(arg2);
34705
34706 wxPyEndAllowThreads(__tstate);
34707 if (PyErr_Occurred()) SWIG_fail;
34708 }
34709 {
34710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34711 }
34712 return resultobj;
34713 fail:
34714 return NULL;
34715 }
34716
34717
34718 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34719 PyObject *resultobj = NULL;
34720 wxMenu *arg1 = (wxMenu *) 0 ;
34721 PyObject * obj0 = 0 ;
34722 char *kwnames[] = {
34723 (char *) "self", NULL
34724 };
34725
34726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34728 if (SWIG_arg_fail(1)) SWIG_fail;
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 wxMenu_Destroy(arg1);
34732
34733 wxPyEndAllowThreads(__tstate);
34734 if (PyErr_Occurred()) SWIG_fail;
34735 }
34736 Py_INCREF(Py_None); resultobj = Py_None;
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34744 PyObject *resultobj = NULL;
34745 wxMenu *arg1 = (wxMenu *) 0 ;
34746 int arg2 ;
34747 bool result;
34748 PyObject * obj0 = 0 ;
34749 PyObject * obj1 = 0 ;
34750 char *kwnames[] = {
34751 (char *) "self",(char *) "id", NULL
34752 };
34753
34754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34756 if (SWIG_arg_fail(1)) SWIG_fail;
34757 {
34758 arg2 = static_cast<int >(SWIG_As_int(obj1));
34759 if (SWIG_arg_fail(2)) SWIG_fail;
34760 }
34761 {
34762 PyThreadState* __tstate = wxPyBeginAllowThreads();
34763 result = (bool)(arg1)->Destroy(arg2);
34764
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 {
34769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34770 }
34771 return resultobj;
34772 fail:
34773 return NULL;
34774 }
34775
34776
34777 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34778 PyObject *resultobj = NULL;
34779 wxMenu *arg1 = (wxMenu *) 0 ;
34780 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34781 bool result;
34782 PyObject * obj0 = 0 ;
34783 PyObject * obj1 = 0 ;
34784 char *kwnames[] = {
34785 (char *) "self",(char *) "item", NULL
34786 };
34787
34788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34790 if (SWIG_arg_fail(1)) SWIG_fail;
34791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34792 if (SWIG_arg_fail(2)) SWIG_fail;
34793 {
34794 PyThreadState* __tstate = wxPyBeginAllowThreads();
34795 result = (bool)(arg1)->Destroy(arg2);
34796
34797 wxPyEndAllowThreads(__tstate);
34798 if (PyErr_Occurred()) SWIG_fail;
34799 }
34800 {
34801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34802 }
34803 return resultobj;
34804 fail:
34805 return NULL;
34806 }
34807
34808
34809 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34810 PyObject *resultobj = NULL;
34811 wxMenu *arg1 = (wxMenu *) 0 ;
34812 size_t result;
34813 PyObject * obj0 = 0 ;
34814 char *kwnames[] = {
34815 (char *) "self", NULL
34816 };
34817
34818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34820 if (SWIG_arg_fail(1)) SWIG_fail;
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34824
34825 wxPyEndAllowThreads(__tstate);
34826 if (PyErr_Occurred()) SWIG_fail;
34827 }
34828 {
34829 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34830 }
34831 return resultobj;
34832 fail:
34833 return NULL;
34834 }
34835
34836
34837 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34838 PyObject *resultobj = NULL;
34839 wxMenu *arg1 = (wxMenu *) 0 ;
34840 PyObject *result;
34841 PyObject * obj0 = 0 ;
34842 char *kwnames[] = {
34843 (char *) "self", NULL
34844 };
34845
34846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34848 if (SWIG_arg_fail(1)) SWIG_fail;
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34852
34853 wxPyEndAllowThreads(__tstate);
34854 if (PyErr_Occurred()) SWIG_fail;
34855 }
34856 resultobj = result;
34857 return resultobj;
34858 fail:
34859 return NULL;
34860 }
34861
34862
34863 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34864 PyObject *resultobj = NULL;
34865 wxMenu *arg1 = (wxMenu *) 0 ;
34866 wxString *arg2 = 0 ;
34867 int result;
34868 bool temp2 = false ;
34869 PyObject * obj0 = 0 ;
34870 PyObject * obj1 = 0 ;
34871 char *kwnames[] = {
34872 (char *) "self",(char *) "item", NULL
34873 };
34874
34875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34877 if (SWIG_arg_fail(1)) SWIG_fail;
34878 {
34879 arg2 = wxString_in_helper(obj1);
34880 if (arg2 == NULL) SWIG_fail;
34881 temp2 = true;
34882 }
34883 {
34884 PyThreadState* __tstate = wxPyBeginAllowThreads();
34885 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34886
34887 wxPyEndAllowThreads(__tstate);
34888 if (PyErr_Occurred()) SWIG_fail;
34889 }
34890 {
34891 resultobj = SWIG_From_int(static_cast<int >(result));
34892 }
34893 {
34894 if (temp2)
34895 delete arg2;
34896 }
34897 return resultobj;
34898 fail:
34899 {
34900 if (temp2)
34901 delete arg2;
34902 }
34903 return NULL;
34904 }
34905
34906
34907 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34908 PyObject *resultobj = NULL;
34909 wxMenu *arg1 = (wxMenu *) 0 ;
34910 int arg2 ;
34911 wxMenuItem *result;
34912 PyObject * obj0 = 0 ;
34913 PyObject * obj1 = 0 ;
34914 char *kwnames[] = {
34915 (char *) "self",(char *) "id", NULL
34916 };
34917
34918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",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 {
34922 arg2 = static_cast<int >(SWIG_As_int(obj1));
34923 if (SWIG_arg_fail(2)) SWIG_fail;
34924 }
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34928
34929 wxPyEndAllowThreads(__tstate);
34930 if (PyErr_Occurred()) SWIG_fail;
34931 }
34932 {
34933 resultobj = wxPyMake_wxObject(result, 0);
34934 }
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34942 PyObject *resultobj = NULL;
34943 wxMenu *arg1 = (wxMenu *) 0 ;
34944 size_t arg2 ;
34945 wxMenuItem *result;
34946 PyObject * obj0 = 0 ;
34947 PyObject * obj1 = 0 ;
34948 char *kwnames[] = {
34949 (char *) "self",(char *) "position", NULL
34950 };
34951
34952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34954 if (SWIG_arg_fail(1)) SWIG_fail;
34955 {
34956 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34957 if (SWIG_arg_fail(2)) SWIG_fail;
34958 }
34959 {
34960 PyThreadState* __tstate = wxPyBeginAllowThreads();
34961 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34962
34963 wxPyEndAllowThreads(__tstate);
34964 if (PyErr_Occurred()) SWIG_fail;
34965 }
34966 {
34967 resultobj = wxPyMake_wxObject(result, 0);
34968 }
34969 return resultobj;
34970 fail:
34971 return NULL;
34972 }
34973
34974
34975 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34976 PyObject *resultobj = NULL;
34977 wxMenu *arg1 = (wxMenu *) 0 ;
34978 int arg2 ;
34979 bool arg3 ;
34980 PyObject * obj0 = 0 ;
34981 PyObject * obj1 = 0 ;
34982 PyObject * obj2 = 0 ;
34983 char *kwnames[] = {
34984 (char *) "self",(char *) "id",(char *) "enable", NULL
34985 };
34986
34987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34989 if (SWIG_arg_fail(1)) SWIG_fail;
34990 {
34991 arg2 = static_cast<int >(SWIG_As_int(obj1));
34992 if (SWIG_arg_fail(2)) SWIG_fail;
34993 }
34994 {
34995 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
34996 if (SWIG_arg_fail(3)) SWIG_fail;
34997 }
34998 {
34999 PyThreadState* __tstate = wxPyBeginAllowThreads();
35000 (arg1)->Enable(arg2,arg3);
35001
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 Py_INCREF(Py_None); resultobj = Py_None;
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35013 PyObject *resultobj = NULL;
35014 wxMenu *arg1 = (wxMenu *) 0 ;
35015 int arg2 ;
35016 bool result;
35017 PyObject * obj0 = 0 ;
35018 PyObject * obj1 = 0 ;
35019 char *kwnames[] = {
35020 (char *) "self",(char *) "id", NULL
35021 };
35022
35023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35025 if (SWIG_arg_fail(1)) SWIG_fail;
35026 {
35027 arg2 = static_cast<int >(SWIG_As_int(obj1));
35028 if (SWIG_arg_fail(2)) SWIG_fail;
35029 }
35030 {
35031 PyThreadState* __tstate = wxPyBeginAllowThreads();
35032 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35033
35034 wxPyEndAllowThreads(__tstate);
35035 if (PyErr_Occurred()) SWIG_fail;
35036 }
35037 {
35038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35039 }
35040 return resultobj;
35041 fail:
35042 return NULL;
35043 }
35044
35045
35046 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35047 PyObject *resultobj = NULL;
35048 wxMenu *arg1 = (wxMenu *) 0 ;
35049 int arg2 ;
35050 bool arg3 ;
35051 PyObject * obj0 = 0 ;
35052 PyObject * obj1 = 0 ;
35053 PyObject * obj2 = 0 ;
35054 char *kwnames[] = {
35055 (char *) "self",(char *) "id",(char *) "check", NULL
35056 };
35057
35058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35060 if (SWIG_arg_fail(1)) SWIG_fail;
35061 {
35062 arg2 = static_cast<int >(SWIG_As_int(obj1));
35063 if (SWIG_arg_fail(2)) SWIG_fail;
35064 }
35065 {
35066 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35067 if (SWIG_arg_fail(3)) SWIG_fail;
35068 }
35069 {
35070 PyThreadState* __tstate = wxPyBeginAllowThreads();
35071 (arg1)->Check(arg2,arg3);
35072
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 Py_INCREF(Py_None); resultobj = Py_None;
35077 return resultobj;
35078 fail:
35079 return NULL;
35080 }
35081
35082
35083 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35084 PyObject *resultobj = NULL;
35085 wxMenu *arg1 = (wxMenu *) 0 ;
35086 int arg2 ;
35087 bool result;
35088 PyObject * obj0 = 0 ;
35089 PyObject * obj1 = 0 ;
35090 char *kwnames[] = {
35091 (char *) "self",(char *) "id", NULL
35092 };
35093
35094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35096 if (SWIG_arg_fail(1)) SWIG_fail;
35097 {
35098 arg2 = static_cast<int >(SWIG_As_int(obj1));
35099 if (SWIG_arg_fail(2)) SWIG_fail;
35100 }
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35104
35105 wxPyEndAllowThreads(__tstate);
35106 if (PyErr_Occurred()) SWIG_fail;
35107 }
35108 {
35109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35110 }
35111 return resultobj;
35112 fail:
35113 return NULL;
35114 }
35115
35116
35117 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35118 PyObject *resultobj = NULL;
35119 wxMenu *arg1 = (wxMenu *) 0 ;
35120 int arg2 ;
35121 wxString *arg3 = 0 ;
35122 bool temp3 = false ;
35123 PyObject * obj0 = 0 ;
35124 PyObject * obj1 = 0 ;
35125 PyObject * obj2 = 0 ;
35126 char *kwnames[] = {
35127 (char *) "self",(char *) "id",(char *) "label", NULL
35128 };
35129
35130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35132 if (SWIG_arg_fail(1)) SWIG_fail;
35133 {
35134 arg2 = static_cast<int >(SWIG_As_int(obj1));
35135 if (SWIG_arg_fail(2)) SWIG_fail;
35136 }
35137 {
35138 arg3 = wxString_in_helper(obj2);
35139 if (arg3 == NULL) SWIG_fail;
35140 temp3 = true;
35141 }
35142 {
35143 PyThreadState* __tstate = wxPyBeginAllowThreads();
35144 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35145
35146 wxPyEndAllowThreads(__tstate);
35147 if (PyErr_Occurred()) SWIG_fail;
35148 }
35149 Py_INCREF(Py_None); resultobj = Py_None;
35150 {
35151 if (temp3)
35152 delete arg3;
35153 }
35154 return resultobj;
35155 fail:
35156 {
35157 if (temp3)
35158 delete arg3;
35159 }
35160 return NULL;
35161 }
35162
35163
35164 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35165 PyObject *resultobj = NULL;
35166 wxMenu *arg1 = (wxMenu *) 0 ;
35167 int arg2 ;
35168 wxString result;
35169 PyObject * obj0 = 0 ;
35170 PyObject * obj1 = 0 ;
35171 char *kwnames[] = {
35172 (char *) "self",(char *) "id", NULL
35173 };
35174
35175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35177 if (SWIG_arg_fail(1)) SWIG_fail;
35178 {
35179 arg2 = static_cast<int >(SWIG_As_int(obj1));
35180 if (SWIG_arg_fail(2)) SWIG_fail;
35181 }
35182 {
35183 PyThreadState* __tstate = wxPyBeginAllowThreads();
35184 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35185
35186 wxPyEndAllowThreads(__tstate);
35187 if (PyErr_Occurred()) SWIG_fail;
35188 }
35189 {
35190 #if wxUSE_UNICODE
35191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35192 #else
35193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35194 #endif
35195 }
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35203 PyObject *resultobj = NULL;
35204 wxMenu *arg1 = (wxMenu *) 0 ;
35205 int arg2 ;
35206 wxString *arg3 = 0 ;
35207 bool temp3 = false ;
35208 PyObject * obj0 = 0 ;
35209 PyObject * obj1 = 0 ;
35210 PyObject * obj2 = 0 ;
35211 char *kwnames[] = {
35212 (char *) "self",(char *) "id",(char *) "helpString", NULL
35213 };
35214
35215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35217 if (SWIG_arg_fail(1)) SWIG_fail;
35218 {
35219 arg2 = static_cast<int >(SWIG_As_int(obj1));
35220 if (SWIG_arg_fail(2)) SWIG_fail;
35221 }
35222 {
35223 arg3 = wxString_in_helper(obj2);
35224 if (arg3 == NULL) SWIG_fail;
35225 temp3 = true;
35226 }
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35230
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 Py_INCREF(Py_None); resultobj = Py_None;
35235 {
35236 if (temp3)
35237 delete arg3;
35238 }
35239 return resultobj;
35240 fail:
35241 {
35242 if (temp3)
35243 delete arg3;
35244 }
35245 return NULL;
35246 }
35247
35248
35249 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35250 PyObject *resultobj = NULL;
35251 wxMenu *arg1 = (wxMenu *) 0 ;
35252 int arg2 ;
35253 wxString result;
35254 PyObject * obj0 = 0 ;
35255 PyObject * obj1 = 0 ;
35256 char *kwnames[] = {
35257 (char *) "self",(char *) "id", NULL
35258 };
35259
35260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
35269 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35270
35271 wxPyEndAllowThreads(__tstate);
35272 if (PyErr_Occurred()) SWIG_fail;
35273 }
35274 {
35275 #if wxUSE_UNICODE
35276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35277 #else
35278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35279 #endif
35280 }
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj = NULL;
35289 wxMenu *arg1 = (wxMenu *) 0 ;
35290 wxString *arg2 = 0 ;
35291 bool temp2 = false ;
35292 PyObject * obj0 = 0 ;
35293 PyObject * obj1 = 0 ;
35294 char *kwnames[] = {
35295 (char *) "self",(char *) "title", NULL
35296 };
35297
35298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35300 if (SWIG_arg_fail(1)) SWIG_fail;
35301 {
35302 arg2 = wxString_in_helper(obj1);
35303 if (arg2 == NULL) SWIG_fail;
35304 temp2 = true;
35305 }
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 (arg1)->SetTitle((wxString const &)*arg2);
35309
35310 wxPyEndAllowThreads(__tstate);
35311 if (PyErr_Occurred()) SWIG_fail;
35312 }
35313 Py_INCREF(Py_None); resultobj = Py_None;
35314 {
35315 if (temp2)
35316 delete arg2;
35317 }
35318 return resultobj;
35319 fail:
35320 {
35321 if (temp2)
35322 delete arg2;
35323 }
35324 return NULL;
35325 }
35326
35327
35328 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35329 PyObject *resultobj = NULL;
35330 wxMenu *arg1 = (wxMenu *) 0 ;
35331 wxString result;
35332 PyObject * obj0 = 0 ;
35333 char *kwnames[] = {
35334 (char *) "self", NULL
35335 };
35336
35337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35339 if (SWIG_arg_fail(1)) SWIG_fail;
35340 {
35341 PyThreadState* __tstate = wxPyBeginAllowThreads();
35342 result = ((wxMenu const *)arg1)->GetTitle();
35343
35344 wxPyEndAllowThreads(__tstate);
35345 if (PyErr_Occurred()) SWIG_fail;
35346 }
35347 {
35348 #if wxUSE_UNICODE
35349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35350 #else
35351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35352 #endif
35353 }
35354 return resultobj;
35355 fail:
35356 return NULL;
35357 }
35358
35359
35360 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35361 PyObject *resultobj = NULL;
35362 wxMenu *arg1 = (wxMenu *) 0 ;
35363 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35364 PyObject * obj0 = 0 ;
35365 PyObject * obj1 = 0 ;
35366 char *kwnames[] = {
35367 (char *) "self",(char *) "handler", NULL
35368 };
35369
35370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35372 if (SWIG_arg_fail(1)) SWIG_fail;
35373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35374 if (SWIG_arg_fail(2)) SWIG_fail;
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 (arg1)->SetEventHandler(arg2);
35378
35379 wxPyEndAllowThreads(__tstate);
35380 if (PyErr_Occurred()) SWIG_fail;
35381 }
35382 Py_INCREF(Py_None); resultobj = Py_None;
35383 return resultobj;
35384 fail:
35385 return NULL;
35386 }
35387
35388
35389 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35390 PyObject *resultobj = NULL;
35391 wxMenu *arg1 = (wxMenu *) 0 ;
35392 wxEvtHandler *result;
35393 PyObject * obj0 = 0 ;
35394 char *kwnames[] = {
35395 (char *) "self", NULL
35396 };
35397
35398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35400 if (SWIG_arg_fail(1)) SWIG_fail;
35401 {
35402 PyThreadState* __tstate = wxPyBeginAllowThreads();
35403 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35404
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 {
35409 resultobj = wxPyMake_wxObject(result, 0);
35410 }
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35418 PyObject *resultobj = NULL;
35419 wxMenu *arg1 = (wxMenu *) 0 ;
35420 wxWindow *arg2 = (wxWindow *) 0 ;
35421 PyObject * obj0 = 0 ;
35422 PyObject * obj1 = 0 ;
35423 char *kwnames[] = {
35424 (char *) "self",(char *) "win", NULL
35425 };
35426
35427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35429 if (SWIG_arg_fail(1)) SWIG_fail;
35430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35431 if (SWIG_arg_fail(2)) SWIG_fail;
35432 {
35433 PyThreadState* __tstate = wxPyBeginAllowThreads();
35434 (arg1)->SetInvokingWindow(arg2);
35435
35436 wxPyEndAllowThreads(__tstate);
35437 if (PyErr_Occurred()) SWIG_fail;
35438 }
35439 Py_INCREF(Py_None); resultobj = Py_None;
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35447 PyObject *resultobj = NULL;
35448 wxMenu *arg1 = (wxMenu *) 0 ;
35449 wxWindow *result;
35450 PyObject * obj0 = 0 ;
35451 char *kwnames[] = {
35452 (char *) "self", NULL
35453 };
35454
35455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35457 if (SWIG_arg_fail(1)) SWIG_fail;
35458 {
35459 PyThreadState* __tstate = wxPyBeginAllowThreads();
35460 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35461
35462 wxPyEndAllowThreads(__tstate);
35463 if (PyErr_Occurred()) SWIG_fail;
35464 }
35465 {
35466 resultobj = wxPyMake_wxObject(result, 0);
35467 }
35468 return resultobj;
35469 fail:
35470 return NULL;
35471 }
35472
35473
35474 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35475 PyObject *resultobj = NULL;
35476 wxMenu *arg1 = (wxMenu *) 0 ;
35477 long result;
35478 PyObject * obj0 = 0 ;
35479 char *kwnames[] = {
35480 (char *) "self", NULL
35481 };
35482
35483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35485 if (SWIG_arg_fail(1)) SWIG_fail;
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = (long)((wxMenu const *)arg1)->GetStyle();
35489
35490 wxPyEndAllowThreads(__tstate);
35491 if (PyErr_Occurred()) SWIG_fail;
35492 }
35493 {
35494 resultobj = SWIG_From_long(static_cast<long >(result));
35495 }
35496 return resultobj;
35497 fail:
35498 return NULL;
35499 }
35500
35501
35502 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35503 PyObject *resultobj = NULL;
35504 wxMenu *arg1 = (wxMenu *) 0 ;
35505 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35506 PyObject * obj0 = 0 ;
35507 PyObject * obj1 = 0 ;
35508 char *kwnames[] = {
35509 (char *) "self",(char *) "source", NULL
35510 };
35511
35512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35514 if (SWIG_arg_fail(1)) SWIG_fail;
35515 if (obj1) {
35516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35517 if (SWIG_arg_fail(2)) SWIG_fail;
35518 }
35519 {
35520 PyThreadState* __tstate = wxPyBeginAllowThreads();
35521 (arg1)->UpdateUI(arg2);
35522
35523 wxPyEndAllowThreads(__tstate);
35524 if (PyErr_Occurred()) SWIG_fail;
35525 }
35526 Py_INCREF(Py_None); resultobj = Py_None;
35527 return resultobj;
35528 fail:
35529 return NULL;
35530 }
35531
35532
35533 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35534 PyObject *resultobj = NULL;
35535 wxMenu *arg1 = (wxMenu *) 0 ;
35536 wxMenuBar *result;
35537 PyObject * obj0 = 0 ;
35538 char *kwnames[] = {
35539 (char *) "self", NULL
35540 };
35541
35542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35544 if (SWIG_arg_fail(1)) SWIG_fail;
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35548
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 {
35553 resultobj = wxPyMake_wxObject(result, 0);
35554 }
35555 return resultobj;
35556 fail:
35557 return NULL;
35558 }
35559
35560
35561 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35562 PyObject *resultobj = NULL;
35563 wxMenu *arg1 = (wxMenu *) 0 ;
35564 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35565 PyObject * obj0 = 0 ;
35566 PyObject * obj1 = 0 ;
35567 char *kwnames[] = {
35568 (char *) "self",(char *) "menubar", NULL
35569 };
35570
35571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35573 if (SWIG_arg_fail(1)) SWIG_fail;
35574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35575 if (SWIG_arg_fail(2)) SWIG_fail;
35576 {
35577 PyThreadState* __tstate = wxPyBeginAllowThreads();
35578 (arg1)->Attach(arg2);
35579
35580 wxPyEndAllowThreads(__tstate);
35581 if (PyErr_Occurred()) SWIG_fail;
35582 }
35583 Py_INCREF(Py_None); resultobj = Py_None;
35584 return resultobj;
35585 fail:
35586 return NULL;
35587 }
35588
35589
35590 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35591 PyObject *resultobj = NULL;
35592 wxMenu *arg1 = (wxMenu *) 0 ;
35593 PyObject * obj0 = 0 ;
35594 char *kwnames[] = {
35595 (char *) "self", NULL
35596 };
35597
35598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35600 if (SWIG_arg_fail(1)) SWIG_fail;
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 (arg1)->Detach();
35604
35605 wxPyEndAllowThreads(__tstate);
35606 if (PyErr_Occurred()) SWIG_fail;
35607 }
35608 Py_INCREF(Py_None); resultobj = Py_None;
35609 return resultobj;
35610 fail:
35611 return NULL;
35612 }
35613
35614
35615 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35616 PyObject *resultobj = NULL;
35617 wxMenu *arg1 = (wxMenu *) 0 ;
35618 bool result;
35619 PyObject * obj0 = 0 ;
35620 char *kwnames[] = {
35621 (char *) "self", NULL
35622 };
35623
35624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35626 if (SWIG_arg_fail(1)) SWIG_fail;
35627 {
35628 PyThreadState* __tstate = wxPyBeginAllowThreads();
35629 result = (bool)((wxMenu const *)arg1)->IsAttached();
35630
35631 wxPyEndAllowThreads(__tstate);
35632 if (PyErr_Occurred()) SWIG_fail;
35633 }
35634 {
35635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35636 }
35637 return resultobj;
35638 fail:
35639 return NULL;
35640 }
35641
35642
35643 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35644 PyObject *resultobj = NULL;
35645 wxMenu *arg1 = (wxMenu *) 0 ;
35646 wxMenu *arg2 = (wxMenu *) 0 ;
35647 PyObject * obj0 = 0 ;
35648 PyObject * obj1 = 0 ;
35649 char *kwnames[] = {
35650 (char *) "self",(char *) "parent", NULL
35651 };
35652
35653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35655 if (SWIG_arg_fail(1)) SWIG_fail;
35656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35657 if (SWIG_arg_fail(2)) SWIG_fail;
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 (arg1)->SetParent(arg2);
35661
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 Py_INCREF(Py_None); resultobj = Py_None;
35666 return resultobj;
35667 fail:
35668 return NULL;
35669 }
35670
35671
35672 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35673 PyObject *resultobj = NULL;
35674 wxMenu *arg1 = (wxMenu *) 0 ;
35675 wxMenu *result;
35676 PyObject * obj0 = 0 ;
35677 char *kwnames[] = {
35678 (char *) "self", NULL
35679 };
35680
35681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35683 if (SWIG_arg_fail(1)) SWIG_fail;
35684 {
35685 PyThreadState* __tstate = wxPyBeginAllowThreads();
35686 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35687
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 {
35692 resultobj = wxPyMake_wxObject(result, 0);
35693 }
35694 return resultobj;
35695 fail:
35696 return NULL;
35697 }
35698
35699
35700 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35701 PyObject *obj;
35702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35703 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35704 Py_INCREF(obj);
35705 return Py_BuildValue((char *)"");
35706 }
35707 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35708 PyObject *resultobj = NULL;
35709 long arg1 = (long) 0 ;
35710 wxMenuBar *result;
35711 PyObject * obj0 = 0 ;
35712 char *kwnames[] = {
35713 (char *) "style", NULL
35714 };
35715
35716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35717 if (obj0) {
35718 {
35719 arg1 = static_cast<long >(SWIG_As_long(obj0));
35720 if (SWIG_arg_fail(1)) SWIG_fail;
35721 }
35722 }
35723 {
35724 if (!wxPyCheckForApp()) SWIG_fail;
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 result = (wxMenuBar *)new wxMenuBar(arg1);
35727
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35732 return resultobj;
35733 fail:
35734 return NULL;
35735 }
35736
35737
35738 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35739 PyObject *resultobj = NULL;
35740 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35741 wxMenu *arg2 = (wxMenu *) 0 ;
35742 wxString *arg3 = 0 ;
35743 bool result;
35744 bool temp3 = false ;
35745 PyObject * obj0 = 0 ;
35746 PyObject * obj1 = 0 ;
35747 PyObject * obj2 = 0 ;
35748 char *kwnames[] = {
35749 (char *) "self",(char *) "menu",(char *) "title", NULL
35750 };
35751
35752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35754 if (SWIG_arg_fail(1)) SWIG_fail;
35755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35756 if (SWIG_arg_fail(2)) SWIG_fail;
35757 {
35758 arg3 = wxString_in_helper(obj2);
35759 if (arg3 == NULL) SWIG_fail;
35760 temp3 = true;
35761 }
35762 {
35763 PyThreadState* __tstate = wxPyBeginAllowThreads();
35764 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35765
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 {
35770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35771 }
35772 {
35773 if (temp3)
35774 delete arg3;
35775 }
35776 return resultobj;
35777 fail:
35778 {
35779 if (temp3)
35780 delete arg3;
35781 }
35782 return NULL;
35783 }
35784
35785
35786 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35787 PyObject *resultobj = NULL;
35788 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35789 size_t arg2 ;
35790 wxMenu *arg3 = (wxMenu *) 0 ;
35791 wxString *arg4 = 0 ;
35792 bool result;
35793 bool temp4 = false ;
35794 PyObject * obj0 = 0 ;
35795 PyObject * obj1 = 0 ;
35796 PyObject * obj2 = 0 ;
35797 PyObject * obj3 = 0 ;
35798 char *kwnames[] = {
35799 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35800 };
35801
35802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35804 if (SWIG_arg_fail(1)) SWIG_fail;
35805 {
35806 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35807 if (SWIG_arg_fail(2)) SWIG_fail;
35808 }
35809 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35810 if (SWIG_arg_fail(3)) SWIG_fail;
35811 {
35812 arg4 = wxString_in_helper(obj3);
35813 if (arg4 == NULL) SWIG_fail;
35814 temp4 = true;
35815 }
35816 {
35817 PyThreadState* __tstate = wxPyBeginAllowThreads();
35818 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35819
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 {
35824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35825 }
35826 {
35827 if (temp4)
35828 delete arg4;
35829 }
35830 return resultobj;
35831 fail:
35832 {
35833 if (temp4)
35834 delete arg4;
35835 }
35836 return NULL;
35837 }
35838
35839
35840 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35841 PyObject *resultobj = NULL;
35842 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35843 size_t result;
35844 PyObject * obj0 = 0 ;
35845 char *kwnames[] = {
35846 (char *) "self", NULL
35847 };
35848
35849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35851 if (SWIG_arg_fail(1)) SWIG_fail;
35852 {
35853 PyThreadState* __tstate = wxPyBeginAllowThreads();
35854 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35855
35856 wxPyEndAllowThreads(__tstate);
35857 if (PyErr_Occurred()) SWIG_fail;
35858 }
35859 {
35860 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35861 }
35862 return resultobj;
35863 fail:
35864 return NULL;
35865 }
35866
35867
35868 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35869 PyObject *resultobj = NULL;
35870 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35871 size_t arg2 ;
35872 wxMenu *result;
35873 PyObject * obj0 = 0 ;
35874 PyObject * obj1 = 0 ;
35875 char *kwnames[] = {
35876 (char *) "self",(char *) "pos", NULL
35877 };
35878
35879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35881 if (SWIG_arg_fail(1)) SWIG_fail;
35882 {
35883 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35884 if (SWIG_arg_fail(2)) SWIG_fail;
35885 }
35886 {
35887 PyThreadState* __tstate = wxPyBeginAllowThreads();
35888 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35889
35890 wxPyEndAllowThreads(__tstate);
35891 if (PyErr_Occurred()) SWIG_fail;
35892 }
35893 {
35894 resultobj = wxPyMake_wxObject(result, 0);
35895 }
35896 return resultobj;
35897 fail:
35898 return NULL;
35899 }
35900
35901
35902 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35903 PyObject *resultobj = NULL;
35904 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35905 size_t arg2 ;
35906 wxMenu *arg3 = (wxMenu *) 0 ;
35907 wxString *arg4 = 0 ;
35908 wxMenu *result;
35909 bool temp4 = false ;
35910 PyObject * obj0 = 0 ;
35911 PyObject * obj1 = 0 ;
35912 PyObject * obj2 = 0 ;
35913 PyObject * obj3 = 0 ;
35914 char *kwnames[] = {
35915 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35916 };
35917
35918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35920 if (SWIG_arg_fail(1)) SWIG_fail;
35921 {
35922 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35923 if (SWIG_arg_fail(2)) SWIG_fail;
35924 }
35925 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35926 if (SWIG_arg_fail(3)) SWIG_fail;
35927 {
35928 arg4 = wxString_in_helper(obj3);
35929 if (arg4 == NULL) SWIG_fail;
35930 temp4 = true;
35931 }
35932 {
35933 PyThreadState* __tstate = wxPyBeginAllowThreads();
35934 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35935
35936 wxPyEndAllowThreads(__tstate);
35937 if (PyErr_Occurred()) SWIG_fail;
35938 }
35939 {
35940 resultobj = wxPyMake_wxObject(result, 0);
35941 }
35942 {
35943 if (temp4)
35944 delete arg4;
35945 }
35946 return resultobj;
35947 fail:
35948 {
35949 if (temp4)
35950 delete arg4;
35951 }
35952 return NULL;
35953 }
35954
35955
35956 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35957 PyObject *resultobj = NULL;
35958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35959 size_t arg2 ;
35960 wxMenu *result;
35961 PyObject * obj0 = 0 ;
35962 PyObject * obj1 = 0 ;
35963 char *kwnames[] = {
35964 (char *) "self",(char *) "pos", NULL
35965 };
35966
35967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35969 if (SWIG_arg_fail(1)) SWIG_fail;
35970 {
35971 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35972 if (SWIG_arg_fail(2)) SWIG_fail;
35973 }
35974 {
35975 PyThreadState* __tstate = wxPyBeginAllowThreads();
35976 result = (wxMenu *)(arg1)->Remove(arg2);
35977
35978 wxPyEndAllowThreads(__tstate);
35979 if (PyErr_Occurred()) SWIG_fail;
35980 }
35981 {
35982 resultobj = wxPyMake_wxObject(result, 0);
35983 }
35984 return resultobj;
35985 fail:
35986 return NULL;
35987 }
35988
35989
35990 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35991 PyObject *resultobj = NULL;
35992 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35993 size_t arg2 ;
35994 bool arg3 ;
35995 PyObject * obj0 = 0 ;
35996 PyObject * obj1 = 0 ;
35997 PyObject * obj2 = 0 ;
35998 char *kwnames[] = {
35999 (char *) "self",(char *) "pos",(char *) "enable", NULL
36000 };
36001
36002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36004 if (SWIG_arg_fail(1)) SWIG_fail;
36005 {
36006 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36007 if (SWIG_arg_fail(2)) SWIG_fail;
36008 }
36009 {
36010 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36011 if (SWIG_arg_fail(3)) SWIG_fail;
36012 }
36013 {
36014 PyThreadState* __tstate = wxPyBeginAllowThreads();
36015 (arg1)->EnableTop(arg2,arg3);
36016
36017 wxPyEndAllowThreads(__tstate);
36018 if (PyErr_Occurred()) SWIG_fail;
36019 }
36020 Py_INCREF(Py_None); resultobj = Py_None;
36021 return resultobj;
36022 fail:
36023 return NULL;
36024 }
36025
36026
36027 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36028 PyObject *resultobj = NULL;
36029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36030 size_t arg2 ;
36031 bool result;
36032 PyObject * obj0 = 0 ;
36033 PyObject * obj1 = 0 ;
36034 char *kwnames[] = {
36035 (char *) "self",(char *) "pos", NULL
36036 };
36037
36038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36040 if (SWIG_arg_fail(1)) SWIG_fail;
36041 {
36042 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36043 if (SWIG_arg_fail(2)) SWIG_fail;
36044 }
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36048
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj = NULL;
36063 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36064 size_t arg2 ;
36065 wxString *arg3 = 0 ;
36066 bool temp3 = false ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 PyObject * obj2 = 0 ;
36070 char *kwnames[] = {
36071 (char *) "self",(char *) "pos",(char *) "label", NULL
36072 };
36073
36074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36076 if (SWIG_arg_fail(1)) SWIG_fail;
36077 {
36078 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36079 if (SWIG_arg_fail(2)) SWIG_fail;
36080 }
36081 {
36082 arg3 = wxString_in_helper(obj2);
36083 if (arg3 == NULL) SWIG_fail;
36084 temp3 = true;
36085 }
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36089
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 Py_INCREF(Py_None); resultobj = Py_None;
36094 {
36095 if (temp3)
36096 delete arg3;
36097 }
36098 return resultobj;
36099 fail:
36100 {
36101 if (temp3)
36102 delete arg3;
36103 }
36104 return NULL;
36105 }
36106
36107
36108 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36109 PyObject *resultobj = NULL;
36110 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36111 size_t arg2 ;
36112 wxString result;
36113 PyObject * obj0 = 0 ;
36114 PyObject * obj1 = 0 ;
36115 char *kwnames[] = {
36116 (char *) "self",(char *) "pos", NULL
36117 };
36118
36119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36121 if (SWIG_arg_fail(1)) SWIG_fail;
36122 {
36123 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36124 if (SWIG_arg_fail(2)) SWIG_fail;
36125 }
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36129
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 {
36134 #if wxUSE_UNICODE
36135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36136 #else
36137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36138 #endif
36139 }
36140 return resultobj;
36141 fail:
36142 return NULL;
36143 }
36144
36145
36146 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36147 PyObject *resultobj = NULL;
36148 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36149 wxString *arg2 = 0 ;
36150 wxString *arg3 = 0 ;
36151 int result;
36152 bool temp2 = false ;
36153 bool temp3 = false ;
36154 PyObject * obj0 = 0 ;
36155 PyObject * obj1 = 0 ;
36156 PyObject * obj2 = 0 ;
36157 char *kwnames[] = {
36158 (char *) "self",(char *) "menu",(char *) "item", NULL
36159 };
36160
36161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36163 if (SWIG_arg_fail(1)) SWIG_fail;
36164 {
36165 arg2 = wxString_in_helper(obj1);
36166 if (arg2 == NULL) SWIG_fail;
36167 temp2 = true;
36168 }
36169 {
36170 arg3 = wxString_in_helper(obj2);
36171 if (arg3 == NULL) SWIG_fail;
36172 temp3 = true;
36173 }
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36177
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 {
36182 resultobj = SWIG_From_int(static_cast<int >(result));
36183 }
36184 {
36185 if (temp2)
36186 delete arg2;
36187 }
36188 {
36189 if (temp3)
36190 delete arg3;
36191 }
36192 return resultobj;
36193 fail:
36194 {
36195 if (temp2)
36196 delete arg2;
36197 }
36198 {
36199 if (temp3)
36200 delete arg3;
36201 }
36202 return NULL;
36203 }
36204
36205
36206 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36207 PyObject *resultobj = NULL;
36208 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36209 int arg2 ;
36210 wxMenuItem *result;
36211 PyObject * obj0 = 0 ;
36212 PyObject * obj1 = 0 ;
36213 char *kwnames[] = {
36214 (char *) "self",(char *) "id", NULL
36215 };
36216
36217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36219 if (SWIG_arg_fail(1)) SWIG_fail;
36220 {
36221 arg2 = static_cast<int >(SWIG_As_int(obj1));
36222 if (SWIG_arg_fail(2)) SWIG_fail;
36223 }
36224 {
36225 PyThreadState* __tstate = wxPyBeginAllowThreads();
36226 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36227
36228 wxPyEndAllowThreads(__tstate);
36229 if (PyErr_Occurred()) SWIG_fail;
36230 }
36231 {
36232 resultobj = wxPyMake_wxObject(result, 0);
36233 }
36234 return resultobj;
36235 fail:
36236 return NULL;
36237 }
36238
36239
36240 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36241 PyObject *resultobj = NULL;
36242 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36243 wxString *arg2 = 0 ;
36244 int result;
36245 bool temp2 = false ;
36246 PyObject * obj0 = 0 ;
36247 PyObject * obj1 = 0 ;
36248 char *kwnames[] = {
36249 (char *) "self",(char *) "title", NULL
36250 };
36251
36252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36254 if (SWIG_arg_fail(1)) SWIG_fail;
36255 {
36256 arg2 = wxString_in_helper(obj1);
36257 if (arg2 == NULL) SWIG_fail;
36258 temp2 = true;
36259 }
36260 {
36261 PyThreadState* __tstate = wxPyBeginAllowThreads();
36262 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36263
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 {
36268 resultobj = SWIG_From_int(static_cast<int >(result));
36269 }
36270 {
36271 if (temp2)
36272 delete arg2;
36273 }
36274 return resultobj;
36275 fail:
36276 {
36277 if (temp2)
36278 delete arg2;
36279 }
36280 return NULL;
36281 }
36282
36283
36284 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36285 PyObject *resultobj = NULL;
36286 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36287 int arg2 ;
36288 bool arg3 ;
36289 PyObject * obj0 = 0 ;
36290 PyObject * obj1 = 0 ;
36291 PyObject * obj2 = 0 ;
36292 char *kwnames[] = {
36293 (char *) "self",(char *) "id",(char *) "enable", NULL
36294 };
36295
36296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36298 if (SWIG_arg_fail(1)) SWIG_fail;
36299 {
36300 arg2 = static_cast<int >(SWIG_As_int(obj1));
36301 if (SWIG_arg_fail(2)) SWIG_fail;
36302 }
36303 {
36304 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36305 if (SWIG_arg_fail(3)) SWIG_fail;
36306 }
36307 {
36308 PyThreadState* __tstate = wxPyBeginAllowThreads();
36309 (arg1)->Enable(arg2,arg3);
36310
36311 wxPyEndAllowThreads(__tstate);
36312 if (PyErr_Occurred()) SWIG_fail;
36313 }
36314 Py_INCREF(Py_None); resultobj = Py_None;
36315 return resultobj;
36316 fail:
36317 return NULL;
36318 }
36319
36320
36321 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36322 PyObject *resultobj = NULL;
36323 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36324 int arg2 ;
36325 bool arg3 ;
36326 PyObject * obj0 = 0 ;
36327 PyObject * obj1 = 0 ;
36328 PyObject * obj2 = 0 ;
36329 char *kwnames[] = {
36330 (char *) "self",(char *) "id",(char *) "check", NULL
36331 };
36332
36333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36335 if (SWIG_arg_fail(1)) SWIG_fail;
36336 {
36337 arg2 = static_cast<int >(SWIG_As_int(obj1));
36338 if (SWIG_arg_fail(2)) SWIG_fail;
36339 }
36340 {
36341 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36342 if (SWIG_arg_fail(3)) SWIG_fail;
36343 }
36344 {
36345 PyThreadState* __tstate = wxPyBeginAllowThreads();
36346 (arg1)->Check(arg2,arg3);
36347
36348 wxPyEndAllowThreads(__tstate);
36349 if (PyErr_Occurred()) SWIG_fail;
36350 }
36351 Py_INCREF(Py_None); resultobj = Py_None;
36352 return resultobj;
36353 fail:
36354 return NULL;
36355 }
36356
36357
36358 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36359 PyObject *resultobj = NULL;
36360 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36361 int arg2 ;
36362 bool result;
36363 PyObject * obj0 = 0 ;
36364 PyObject * obj1 = 0 ;
36365 char *kwnames[] = {
36366 (char *) "self",(char *) "id", NULL
36367 };
36368
36369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36371 if (SWIG_arg_fail(1)) SWIG_fail;
36372 {
36373 arg2 = static_cast<int >(SWIG_As_int(obj1));
36374 if (SWIG_arg_fail(2)) SWIG_fail;
36375 }
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36379
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 {
36384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36385 }
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36393 PyObject *resultobj = NULL;
36394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36395 int arg2 ;
36396 bool result;
36397 PyObject * obj0 = 0 ;
36398 PyObject * obj1 = 0 ;
36399 char *kwnames[] = {
36400 (char *) "self",(char *) "id", NULL
36401 };
36402
36403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36405 if (SWIG_arg_fail(1)) SWIG_fail;
36406 {
36407 arg2 = static_cast<int >(SWIG_As_int(obj1));
36408 if (SWIG_arg_fail(2)) SWIG_fail;
36409 }
36410 {
36411 PyThreadState* __tstate = wxPyBeginAllowThreads();
36412 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36413
36414 wxPyEndAllowThreads(__tstate);
36415 if (PyErr_Occurred()) SWIG_fail;
36416 }
36417 {
36418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36419 }
36420 return resultobj;
36421 fail:
36422 return NULL;
36423 }
36424
36425
36426 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36427 PyObject *resultobj = NULL;
36428 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36429 int arg2 ;
36430 wxString *arg3 = 0 ;
36431 bool temp3 = false ;
36432 PyObject * obj0 = 0 ;
36433 PyObject * obj1 = 0 ;
36434 PyObject * obj2 = 0 ;
36435 char *kwnames[] = {
36436 (char *) "self",(char *) "id",(char *) "label", NULL
36437 };
36438
36439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36441 if (SWIG_arg_fail(1)) SWIG_fail;
36442 {
36443 arg2 = static_cast<int >(SWIG_As_int(obj1));
36444 if (SWIG_arg_fail(2)) SWIG_fail;
36445 }
36446 {
36447 arg3 = wxString_in_helper(obj2);
36448 if (arg3 == NULL) SWIG_fail;
36449 temp3 = true;
36450 }
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36454
36455 wxPyEndAllowThreads(__tstate);
36456 if (PyErr_Occurred()) SWIG_fail;
36457 }
36458 Py_INCREF(Py_None); resultobj = Py_None;
36459 {
36460 if (temp3)
36461 delete arg3;
36462 }
36463 return resultobj;
36464 fail:
36465 {
36466 if (temp3)
36467 delete arg3;
36468 }
36469 return NULL;
36470 }
36471
36472
36473 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36474 PyObject *resultobj = NULL;
36475 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36476 int arg2 ;
36477 wxString result;
36478 PyObject * obj0 = 0 ;
36479 PyObject * obj1 = 0 ;
36480 char *kwnames[] = {
36481 (char *) "self",(char *) "id", NULL
36482 };
36483
36484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36486 if (SWIG_arg_fail(1)) SWIG_fail;
36487 {
36488 arg2 = static_cast<int >(SWIG_As_int(obj1));
36489 if (SWIG_arg_fail(2)) SWIG_fail;
36490 }
36491 {
36492 PyThreadState* __tstate = wxPyBeginAllowThreads();
36493 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36494
36495 wxPyEndAllowThreads(__tstate);
36496 if (PyErr_Occurred()) SWIG_fail;
36497 }
36498 {
36499 #if wxUSE_UNICODE
36500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36501 #else
36502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36503 #endif
36504 }
36505 return resultobj;
36506 fail:
36507 return NULL;
36508 }
36509
36510
36511 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36512 PyObject *resultobj = NULL;
36513 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36514 int arg2 ;
36515 wxString *arg3 = 0 ;
36516 bool temp3 = false ;
36517 PyObject * obj0 = 0 ;
36518 PyObject * obj1 = 0 ;
36519 PyObject * obj2 = 0 ;
36520 char *kwnames[] = {
36521 (char *) "self",(char *) "id",(char *) "helpString", NULL
36522 };
36523
36524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36526 if (SWIG_arg_fail(1)) SWIG_fail;
36527 {
36528 arg2 = static_cast<int >(SWIG_As_int(obj1));
36529 if (SWIG_arg_fail(2)) SWIG_fail;
36530 }
36531 {
36532 arg3 = wxString_in_helper(obj2);
36533 if (arg3 == NULL) SWIG_fail;
36534 temp3 = true;
36535 }
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36539
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 Py_INCREF(Py_None); resultobj = Py_None;
36544 {
36545 if (temp3)
36546 delete arg3;
36547 }
36548 return resultobj;
36549 fail:
36550 {
36551 if (temp3)
36552 delete arg3;
36553 }
36554 return NULL;
36555 }
36556
36557
36558 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36559 PyObject *resultobj = NULL;
36560 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36561 int arg2 ;
36562 wxString result;
36563 PyObject * obj0 = 0 ;
36564 PyObject * obj1 = 0 ;
36565 char *kwnames[] = {
36566 (char *) "self",(char *) "id", NULL
36567 };
36568
36569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
36578 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36579
36580 wxPyEndAllowThreads(__tstate);
36581 if (PyErr_Occurred()) SWIG_fail;
36582 }
36583 {
36584 #if wxUSE_UNICODE
36585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36586 #else
36587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36588 #endif
36589 }
36590 return resultobj;
36591 fail:
36592 return NULL;
36593 }
36594
36595
36596 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36597 PyObject *resultobj = NULL;
36598 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36599 wxFrame *result;
36600 PyObject * obj0 = 0 ;
36601 char *kwnames[] = {
36602 (char *) "self", NULL
36603 };
36604
36605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36607 if (SWIG_arg_fail(1)) SWIG_fail;
36608 {
36609 PyThreadState* __tstate = wxPyBeginAllowThreads();
36610 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36611
36612 wxPyEndAllowThreads(__tstate);
36613 if (PyErr_Occurred()) SWIG_fail;
36614 }
36615 {
36616 resultobj = wxPyMake_wxObject(result, 0);
36617 }
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36625 PyObject *resultobj = NULL;
36626 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36627 bool result;
36628 PyObject * obj0 = 0 ;
36629 char *kwnames[] = {
36630 (char *) "self", NULL
36631 };
36632
36633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36635 if (SWIG_arg_fail(1)) SWIG_fail;
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36639
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 {
36644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36645 }
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj = NULL;
36654 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36655 wxFrame *arg2 = (wxFrame *) 0 ;
36656 PyObject * obj0 = 0 ;
36657 PyObject * obj1 = 0 ;
36658 char *kwnames[] = {
36659 (char *) "self",(char *) "frame", NULL
36660 };
36661
36662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36664 if (SWIG_arg_fail(1)) SWIG_fail;
36665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36666 if (SWIG_arg_fail(2)) SWIG_fail;
36667 {
36668 PyThreadState* __tstate = wxPyBeginAllowThreads();
36669 (arg1)->Attach(arg2);
36670
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 Py_INCREF(Py_None); resultobj = Py_None;
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36682 PyObject *resultobj = NULL;
36683 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36684 PyObject * obj0 = 0 ;
36685 char *kwnames[] = {
36686 (char *) "self", NULL
36687 };
36688
36689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36691 if (SWIG_arg_fail(1)) SWIG_fail;
36692 {
36693 PyThreadState* __tstate = wxPyBeginAllowThreads();
36694 (arg1)->Detach();
36695
36696 wxPyEndAllowThreads(__tstate);
36697 if (PyErr_Occurred()) SWIG_fail;
36698 }
36699 Py_INCREF(Py_None); resultobj = Py_None;
36700 return resultobj;
36701 fail:
36702 return NULL;
36703 }
36704
36705
36706 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36707 PyObject *resultobj = NULL;
36708 bool arg1 ;
36709 PyObject * obj0 = 0 ;
36710 char *kwnames[] = {
36711 (char *) "enable", NULL
36712 };
36713
36714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36715 {
36716 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36717 if (SWIG_arg_fail(1)) SWIG_fail;
36718 }
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 wxMenuBar_SetAutoWindowMenu(arg1);
36722
36723 wxPyEndAllowThreads(__tstate);
36724 if (PyErr_Occurred()) SWIG_fail;
36725 }
36726 Py_INCREF(Py_None); resultobj = Py_None;
36727 return resultobj;
36728 fail:
36729 return NULL;
36730 }
36731
36732
36733 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36734 PyObject *resultobj = NULL;
36735 bool result;
36736 char *kwnames[] = {
36737 NULL
36738 };
36739
36740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36741 {
36742 PyThreadState* __tstate = wxPyBeginAllowThreads();
36743 result = (bool)wxMenuBar_GetAutoWindowMenu();
36744
36745 wxPyEndAllowThreads(__tstate);
36746 if (PyErr_Occurred()) SWIG_fail;
36747 }
36748 {
36749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36750 }
36751 return resultobj;
36752 fail:
36753 return NULL;
36754 }
36755
36756
36757 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36758 PyObject *obj;
36759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36760 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36761 Py_INCREF(obj);
36762 return Py_BuildValue((char *)"");
36763 }
36764 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36765 PyObject *resultobj = NULL;
36766 wxMenu *arg1 = (wxMenu *) NULL ;
36767 int arg2 = (int) wxID_ANY ;
36768 wxString const &arg3_defvalue = wxPyEmptyString ;
36769 wxString *arg3 = (wxString *) &arg3_defvalue ;
36770 wxString const &arg4_defvalue = wxPyEmptyString ;
36771 wxString *arg4 = (wxString *) &arg4_defvalue ;
36772 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36773 wxMenu *arg6 = (wxMenu *) NULL ;
36774 wxMenuItem *result;
36775 bool temp3 = false ;
36776 bool temp4 = false ;
36777 PyObject * obj0 = 0 ;
36778 PyObject * obj1 = 0 ;
36779 PyObject * obj2 = 0 ;
36780 PyObject * obj3 = 0 ;
36781 PyObject * obj4 = 0 ;
36782 PyObject * obj5 = 0 ;
36783 char *kwnames[] = {
36784 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36785 };
36786
36787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36788 if (obj0) {
36789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36790 if (SWIG_arg_fail(1)) SWIG_fail;
36791 }
36792 if (obj1) {
36793 {
36794 arg2 = static_cast<int >(SWIG_As_int(obj1));
36795 if (SWIG_arg_fail(2)) SWIG_fail;
36796 }
36797 }
36798 if (obj2) {
36799 {
36800 arg3 = wxString_in_helper(obj2);
36801 if (arg3 == NULL) SWIG_fail;
36802 temp3 = true;
36803 }
36804 }
36805 if (obj3) {
36806 {
36807 arg4 = wxString_in_helper(obj3);
36808 if (arg4 == NULL) SWIG_fail;
36809 temp4 = true;
36810 }
36811 }
36812 if (obj4) {
36813 {
36814 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36815 if (SWIG_arg_fail(5)) SWIG_fail;
36816 }
36817 }
36818 if (obj5) {
36819 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36820 if (SWIG_arg_fail(6)) SWIG_fail;
36821 }
36822 {
36823 PyThreadState* __tstate = wxPyBeginAllowThreads();
36824 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36825
36826 wxPyEndAllowThreads(__tstate);
36827 if (PyErr_Occurred()) SWIG_fail;
36828 }
36829 {
36830 resultobj = wxPyMake_wxObject(result, 1);
36831 }
36832 {
36833 if (temp3)
36834 delete arg3;
36835 }
36836 {
36837 if (temp4)
36838 delete arg4;
36839 }
36840 return resultobj;
36841 fail:
36842 {
36843 if (temp3)
36844 delete arg3;
36845 }
36846 {
36847 if (temp4)
36848 delete arg4;
36849 }
36850 return NULL;
36851 }
36852
36853
36854 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36855 PyObject *resultobj = NULL;
36856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36857 wxMenu *result;
36858 PyObject * obj0 = 0 ;
36859 char *kwnames[] = {
36860 (char *) "self", NULL
36861 };
36862
36863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36865 if (SWIG_arg_fail(1)) SWIG_fail;
36866 {
36867 PyThreadState* __tstate = wxPyBeginAllowThreads();
36868 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36869
36870 wxPyEndAllowThreads(__tstate);
36871 if (PyErr_Occurred()) SWIG_fail;
36872 }
36873 {
36874 resultobj = wxPyMake_wxObject(result, 0);
36875 }
36876 return resultobj;
36877 fail:
36878 return NULL;
36879 }
36880
36881
36882 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36883 PyObject *resultobj = NULL;
36884 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36885 wxMenu *arg2 = (wxMenu *) 0 ;
36886 PyObject * obj0 = 0 ;
36887 PyObject * obj1 = 0 ;
36888 char *kwnames[] = {
36889 (char *) "self",(char *) "menu", NULL
36890 };
36891
36892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36894 if (SWIG_arg_fail(1)) SWIG_fail;
36895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36896 if (SWIG_arg_fail(2)) SWIG_fail;
36897 {
36898 PyThreadState* __tstate = wxPyBeginAllowThreads();
36899 (arg1)->SetMenu(arg2);
36900
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 Py_INCREF(Py_None); resultobj = Py_None;
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36912 PyObject *resultobj = NULL;
36913 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36914 int arg2 ;
36915 PyObject * obj0 = 0 ;
36916 PyObject * obj1 = 0 ;
36917 char *kwnames[] = {
36918 (char *) "self",(char *) "id", NULL
36919 };
36920
36921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36923 if (SWIG_arg_fail(1)) SWIG_fail;
36924 {
36925 arg2 = static_cast<int >(SWIG_As_int(obj1));
36926 if (SWIG_arg_fail(2)) SWIG_fail;
36927 }
36928 {
36929 PyThreadState* __tstate = wxPyBeginAllowThreads();
36930 (arg1)->SetId(arg2);
36931
36932 wxPyEndAllowThreads(__tstate);
36933 if (PyErr_Occurred()) SWIG_fail;
36934 }
36935 Py_INCREF(Py_None); resultobj = Py_None;
36936 return resultobj;
36937 fail:
36938 return NULL;
36939 }
36940
36941
36942 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36943 PyObject *resultobj = NULL;
36944 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36945 int result;
36946 PyObject * obj0 = 0 ;
36947 char *kwnames[] = {
36948 (char *) "self", NULL
36949 };
36950
36951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36953 if (SWIG_arg_fail(1)) SWIG_fail;
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = (int)((wxMenuItem const *)arg1)->GetId();
36957
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 {
36962 resultobj = SWIG_From_int(static_cast<int >(result));
36963 }
36964 return resultobj;
36965 fail:
36966 return NULL;
36967 }
36968
36969
36970 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36971 PyObject *resultobj = NULL;
36972 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36973 bool result;
36974 PyObject * obj0 = 0 ;
36975 char *kwnames[] = {
36976 (char *) "self", NULL
36977 };
36978
36979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36981 if (SWIG_arg_fail(1)) SWIG_fail;
36982 {
36983 PyThreadState* __tstate = wxPyBeginAllowThreads();
36984 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36985
36986 wxPyEndAllowThreads(__tstate);
36987 if (PyErr_Occurred()) SWIG_fail;
36988 }
36989 {
36990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36991 }
36992 return resultobj;
36993 fail:
36994 return NULL;
36995 }
36996
36997
36998 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36999 PyObject *resultobj = NULL;
37000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37001 wxString *arg2 = 0 ;
37002 bool temp2 = false ;
37003 PyObject * obj0 = 0 ;
37004 PyObject * obj1 = 0 ;
37005 char *kwnames[] = {
37006 (char *) "self",(char *) "str", NULL
37007 };
37008
37009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37011 if (SWIG_arg_fail(1)) SWIG_fail;
37012 {
37013 arg2 = wxString_in_helper(obj1);
37014 if (arg2 == NULL) SWIG_fail;
37015 temp2 = true;
37016 }
37017 {
37018 PyThreadState* __tstate = wxPyBeginAllowThreads();
37019 (arg1)->SetText((wxString const &)*arg2);
37020
37021 wxPyEndAllowThreads(__tstate);
37022 if (PyErr_Occurred()) SWIG_fail;
37023 }
37024 Py_INCREF(Py_None); resultobj = Py_None;
37025 {
37026 if (temp2)
37027 delete arg2;
37028 }
37029 return resultobj;
37030 fail:
37031 {
37032 if (temp2)
37033 delete arg2;
37034 }
37035 return NULL;
37036 }
37037
37038
37039 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37040 PyObject *resultobj = NULL;
37041 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37042 wxString result;
37043 PyObject * obj0 = 0 ;
37044 char *kwnames[] = {
37045 (char *) "self", NULL
37046 };
37047
37048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37050 if (SWIG_arg_fail(1)) SWIG_fail;
37051 {
37052 PyThreadState* __tstate = wxPyBeginAllowThreads();
37053 result = ((wxMenuItem const *)arg1)->GetLabel();
37054
37055 wxPyEndAllowThreads(__tstate);
37056 if (PyErr_Occurred()) SWIG_fail;
37057 }
37058 {
37059 #if wxUSE_UNICODE
37060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37061 #else
37062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37063 #endif
37064 }
37065 return resultobj;
37066 fail:
37067 return NULL;
37068 }
37069
37070
37071 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37072 PyObject *resultobj = NULL;
37073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37074 wxString *result;
37075 PyObject * obj0 = 0 ;
37076 char *kwnames[] = {
37077 (char *) "self", NULL
37078 };
37079
37080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37082 if (SWIG_arg_fail(1)) SWIG_fail;
37083 {
37084 PyThreadState* __tstate = wxPyBeginAllowThreads();
37085 {
37086 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37087 result = (wxString *) &_result_ref;
37088 }
37089
37090 wxPyEndAllowThreads(__tstate);
37091 if (PyErr_Occurred()) SWIG_fail;
37092 }
37093 {
37094 #if wxUSE_UNICODE
37095 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37096 #else
37097 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37098 #endif
37099 }
37100 return resultobj;
37101 fail:
37102 return NULL;
37103 }
37104
37105
37106 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37107 PyObject *resultobj = NULL;
37108 wxString *arg1 = 0 ;
37109 wxString result;
37110 bool temp1 = false ;
37111 PyObject * obj0 = 0 ;
37112 char *kwnames[] = {
37113 (char *) "text", NULL
37114 };
37115
37116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37117 {
37118 arg1 = wxString_in_helper(obj0);
37119 if (arg1 == NULL) SWIG_fail;
37120 temp1 = true;
37121 }
37122 {
37123 PyThreadState* __tstate = wxPyBeginAllowThreads();
37124 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37125
37126 wxPyEndAllowThreads(__tstate);
37127 if (PyErr_Occurred()) SWIG_fail;
37128 }
37129 {
37130 #if wxUSE_UNICODE
37131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37132 #else
37133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37134 #endif
37135 }
37136 {
37137 if (temp1)
37138 delete arg1;
37139 }
37140 return resultobj;
37141 fail:
37142 {
37143 if (temp1)
37144 delete arg1;
37145 }
37146 return NULL;
37147 }
37148
37149
37150 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37151 PyObject *resultobj = NULL;
37152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37153 wxItemKind result;
37154 PyObject * obj0 = 0 ;
37155 char *kwnames[] = {
37156 (char *) "self", NULL
37157 };
37158
37159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37161 if (SWIG_arg_fail(1)) SWIG_fail;
37162 {
37163 PyThreadState* __tstate = wxPyBeginAllowThreads();
37164 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37165
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 resultobj = SWIG_From_int((result));
37170 return resultobj;
37171 fail:
37172 return NULL;
37173 }
37174
37175
37176 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37177 PyObject *resultobj = NULL;
37178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37179 wxItemKind arg2 ;
37180 PyObject * obj0 = 0 ;
37181 PyObject * obj1 = 0 ;
37182 char *kwnames[] = {
37183 (char *) "self",(char *) "kind", NULL
37184 };
37185
37186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37188 if (SWIG_arg_fail(1)) SWIG_fail;
37189 {
37190 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37191 if (SWIG_arg_fail(2)) SWIG_fail;
37192 }
37193 {
37194 PyThreadState* __tstate = wxPyBeginAllowThreads();
37195 (arg1)->SetKind(arg2);
37196
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 Py_INCREF(Py_None); resultobj = Py_None;
37201 return resultobj;
37202 fail:
37203 return NULL;
37204 }
37205
37206
37207 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37208 PyObject *resultobj = NULL;
37209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37210 bool arg2 ;
37211 PyObject * obj0 = 0 ;
37212 PyObject * obj1 = 0 ;
37213 char *kwnames[] = {
37214 (char *) "self",(char *) "checkable", NULL
37215 };
37216
37217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37219 if (SWIG_arg_fail(1)) SWIG_fail;
37220 {
37221 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37222 if (SWIG_arg_fail(2)) SWIG_fail;
37223 }
37224 {
37225 PyThreadState* __tstate = wxPyBeginAllowThreads();
37226 (arg1)->SetCheckable(arg2);
37227
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 Py_INCREF(Py_None); resultobj = Py_None;
37232 return resultobj;
37233 fail:
37234 return NULL;
37235 }
37236
37237
37238 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37239 PyObject *resultobj = NULL;
37240 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37241 bool result;
37242 PyObject * obj0 = 0 ;
37243 char *kwnames[] = {
37244 (char *) "self", NULL
37245 };
37246
37247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37249 if (SWIG_arg_fail(1)) SWIG_fail;
37250 {
37251 PyThreadState* __tstate = wxPyBeginAllowThreads();
37252 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37253
37254 wxPyEndAllowThreads(__tstate);
37255 if (PyErr_Occurred()) SWIG_fail;
37256 }
37257 {
37258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37259 }
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37267 PyObject *resultobj = NULL;
37268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37269 bool result;
37270 PyObject * obj0 = 0 ;
37271 char *kwnames[] = {
37272 (char *) "self", NULL
37273 };
37274
37275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37277 if (SWIG_arg_fail(1)) SWIG_fail;
37278 {
37279 PyThreadState* __tstate = wxPyBeginAllowThreads();
37280 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37281
37282 wxPyEndAllowThreads(__tstate);
37283 if (PyErr_Occurred()) SWIG_fail;
37284 }
37285 {
37286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37287 }
37288 return resultobj;
37289 fail:
37290 return NULL;
37291 }
37292
37293
37294 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37295 PyObject *resultobj = NULL;
37296 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37297 wxMenu *arg2 = (wxMenu *) 0 ;
37298 PyObject * obj0 = 0 ;
37299 PyObject * obj1 = 0 ;
37300 char *kwnames[] = {
37301 (char *) "self",(char *) "menu", NULL
37302 };
37303
37304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37306 if (SWIG_arg_fail(1)) SWIG_fail;
37307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37308 if (SWIG_arg_fail(2)) SWIG_fail;
37309 {
37310 PyThreadState* __tstate = wxPyBeginAllowThreads();
37311 (arg1)->SetSubMenu(arg2);
37312
37313 wxPyEndAllowThreads(__tstate);
37314 if (PyErr_Occurred()) SWIG_fail;
37315 }
37316 Py_INCREF(Py_None); resultobj = Py_None;
37317 return resultobj;
37318 fail:
37319 return NULL;
37320 }
37321
37322
37323 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37324 PyObject *resultobj = NULL;
37325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37326 wxMenu *result;
37327 PyObject * obj0 = 0 ;
37328 char *kwnames[] = {
37329 (char *) "self", NULL
37330 };
37331
37332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37334 if (SWIG_arg_fail(1)) SWIG_fail;
37335 {
37336 PyThreadState* __tstate = wxPyBeginAllowThreads();
37337 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37338
37339 wxPyEndAllowThreads(__tstate);
37340 if (PyErr_Occurred()) SWIG_fail;
37341 }
37342 {
37343 resultobj = wxPyMake_wxObject(result, 0);
37344 }
37345 return resultobj;
37346 fail:
37347 return NULL;
37348 }
37349
37350
37351 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37352 PyObject *resultobj = NULL;
37353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37354 bool arg2 = (bool) true ;
37355 PyObject * obj0 = 0 ;
37356 PyObject * obj1 = 0 ;
37357 char *kwnames[] = {
37358 (char *) "self",(char *) "enable", NULL
37359 };
37360
37361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37363 if (SWIG_arg_fail(1)) SWIG_fail;
37364 if (obj1) {
37365 {
37366 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37367 if (SWIG_arg_fail(2)) SWIG_fail;
37368 }
37369 }
37370 {
37371 PyThreadState* __tstate = wxPyBeginAllowThreads();
37372 (arg1)->Enable(arg2);
37373
37374 wxPyEndAllowThreads(__tstate);
37375 if (PyErr_Occurred()) SWIG_fail;
37376 }
37377 Py_INCREF(Py_None); resultobj = Py_None;
37378 return resultobj;
37379 fail:
37380 return NULL;
37381 }
37382
37383
37384 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37385 PyObject *resultobj = NULL;
37386 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37387 bool result;
37388 PyObject * obj0 = 0 ;
37389 char *kwnames[] = {
37390 (char *) "self", NULL
37391 };
37392
37393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37395 if (SWIG_arg_fail(1)) SWIG_fail;
37396 {
37397 PyThreadState* __tstate = wxPyBeginAllowThreads();
37398 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37399
37400 wxPyEndAllowThreads(__tstate);
37401 if (PyErr_Occurred()) SWIG_fail;
37402 }
37403 {
37404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37405 }
37406 return resultobj;
37407 fail:
37408 return NULL;
37409 }
37410
37411
37412 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37413 PyObject *resultobj = NULL;
37414 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37415 bool arg2 = (bool) true ;
37416 PyObject * obj0 = 0 ;
37417 PyObject * obj1 = 0 ;
37418 char *kwnames[] = {
37419 (char *) "self",(char *) "check", NULL
37420 };
37421
37422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37424 if (SWIG_arg_fail(1)) SWIG_fail;
37425 if (obj1) {
37426 {
37427 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37428 if (SWIG_arg_fail(2)) SWIG_fail;
37429 }
37430 }
37431 {
37432 PyThreadState* __tstate = wxPyBeginAllowThreads();
37433 (arg1)->Check(arg2);
37434
37435 wxPyEndAllowThreads(__tstate);
37436 if (PyErr_Occurred()) SWIG_fail;
37437 }
37438 Py_INCREF(Py_None); resultobj = Py_None;
37439 return resultobj;
37440 fail:
37441 return NULL;
37442 }
37443
37444
37445 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37446 PyObject *resultobj = NULL;
37447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37448 bool result;
37449 PyObject * obj0 = 0 ;
37450 char *kwnames[] = {
37451 (char *) "self", NULL
37452 };
37453
37454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37456 if (SWIG_arg_fail(1)) SWIG_fail;
37457 {
37458 PyThreadState* __tstate = wxPyBeginAllowThreads();
37459 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37460
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 {
37465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37466 }
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37474 PyObject *resultobj = NULL;
37475 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37476 PyObject * obj0 = 0 ;
37477 char *kwnames[] = {
37478 (char *) "self", NULL
37479 };
37480
37481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37483 if (SWIG_arg_fail(1)) SWIG_fail;
37484 {
37485 PyThreadState* __tstate = wxPyBeginAllowThreads();
37486 (arg1)->Toggle();
37487
37488 wxPyEndAllowThreads(__tstate);
37489 if (PyErr_Occurred()) SWIG_fail;
37490 }
37491 Py_INCREF(Py_None); resultobj = Py_None;
37492 return resultobj;
37493 fail:
37494 return NULL;
37495 }
37496
37497
37498 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37499 PyObject *resultobj = NULL;
37500 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37501 wxString *arg2 = 0 ;
37502 bool temp2 = false ;
37503 PyObject * obj0 = 0 ;
37504 PyObject * obj1 = 0 ;
37505 char *kwnames[] = {
37506 (char *) "self",(char *) "str", NULL
37507 };
37508
37509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37511 if (SWIG_arg_fail(1)) SWIG_fail;
37512 {
37513 arg2 = wxString_in_helper(obj1);
37514 if (arg2 == NULL) SWIG_fail;
37515 temp2 = true;
37516 }
37517 {
37518 PyThreadState* __tstate = wxPyBeginAllowThreads();
37519 (arg1)->SetHelp((wxString const &)*arg2);
37520
37521 wxPyEndAllowThreads(__tstate);
37522 if (PyErr_Occurred()) SWIG_fail;
37523 }
37524 Py_INCREF(Py_None); resultobj = Py_None;
37525 {
37526 if (temp2)
37527 delete arg2;
37528 }
37529 return resultobj;
37530 fail:
37531 {
37532 if (temp2)
37533 delete arg2;
37534 }
37535 return NULL;
37536 }
37537
37538
37539 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37540 PyObject *resultobj = NULL;
37541 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37542 wxString *result;
37543 PyObject * obj0 = 0 ;
37544 char *kwnames[] = {
37545 (char *) "self", NULL
37546 };
37547
37548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37550 if (SWIG_arg_fail(1)) SWIG_fail;
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 {
37554 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37555 result = (wxString *) &_result_ref;
37556 }
37557
37558 wxPyEndAllowThreads(__tstate);
37559 if (PyErr_Occurred()) SWIG_fail;
37560 }
37561 {
37562 #if wxUSE_UNICODE
37563 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37564 #else
37565 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37566 #endif
37567 }
37568 return resultobj;
37569 fail:
37570 return NULL;
37571 }
37572
37573
37574 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37575 PyObject *resultobj = NULL;
37576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37577 wxAcceleratorEntry *result;
37578 PyObject * obj0 = 0 ;
37579 char *kwnames[] = {
37580 (char *) "self", NULL
37581 };
37582
37583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37585 if (SWIG_arg_fail(1)) SWIG_fail;
37586 {
37587 PyThreadState* __tstate = wxPyBeginAllowThreads();
37588 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37589
37590 wxPyEndAllowThreads(__tstate);
37591 if (PyErr_Occurred()) SWIG_fail;
37592 }
37593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37594 return resultobj;
37595 fail:
37596 return NULL;
37597 }
37598
37599
37600 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37601 PyObject *resultobj = NULL;
37602 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37603 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37604 PyObject * obj0 = 0 ;
37605 PyObject * obj1 = 0 ;
37606 char *kwnames[] = {
37607 (char *) "self",(char *) "accel", NULL
37608 };
37609
37610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37612 if (SWIG_arg_fail(1)) SWIG_fail;
37613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37614 if (SWIG_arg_fail(2)) SWIG_fail;
37615 {
37616 PyThreadState* __tstate = wxPyBeginAllowThreads();
37617 (arg1)->SetAccel(arg2);
37618
37619 wxPyEndAllowThreads(__tstate);
37620 if (PyErr_Occurred()) SWIG_fail;
37621 }
37622 Py_INCREF(Py_None); resultobj = Py_None;
37623 return resultobj;
37624 fail:
37625 return NULL;
37626 }
37627
37628
37629 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37630 PyObject *resultobj = NULL;
37631 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37632 wxBitmap *arg2 = 0 ;
37633 PyObject * obj0 = 0 ;
37634 PyObject * obj1 = 0 ;
37635 char *kwnames[] = {
37636 (char *) "self",(char *) "bitmap", NULL
37637 };
37638
37639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37644 if (SWIG_arg_fail(2)) SWIG_fail;
37645 if (arg2 == NULL) {
37646 SWIG_null_ref("wxBitmap");
37647 }
37648 if (SWIG_arg_fail(2)) SWIG_fail;
37649 }
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37653
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 Py_INCREF(Py_None); resultobj = Py_None;
37658 return resultobj;
37659 fail:
37660 return NULL;
37661 }
37662
37663
37664 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37665 PyObject *resultobj = NULL;
37666 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37667 wxBitmap *result;
37668 PyObject * obj0 = 0 ;
37669 char *kwnames[] = {
37670 (char *) "self", NULL
37671 };
37672
37673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37675 if (SWIG_arg_fail(1)) SWIG_fail;
37676 {
37677 PyThreadState* __tstate = wxPyBeginAllowThreads();
37678 {
37679 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37680 result = (wxBitmap *) &_result_ref;
37681 }
37682
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 {
37687 wxBitmap* resultptr = new wxBitmap(*result);
37688 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37689 }
37690 return resultobj;
37691 fail:
37692 return NULL;
37693 }
37694
37695
37696 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37697 PyObject *resultobj = NULL;
37698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37699 wxFont *arg2 = 0 ;
37700 PyObject * obj0 = 0 ;
37701 PyObject * obj1 = 0 ;
37702 char *kwnames[] = {
37703 (char *) "self",(char *) "font", NULL
37704 };
37705
37706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37708 if (SWIG_arg_fail(1)) SWIG_fail;
37709 {
37710 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37711 if (SWIG_arg_fail(2)) SWIG_fail;
37712 if (arg2 == NULL) {
37713 SWIG_null_ref("wxFont");
37714 }
37715 if (SWIG_arg_fail(2)) SWIG_fail;
37716 }
37717 {
37718 PyThreadState* __tstate = wxPyBeginAllowThreads();
37719 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37720
37721 wxPyEndAllowThreads(__tstate);
37722 if (PyErr_Occurred()) SWIG_fail;
37723 }
37724 Py_INCREF(Py_None); resultobj = Py_None;
37725 return resultobj;
37726 fail:
37727 return NULL;
37728 }
37729
37730
37731 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37732 PyObject *resultobj = NULL;
37733 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37734 wxFont result;
37735 PyObject * obj0 = 0 ;
37736 char *kwnames[] = {
37737 (char *) "self", NULL
37738 };
37739
37740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) 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 {
37744 PyThreadState* __tstate = wxPyBeginAllowThreads();
37745 result = wxMenuItem_GetFont(arg1);
37746
37747 wxPyEndAllowThreads(__tstate);
37748 if (PyErr_Occurred()) SWIG_fail;
37749 }
37750 {
37751 wxFont * resultptr;
37752 resultptr = new wxFont(static_cast<wxFont & >(result));
37753 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37754 }
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37762 PyObject *resultobj = NULL;
37763 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37764 wxColour *arg2 = 0 ;
37765 wxColour temp2 ;
37766 PyObject * obj0 = 0 ;
37767 PyObject * obj1 = 0 ;
37768 char *kwnames[] = {
37769 (char *) "self",(char *) "colText", NULL
37770 };
37771
37772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37774 if (SWIG_arg_fail(1)) SWIG_fail;
37775 {
37776 arg2 = &temp2;
37777 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37778 }
37779 {
37780 PyThreadState* __tstate = wxPyBeginAllowThreads();
37781 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37782
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 Py_INCREF(Py_None); resultobj = Py_None;
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37794 PyObject *resultobj = NULL;
37795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37796 wxColour result;
37797 PyObject * obj0 = 0 ;
37798 char *kwnames[] = {
37799 (char *) "self", NULL
37800 };
37801
37802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37804 if (SWIG_arg_fail(1)) SWIG_fail;
37805 {
37806 PyThreadState* __tstate = wxPyBeginAllowThreads();
37807 result = wxMenuItem_GetTextColour(arg1);
37808
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 {
37813 wxColour * resultptr;
37814 resultptr = new wxColour(static_cast<wxColour & >(result));
37815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37816 }
37817 return resultobj;
37818 fail:
37819 return NULL;
37820 }
37821
37822
37823 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37824 PyObject *resultobj = NULL;
37825 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37826 wxColour *arg2 = 0 ;
37827 wxColour temp2 ;
37828 PyObject * obj0 = 0 ;
37829 PyObject * obj1 = 0 ;
37830 char *kwnames[] = {
37831 (char *) "self",(char *) "colBack", NULL
37832 };
37833
37834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37836 if (SWIG_arg_fail(1)) SWIG_fail;
37837 {
37838 arg2 = &temp2;
37839 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37840 }
37841 {
37842 PyThreadState* __tstate = wxPyBeginAllowThreads();
37843 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37844
37845 wxPyEndAllowThreads(__tstate);
37846 if (PyErr_Occurred()) SWIG_fail;
37847 }
37848 Py_INCREF(Py_None); resultobj = Py_None;
37849 return resultobj;
37850 fail:
37851 return NULL;
37852 }
37853
37854
37855 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37856 PyObject *resultobj = NULL;
37857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37858 wxColour result;
37859 PyObject * obj0 = 0 ;
37860 char *kwnames[] = {
37861 (char *) "self", NULL
37862 };
37863
37864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37866 if (SWIG_arg_fail(1)) SWIG_fail;
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 result = wxMenuItem_GetBackgroundColour(arg1);
37870
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 {
37875 wxColour * resultptr;
37876 resultptr = new wxColour(static_cast<wxColour & >(result));
37877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37878 }
37879 return resultobj;
37880 fail:
37881 return NULL;
37882 }
37883
37884
37885 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37886 PyObject *resultobj = NULL;
37887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37888 wxBitmap *arg2 = 0 ;
37889 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37890 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37891 PyObject * obj0 = 0 ;
37892 PyObject * obj1 = 0 ;
37893 PyObject * obj2 = 0 ;
37894 char *kwnames[] = {
37895 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37896 };
37897
37898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37900 if (SWIG_arg_fail(1)) SWIG_fail;
37901 {
37902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37903 if (SWIG_arg_fail(2)) SWIG_fail;
37904 if (arg2 == NULL) {
37905 SWIG_null_ref("wxBitmap");
37906 }
37907 if (SWIG_arg_fail(2)) SWIG_fail;
37908 }
37909 if (obj2) {
37910 {
37911 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37912 if (SWIG_arg_fail(3)) SWIG_fail;
37913 if (arg3 == NULL) {
37914 SWIG_null_ref("wxBitmap");
37915 }
37916 if (SWIG_arg_fail(3)) SWIG_fail;
37917 }
37918 }
37919 {
37920 PyThreadState* __tstate = wxPyBeginAllowThreads();
37921 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37922
37923 wxPyEndAllowThreads(__tstate);
37924 if (PyErr_Occurred()) SWIG_fail;
37925 }
37926 Py_INCREF(Py_None); resultobj = Py_None;
37927 return resultobj;
37928 fail:
37929 return NULL;
37930 }
37931
37932
37933 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37934 PyObject *resultobj = NULL;
37935 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37936 wxBitmap *arg2 = 0 ;
37937 PyObject * obj0 = 0 ;
37938 PyObject * obj1 = 0 ;
37939 char *kwnames[] = {
37940 (char *) "self",(char *) "bmpDisabled", NULL
37941 };
37942
37943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37945 if (SWIG_arg_fail(1)) SWIG_fail;
37946 {
37947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37948 if (SWIG_arg_fail(2)) SWIG_fail;
37949 if (arg2 == NULL) {
37950 SWIG_null_ref("wxBitmap");
37951 }
37952 if (SWIG_arg_fail(2)) SWIG_fail;
37953 }
37954 {
37955 PyThreadState* __tstate = wxPyBeginAllowThreads();
37956 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37957
37958 wxPyEndAllowThreads(__tstate);
37959 if (PyErr_Occurred()) SWIG_fail;
37960 }
37961 Py_INCREF(Py_None); resultobj = Py_None;
37962 return resultobj;
37963 fail:
37964 return NULL;
37965 }
37966
37967
37968 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37969 PyObject *resultobj = NULL;
37970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37971 wxBitmap *result;
37972 PyObject * obj0 = 0 ;
37973 char *kwnames[] = {
37974 (char *) "self", NULL
37975 };
37976
37977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37979 if (SWIG_arg_fail(1)) SWIG_fail;
37980 {
37981 PyThreadState* __tstate = wxPyBeginAllowThreads();
37982 {
37983 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37984 result = (wxBitmap *) &_result_ref;
37985 }
37986
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 {
37991 wxBitmap* resultptr = new wxBitmap(*result);
37992 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37993 }
37994 return resultobj;
37995 fail:
37996 return NULL;
37997 }
37998
37999
38000 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38001 PyObject *resultobj = NULL;
38002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38003 int arg2 ;
38004 PyObject * obj0 = 0 ;
38005 PyObject * obj1 = 0 ;
38006 char *kwnames[] = {
38007 (char *) "self",(char *) "nWidth", NULL
38008 };
38009
38010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38012 if (SWIG_arg_fail(1)) SWIG_fail;
38013 {
38014 arg2 = static_cast<int >(SWIG_As_int(obj1));
38015 if (SWIG_arg_fail(2)) SWIG_fail;
38016 }
38017 {
38018 PyThreadState* __tstate = wxPyBeginAllowThreads();
38019 wxMenuItem_SetMarginWidth(arg1,arg2);
38020
38021 wxPyEndAllowThreads(__tstate);
38022 if (PyErr_Occurred()) SWIG_fail;
38023 }
38024 Py_INCREF(Py_None); resultobj = Py_None;
38025 return resultobj;
38026 fail:
38027 return NULL;
38028 }
38029
38030
38031 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38032 PyObject *resultobj = NULL;
38033 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38034 int result;
38035 PyObject * obj0 = 0 ;
38036 char *kwnames[] = {
38037 (char *) "self", NULL
38038 };
38039
38040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38042 if (SWIG_arg_fail(1)) SWIG_fail;
38043 {
38044 PyThreadState* __tstate = wxPyBeginAllowThreads();
38045 result = (int)wxMenuItem_GetMarginWidth(arg1);
38046
38047 wxPyEndAllowThreads(__tstate);
38048 if (PyErr_Occurred()) SWIG_fail;
38049 }
38050 {
38051 resultobj = SWIG_From_int(static_cast<int >(result));
38052 }
38053 return resultobj;
38054 fail:
38055 return NULL;
38056 }
38057
38058
38059 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38060 PyObject *resultobj = NULL;
38061 int result;
38062 char *kwnames[] = {
38063 NULL
38064 };
38065
38066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38067 {
38068 PyThreadState* __tstate = wxPyBeginAllowThreads();
38069 result = (int)wxMenuItem_GetDefaultMarginWidth();
38070
38071 wxPyEndAllowThreads(__tstate);
38072 if (PyErr_Occurred()) SWIG_fail;
38073 }
38074 {
38075 resultobj = SWIG_From_int(static_cast<int >(result));
38076 }
38077 return resultobj;
38078 fail:
38079 return NULL;
38080 }
38081
38082
38083 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38084 PyObject *resultobj = NULL;
38085 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38086 bool result;
38087 PyObject * obj0 = 0 ;
38088 char *kwnames[] = {
38089 (char *) "self", NULL
38090 };
38091
38092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38094 if (SWIG_arg_fail(1)) SWIG_fail;
38095 {
38096 PyThreadState* __tstate = wxPyBeginAllowThreads();
38097 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
38098
38099 wxPyEndAllowThreads(__tstate);
38100 if (PyErr_Occurred()) SWIG_fail;
38101 }
38102 {
38103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38104 }
38105 return resultobj;
38106 fail:
38107 return NULL;
38108 }
38109
38110
38111 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38112 PyObject *resultobj = NULL;
38113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38114 bool arg2 = (bool) true ;
38115 PyObject * obj0 = 0 ;
38116 PyObject * obj1 = 0 ;
38117 char *kwnames[] = {
38118 (char *) "self",(char *) "ownerDrawn", NULL
38119 };
38120
38121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38123 if (SWIG_arg_fail(1)) SWIG_fail;
38124 if (obj1) {
38125 {
38126 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38127 if (SWIG_arg_fail(2)) SWIG_fail;
38128 }
38129 }
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 wxMenuItem_SetOwnerDrawn(arg1,arg2);
38133
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 Py_INCREF(Py_None); resultobj = Py_None;
38138 return resultobj;
38139 fail:
38140 return NULL;
38141 }
38142
38143
38144 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38145 PyObject *resultobj = NULL;
38146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38147 PyObject * obj0 = 0 ;
38148 char *kwnames[] = {
38149 (char *) "self", NULL
38150 };
38151
38152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38154 if (SWIG_arg_fail(1)) SWIG_fail;
38155 {
38156 PyThreadState* __tstate = wxPyBeginAllowThreads();
38157 wxMenuItem_ResetOwnerDrawn(arg1);
38158
38159 wxPyEndAllowThreads(__tstate);
38160 if (PyErr_Occurred()) SWIG_fail;
38161 }
38162 Py_INCREF(Py_None); resultobj = Py_None;
38163 return resultobj;
38164 fail:
38165 return NULL;
38166 }
38167
38168
38169 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38170 PyObject *obj;
38171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38172 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38173 Py_INCREF(obj);
38174 return Py_BuildValue((char *)"");
38175 }
38176 static int _wrap_ControlNameStr_set(PyObject *) {
38177 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38178 return 1;
38179 }
38180
38181
38182 static PyObject *_wrap_ControlNameStr_get(void) {
38183 PyObject *pyobj = NULL;
38184
38185 {
38186 #if wxUSE_UNICODE
38187 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38188 #else
38189 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38190 #endif
38191 }
38192 return pyobj;
38193 }
38194
38195
38196 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38197 PyObject *resultobj = NULL;
38198 wxWindow *arg1 = (wxWindow *) 0 ;
38199 int arg2 = (int) -1 ;
38200 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38201 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38202 wxSize const &arg4_defvalue = wxDefaultSize ;
38203 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38204 long arg5 = (long) 0 ;
38205 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38206 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38207 wxString const &arg7_defvalue = wxPyControlNameStr ;
38208 wxString *arg7 = (wxString *) &arg7_defvalue ;
38209 wxControl *result;
38210 wxPoint temp3 ;
38211 wxSize temp4 ;
38212 bool temp7 = false ;
38213 PyObject * obj0 = 0 ;
38214 PyObject * obj1 = 0 ;
38215 PyObject * obj2 = 0 ;
38216 PyObject * obj3 = 0 ;
38217 PyObject * obj4 = 0 ;
38218 PyObject * obj5 = 0 ;
38219 PyObject * obj6 = 0 ;
38220 char *kwnames[] = {
38221 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38222 };
38223
38224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38226 if (SWIG_arg_fail(1)) SWIG_fail;
38227 if (obj1) {
38228 {
38229 arg2 = static_cast<int >(SWIG_As_int(obj1));
38230 if (SWIG_arg_fail(2)) SWIG_fail;
38231 }
38232 }
38233 if (obj2) {
38234 {
38235 arg3 = &temp3;
38236 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38237 }
38238 }
38239 if (obj3) {
38240 {
38241 arg4 = &temp4;
38242 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38243 }
38244 }
38245 if (obj4) {
38246 {
38247 arg5 = static_cast<long >(SWIG_As_long(obj4));
38248 if (SWIG_arg_fail(5)) SWIG_fail;
38249 }
38250 }
38251 if (obj5) {
38252 {
38253 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38254 if (SWIG_arg_fail(6)) SWIG_fail;
38255 if (arg6 == NULL) {
38256 SWIG_null_ref("wxValidator");
38257 }
38258 if (SWIG_arg_fail(6)) SWIG_fail;
38259 }
38260 }
38261 if (obj6) {
38262 {
38263 arg7 = wxString_in_helper(obj6);
38264 if (arg7 == NULL) SWIG_fail;
38265 temp7 = true;
38266 }
38267 }
38268 {
38269 if (!wxPyCheckForApp()) SWIG_fail;
38270 PyThreadState* __tstate = wxPyBeginAllowThreads();
38271 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38272
38273 wxPyEndAllowThreads(__tstate);
38274 if (PyErr_Occurred()) SWIG_fail;
38275 }
38276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38277 {
38278 if (temp7)
38279 delete arg7;
38280 }
38281 return resultobj;
38282 fail:
38283 {
38284 if (temp7)
38285 delete arg7;
38286 }
38287 return NULL;
38288 }
38289
38290
38291 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38292 PyObject *resultobj = NULL;
38293 wxControl *result;
38294 char *kwnames[] = {
38295 NULL
38296 };
38297
38298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38299 {
38300 if (!wxPyCheckForApp()) SWIG_fail;
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 result = (wxControl *)new wxControl();
38303
38304 wxPyEndAllowThreads(__tstate);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 }
38307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38308 return resultobj;
38309 fail:
38310 return NULL;
38311 }
38312
38313
38314 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38315 PyObject *resultobj = NULL;
38316 wxControl *arg1 = (wxControl *) 0 ;
38317 wxWindow *arg2 = (wxWindow *) 0 ;
38318 int arg3 = (int) -1 ;
38319 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38320 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38321 wxSize const &arg5_defvalue = wxDefaultSize ;
38322 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38323 long arg6 = (long) 0 ;
38324 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38325 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38326 wxString const &arg8_defvalue = wxPyControlNameStr ;
38327 wxString *arg8 = (wxString *) &arg8_defvalue ;
38328 bool result;
38329 wxPoint temp4 ;
38330 wxSize temp5 ;
38331 bool temp8 = false ;
38332 PyObject * obj0 = 0 ;
38333 PyObject * obj1 = 0 ;
38334 PyObject * obj2 = 0 ;
38335 PyObject * obj3 = 0 ;
38336 PyObject * obj4 = 0 ;
38337 PyObject * obj5 = 0 ;
38338 PyObject * obj6 = 0 ;
38339 PyObject * obj7 = 0 ;
38340 char *kwnames[] = {
38341 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38342 };
38343
38344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38346 if (SWIG_arg_fail(1)) SWIG_fail;
38347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38348 if (SWIG_arg_fail(2)) SWIG_fail;
38349 if (obj2) {
38350 {
38351 arg3 = static_cast<int >(SWIG_As_int(obj2));
38352 if (SWIG_arg_fail(3)) SWIG_fail;
38353 }
38354 }
38355 if (obj3) {
38356 {
38357 arg4 = &temp4;
38358 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38359 }
38360 }
38361 if (obj4) {
38362 {
38363 arg5 = &temp5;
38364 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38365 }
38366 }
38367 if (obj5) {
38368 {
38369 arg6 = static_cast<long >(SWIG_As_long(obj5));
38370 if (SWIG_arg_fail(6)) SWIG_fail;
38371 }
38372 }
38373 if (obj6) {
38374 {
38375 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38376 if (SWIG_arg_fail(7)) SWIG_fail;
38377 if (arg7 == NULL) {
38378 SWIG_null_ref("wxValidator");
38379 }
38380 if (SWIG_arg_fail(7)) SWIG_fail;
38381 }
38382 }
38383 if (obj7) {
38384 {
38385 arg8 = wxString_in_helper(obj7);
38386 if (arg8 == NULL) SWIG_fail;
38387 temp8 = true;
38388 }
38389 }
38390 {
38391 PyThreadState* __tstate = wxPyBeginAllowThreads();
38392 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38393
38394 wxPyEndAllowThreads(__tstate);
38395 if (PyErr_Occurred()) SWIG_fail;
38396 }
38397 {
38398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38399 }
38400 {
38401 if (temp8)
38402 delete arg8;
38403 }
38404 return resultobj;
38405 fail:
38406 {
38407 if (temp8)
38408 delete arg8;
38409 }
38410 return NULL;
38411 }
38412
38413
38414 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38415 PyObject *resultobj = NULL;
38416 wxControl *arg1 = (wxControl *) 0 ;
38417 wxCommandEvent *arg2 = 0 ;
38418 PyObject * obj0 = 0 ;
38419 PyObject * obj1 = 0 ;
38420 char *kwnames[] = {
38421 (char *) "self",(char *) "event", NULL
38422 };
38423
38424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38426 if (SWIG_arg_fail(1)) SWIG_fail;
38427 {
38428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38429 if (SWIG_arg_fail(2)) SWIG_fail;
38430 if (arg2 == NULL) {
38431 SWIG_null_ref("wxCommandEvent");
38432 }
38433 if (SWIG_arg_fail(2)) SWIG_fail;
38434 }
38435 {
38436 PyThreadState* __tstate = wxPyBeginAllowThreads();
38437 (arg1)->Command(*arg2);
38438
38439 wxPyEndAllowThreads(__tstate);
38440 if (PyErr_Occurred()) SWIG_fail;
38441 }
38442 Py_INCREF(Py_None); resultobj = Py_None;
38443 return resultobj;
38444 fail:
38445 return NULL;
38446 }
38447
38448
38449 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38450 PyObject *resultobj = NULL;
38451 wxControl *arg1 = (wxControl *) 0 ;
38452 wxString result;
38453 PyObject * obj0 = 0 ;
38454 char *kwnames[] = {
38455 (char *) "self", NULL
38456 };
38457
38458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38460 if (SWIG_arg_fail(1)) SWIG_fail;
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 result = (arg1)->GetLabel();
38464
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 {
38469 #if wxUSE_UNICODE
38470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38471 #else
38472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38473 #endif
38474 }
38475 return resultobj;
38476 fail:
38477 return NULL;
38478 }
38479
38480
38481 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38482 PyObject *resultobj = NULL;
38483 wxControl *arg1 = (wxControl *) 0 ;
38484 wxString *arg2 = 0 ;
38485 bool temp2 = false ;
38486 PyObject * obj0 = 0 ;
38487 PyObject * obj1 = 0 ;
38488 char *kwnames[] = {
38489 (char *) "self",(char *) "label", NULL
38490 };
38491
38492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38494 if (SWIG_arg_fail(1)) SWIG_fail;
38495 {
38496 arg2 = wxString_in_helper(obj1);
38497 if (arg2 == NULL) SWIG_fail;
38498 temp2 = true;
38499 }
38500 {
38501 PyThreadState* __tstate = wxPyBeginAllowThreads();
38502 (arg1)->SetLabel((wxString const &)*arg2);
38503
38504 wxPyEndAllowThreads(__tstate);
38505 if (PyErr_Occurred()) SWIG_fail;
38506 }
38507 Py_INCREF(Py_None); resultobj = Py_None;
38508 {
38509 if (temp2)
38510 delete arg2;
38511 }
38512 return resultobj;
38513 fail:
38514 {
38515 if (temp2)
38516 delete arg2;
38517 }
38518 return NULL;
38519 }
38520
38521
38522 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38523 PyObject *resultobj = NULL;
38524 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38525 wxVisualAttributes result;
38526 PyObject * obj0 = 0 ;
38527 char *kwnames[] = {
38528 (char *) "variant", NULL
38529 };
38530
38531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38532 if (obj0) {
38533 {
38534 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38535 if (SWIG_arg_fail(1)) SWIG_fail;
38536 }
38537 }
38538 {
38539 if (!wxPyCheckForApp()) SWIG_fail;
38540 PyThreadState* __tstate = wxPyBeginAllowThreads();
38541 result = wxControl::GetClassDefaultAttributes(arg1);
38542
38543 wxPyEndAllowThreads(__tstate);
38544 if (PyErr_Occurred()) SWIG_fail;
38545 }
38546 {
38547 wxVisualAttributes * resultptr;
38548 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38550 }
38551 return resultobj;
38552 fail:
38553 return NULL;
38554 }
38555
38556
38557 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38558 PyObject *obj;
38559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38560 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38561 Py_INCREF(obj);
38562 return Py_BuildValue((char *)"");
38563 }
38564 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38565 PyObject *resultobj = NULL;
38566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38567 wxString *arg2 = 0 ;
38568 PyObject *arg3 = (PyObject *) NULL ;
38569 int result;
38570 bool temp2 = false ;
38571 PyObject * obj0 = 0 ;
38572 PyObject * obj1 = 0 ;
38573 PyObject * obj2 = 0 ;
38574 char *kwnames[] = {
38575 (char *) "self",(char *) "item",(char *) "clientData", NULL
38576 };
38577
38578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38580 if (SWIG_arg_fail(1)) SWIG_fail;
38581 {
38582 arg2 = wxString_in_helper(obj1);
38583 if (arg2 == NULL) SWIG_fail;
38584 temp2 = true;
38585 }
38586 if (obj2) {
38587 arg3 = obj2;
38588 }
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38592
38593 wxPyEndAllowThreads(__tstate);
38594 if (PyErr_Occurred()) SWIG_fail;
38595 }
38596 {
38597 resultobj = SWIG_From_int(static_cast<int >(result));
38598 }
38599 {
38600 if (temp2)
38601 delete arg2;
38602 }
38603 return resultobj;
38604 fail:
38605 {
38606 if (temp2)
38607 delete arg2;
38608 }
38609 return NULL;
38610 }
38611
38612
38613 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38614 PyObject *resultobj = NULL;
38615 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38616 wxArrayString *arg2 = 0 ;
38617 bool temp2 = false ;
38618 PyObject * obj0 = 0 ;
38619 PyObject * obj1 = 0 ;
38620 char *kwnames[] = {
38621 (char *) "self",(char *) "strings", NULL
38622 };
38623
38624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38626 if (SWIG_arg_fail(1)) SWIG_fail;
38627 {
38628 if (! PySequence_Check(obj1)) {
38629 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38630 SWIG_fail;
38631 }
38632 arg2 = new wxArrayString;
38633 temp2 = true;
38634 int i, len=PySequence_Length(obj1);
38635 for (i=0; i<len; i++) {
38636 PyObject* item = PySequence_GetItem(obj1, i);
38637 wxString* s = wxString_in_helper(item);
38638 if (PyErr_Occurred()) SWIG_fail;
38639 arg2->Add(*s);
38640 delete s;
38641 Py_DECREF(item);
38642 }
38643 }
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 (arg1)->Append((wxArrayString const &)*arg2);
38647
38648 wxPyEndAllowThreads(__tstate);
38649 if (PyErr_Occurred()) SWIG_fail;
38650 }
38651 Py_INCREF(Py_None); resultobj = Py_None;
38652 {
38653 if (temp2) delete arg2;
38654 }
38655 return resultobj;
38656 fail:
38657 {
38658 if (temp2) delete arg2;
38659 }
38660 return NULL;
38661 }
38662
38663
38664 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38665 PyObject *resultobj = NULL;
38666 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38667 wxString *arg2 = 0 ;
38668 int arg3 ;
38669 PyObject *arg4 = (PyObject *) NULL ;
38670 int result;
38671 bool temp2 = false ;
38672 PyObject * obj0 = 0 ;
38673 PyObject * obj1 = 0 ;
38674 PyObject * obj2 = 0 ;
38675 PyObject * obj3 = 0 ;
38676 char *kwnames[] = {
38677 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38678 };
38679
38680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38682 if (SWIG_arg_fail(1)) SWIG_fail;
38683 {
38684 arg2 = wxString_in_helper(obj1);
38685 if (arg2 == NULL) SWIG_fail;
38686 temp2 = true;
38687 }
38688 {
38689 arg3 = static_cast<int >(SWIG_As_int(obj2));
38690 if (SWIG_arg_fail(3)) SWIG_fail;
38691 }
38692 if (obj3) {
38693 arg4 = obj3;
38694 }
38695 {
38696 PyThreadState* __tstate = wxPyBeginAllowThreads();
38697 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38698
38699 wxPyEndAllowThreads(__tstate);
38700 if (PyErr_Occurred()) SWIG_fail;
38701 }
38702 {
38703 resultobj = SWIG_From_int(static_cast<int >(result));
38704 }
38705 {
38706 if (temp2)
38707 delete arg2;
38708 }
38709 return resultobj;
38710 fail:
38711 {
38712 if (temp2)
38713 delete arg2;
38714 }
38715 return NULL;
38716 }
38717
38718
38719 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38720 PyObject *resultobj = NULL;
38721 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38722 PyObject * obj0 = 0 ;
38723 char *kwnames[] = {
38724 (char *) "self", NULL
38725 };
38726
38727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38729 if (SWIG_arg_fail(1)) SWIG_fail;
38730 {
38731 PyThreadState* __tstate = wxPyBeginAllowThreads();
38732 (arg1)->Clear();
38733
38734 wxPyEndAllowThreads(__tstate);
38735 if (PyErr_Occurred()) SWIG_fail;
38736 }
38737 Py_INCREF(Py_None); resultobj = Py_None;
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj = NULL;
38746 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38747 int arg2 ;
38748 PyObject * obj0 = 0 ;
38749 PyObject * obj1 = 0 ;
38750 char *kwnames[] = {
38751 (char *) "self",(char *) "n", NULL
38752 };
38753
38754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",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 arg2 = static_cast<int >(SWIG_As_int(obj1));
38759 if (SWIG_arg_fail(2)) SWIG_fail;
38760 }
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 (arg1)->Delete(arg2);
38764
38765 wxPyEndAllowThreads(__tstate);
38766 if (PyErr_Occurred()) SWIG_fail;
38767 }
38768 Py_INCREF(Py_None); resultobj = Py_None;
38769 return resultobj;
38770 fail:
38771 return NULL;
38772 }
38773
38774
38775 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38776 PyObject *resultobj = NULL;
38777 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38778 int arg2 ;
38779 PyObject *result;
38780 PyObject * obj0 = 0 ;
38781 PyObject * obj1 = 0 ;
38782 char *kwnames[] = {
38783 (char *) "self",(char *) "n", NULL
38784 };
38785
38786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38788 if (SWIG_arg_fail(1)) SWIG_fail;
38789 {
38790 arg2 = static_cast<int >(SWIG_As_int(obj1));
38791 if (SWIG_arg_fail(2)) SWIG_fail;
38792 }
38793 {
38794 PyThreadState* __tstate = wxPyBeginAllowThreads();
38795 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38796
38797 wxPyEndAllowThreads(__tstate);
38798 if (PyErr_Occurred()) SWIG_fail;
38799 }
38800 resultobj = result;
38801 return resultobj;
38802 fail:
38803 return NULL;
38804 }
38805
38806
38807 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38808 PyObject *resultobj = NULL;
38809 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38810 int arg2 ;
38811 PyObject *arg3 = (PyObject *) 0 ;
38812 PyObject * obj0 = 0 ;
38813 PyObject * obj1 = 0 ;
38814 PyObject * obj2 = 0 ;
38815 char *kwnames[] = {
38816 (char *) "self",(char *) "n",(char *) "clientData", NULL
38817 };
38818
38819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38821 if (SWIG_arg_fail(1)) SWIG_fail;
38822 {
38823 arg2 = static_cast<int >(SWIG_As_int(obj1));
38824 if (SWIG_arg_fail(2)) SWIG_fail;
38825 }
38826 arg3 = obj2;
38827 {
38828 PyThreadState* __tstate = wxPyBeginAllowThreads();
38829 wxItemContainer_SetClientData(arg1,arg2,arg3);
38830
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 Py_INCREF(Py_None); resultobj = Py_None;
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38842 PyObject *resultobj = NULL;
38843 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38844 int result;
38845 PyObject * obj0 = 0 ;
38846 char *kwnames[] = {
38847 (char *) "self", NULL
38848 };
38849
38850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38852 if (SWIG_arg_fail(1)) SWIG_fail;
38853 {
38854 PyThreadState* __tstate = wxPyBeginAllowThreads();
38855 result = (int)((wxItemContainer const *)arg1)->GetCount();
38856
38857 wxPyEndAllowThreads(__tstate);
38858 if (PyErr_Occurred()) SWIG_fail;
38859 }
38860 {
38861 resultobj = SWIG_From_int(static_cast<int >(result));
38862 }
38863 return resultobj;
38864 fail:
38865 return NULL;
38866 }
38867
38868
38869 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38870 PyObject *resultobj = NULL;
38871 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38872 bool result;
38873 PyObject * obj0 = 0 ;
38874 char *kwnames[] = {
38875 (char *) "self", NULL
38876 };
38877
38878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38880 if (SWIG_arg_fail(1)) SWIG_fail;
38881 {
38882 PyThreadState* __tstate = wxPyBeginAllowThreads();
38883 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38884
38885 wxPyEndAllowThreads(__tstate);
38886 if (PyErr_Occurred()) SWIG_fail;
38887 }
38888 {
38889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38890 }
38891 return resultobj;
38892 fail:
38893 return NULL;
38894 }
38895
38896
38897 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38898 PyObject *resultobj = NULL;
38899 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38900 int arg2 ;
38901 wxString result;
38902 PyObject * obj0 = 0 ;
38903 PyObject * obj1 = 0 ;
38904 char *kwnames[] = {
38905 (char *) "self",(char *) "n", NULL
38906 };
38907
38908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38910 if (SWIG_arg_fail(1)) SWIG_fail;
38911 {
38912 arg2 = static_cast<int >(SWIG_As_int(obj1));
38913 if (SWIG_arg_fail(2)) SWIG_fail;
38914 }
38915 {
38916 PyThreadState* __tstate = wxPyBeginAllowThreads();
38917 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38918
38919 wxPyEndAllowThreads(__tstate);
38920 if (PyErr_Occurred()) SWIG_fail;
38921 }
38922 {
38923 #if wxUSE_UNICODE
38924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38925 #else
38926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38927 #endif
38928 }
38929 return resultobj;
38930 fail:
38931 return NULL;
38932 }
38933
38934
38935 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38936 PyObject *resultobj = NULL;
38937 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38938 wxArrayString result;
38939 PyObject * obj0 = 0 ;
38940 char *kwnames[] = {
38941 (char *) "self", NULL
38942 };
38943
38944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38946 if (SWIG_arg_fail(1)) SWIG_fail;
38947 {
38948 PyThreadState* __tstate = wxPyBeginAllowThreads();
38949 result = ((wxItemContainer const *)arg1)->GetStrings();
38950
38951 wxPyEndAllowThreads(__tstate);
38952 if (PyErr_Occurred()) SWIG_fail;
38953 }
38954 {
38955 resultobj = wxArrayString2PyList_helper(result);
38956 }
38957 return resultobj;
38958 fail:
38959 return NULL;
38960 }
38961
38962
38963 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38964 PyObject *resultobj = NULL;
38965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38966 int arg2 ;
38967 wxString *arg3 = 0 ;
38968 bool temp3 = false ;
38969 PyObject * obj0 = 0 ;
38970 PyObject * obj1 = 0 ;
38971 PyObject * obj2 = 0 ;
38972 char *kwnames[] = {
38973 (char *) "self",(char *) "n",(char *) "s", NULL
38974 };
38975
38976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38978 if (SWIG_arg_fail(1)) SWIG_fail;
38979 {
38980 arg2 = static_cast<int >(SWIG_As_int(obj1));
38981 if (SWIG_arg_fail(2)) SWIG_fail;
38982 }
38983 {
38984 arg3 = wxString_in_helper(obj2);
38985 if (arg3 == NULL) SWIG_fail;
38986 temp3 = true;
38987 }
38988 {
38989 PyThreadState* __tstate = wxPyBeginAllowThreads();
38990 (arg1)->SetString(arg2,(wxString const &)*arg3);
38991
38992 wxPyEndAllowThreads(__tstate);
38993 if (PyErr_Occurred()) SWIG_fail;
38994 }
38995 Py_INCREF(Py_None); resultobj = Py_None;
38996 {
38997 if (temp3)
38998 delete arg3;
38999 }
39000 return resultobj;
39001 fail:
39002 {
39003 if (temp3)
39004 delete arg3;
39005 }
39006 return NULL;
39007 }
39008
39009
39010 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39011 PyObject *resultobj = NULL;
39012 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39013 wxString *arg2 = 0 ;
39014 int result;
39015 bool temp2 = false ;
39016 PyObject * obj0 = 0 ;
39017 PyObject * obj1 = 0 ;
39018 char *kwnames[] = {
39019 (char *) "self",(char *) "s", NULL
39020 };
39021
39022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39024 if (SWIG_arg_fail(1)) SWIG_fail;
39025 {
39026 arg2 = wxString_in_helper(obj1);
39027 if (arg2 == NULL) SWIG_fail;
39028 temp2 = true;
39029 }
39030 {
39031 PyThreadState* __tstate = wxPyBeginAllowThreads();
39032 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39033
39034 wxPyEndAllowThreads(__tstate);
39035 if (PyErr_Occurred()) SWIG_fail;
39036 }
39037 {
39038 resultobj = SWIG_From_int(static_cast<int >(result));
39039 }
39040 {
39041 if (temp2)
39042 delete arg2;
39043 }
39044 return resultobj;
39045 fail:
39046 {
39047 if (temp2)
39048 delete arg2;
39049 }
39050 return NULL;
39051 }
39052
39053
39054 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39055 PyObject *resultobj = NULL;
39056 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39057 int arg2 ;
39058 PyObject * obj0 = 0 ;
39059 PyObject * obj1 = 0 ;
39060 char *kwnames[] = {
39061 (char *) "self",(char *) "n", NULL
39062 };
39063
39064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39066 if (SWIG_arg_fail(1)) SWIG_fail;
39067 {
39068 arg2 = static_cast<int >(SWIG_As_int(obj1));
39069 if (SWIG_arg_fail(2)) SWIG_fail;
39070 }
39071 {
39072 PyThreadState* __tstate = wxPyBeginAllowThreads();
39073 (arg1)->SetSelection(arg2);
39074
39075 wxPyEndAllowThreads(__tstate);
39076 if (PyErr_Occurred()) SWIG_fail;
39077 }
39078 Py_INCREF(Py_None); resultobj = Py_None;
39079 return resultobj;
39080 fail:
39081 return NULL;
39082 }
39083
39084
39085 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj = NULL;
39087 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39088 int result;
39089 PyObject * obj0 = 0 ;
39090 char *kwnames[] = {
39091 (char *) "self", NULL
39092 };
39093
39094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39096 if (SWIG_arg_fail(1)) SWIG_fail;
39097 {
39098 PyThreadState* __tstate = wxPyBeginAllowThreads();
39099 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39100
39101 wxPyEndAllowThreads(__tstate);
39102 if (PyErr_Occurred()) SWIG_fail;
39103 }
39104 {
39105 resultobj = SWIG_From_int(static_cast<int >(result));
39106 }
39107 return resultobj;
39108 fail:
39109 return NULL;
39110 }
39111
39112
39113 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39114 PyObject *resultobj = NULL;
39115 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39116 wxString *arg2 = 0 ;
39117 bool result;
39118 bool temp2 = false ;
39119 PyObject * obj0 = 0 ;
39120 PyObject * obj1 = 0 ;
39121 char *kwnames[] = {
39122 (char *) "self",(char *) "s", NULL
39123 };
39124
39125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39127 if (SWIG_arg_fail(1)) SWIG_fail;
39128 {
39129 arg2 = wxString_in_helper(obj1);
39130 if (arg2 == NULL) SWIG_fail;
39131 temp2 = true;
39132 }
39133 {
39134 PyThreadState* __tstate = wxPyBeginAllowThreads();
39135 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39136
39137 wxPyEndAllowThreads(__tstate);
39138 if (PyErr_Occurred()) SWIG_fail;
39139 }
39140 {
39141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39142 }
39143 {
39144 if (temp2)
39145 delete arg2;
39146 }
39147 return resultobj;
39148 fail:
39149 {
39150 if (temp2)
39151 delete arg2;
39152 }
39153 return NULL;
39154 }
39155
39156
39157 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39158 PyObject *resultobj = NULL;
39159 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39160 wxString result;
39161 PyObject * obj0 = 0 ;
39162 char *kwnames[] = {
39163 (char *) "self", NULL
39164 };
39165
39166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39168 if (SWIG_arg_fail(1)) SWIG_fail;
39169 {
39170 PyThreadState* __tstate = wxPyBeginAllowThreads();
39171 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39172
39173 wxPyEndAllowThreads(__tstate);
39174 if (PyErr_Occurred()) SWIG_fail;
39175 }
39176 {
39177 #if wxUSE_UNICODE
39178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39179 #else
39180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39181 #endif
39182 }
39183 return resultobj;
39184 fail:
39185 return NULL;
39186 }
39187
39188
39189 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39190 PyObject *resultobj = NULL;
39191 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39192 int arg2 ;
39193 PyObject * obj0 = 0 ;
39194 PyObject * obj1 = 0 ;
39195 char *kwnames[] = {
39196 (char *) "self",(char *) "n", NULL
39197 };
39198
39199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39201 if (SWIG_arg_fail(1)) SWIG_fail;
39202 {
39203 arg2 = static_cast<int >(SWIG_As_int(obj1));
39204 if (SWIG_arg_fail(2)) SWIG_fail;
39205 }
39206 {
39207 PyThreadState* __tstate = wxPyBeginAllowThreads();
39208 (arg1)->Select(arg2);
39209
39210 wxPyEndAllowThreads(__tstate);
39211 if (PyErr_Occurred()) SWIG_fail;
39212 }
39213 Py_INCREF(Py_None); resultobj = Py_None;
39214 return resultobj;
39215 fail:
39216 return NULL;
39217 }
39218
39219
39220 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39221 PyObject *obj;
39222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39223 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39224 Py_INCREF(obj);
39225 return Py_BuildValue((char *)"");
39226 }
39227 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39228 PyObject *obj;
39229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39230 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39231 Py_INCREF(obj);
39232 return Py_BuildValue((char *)"");
39233 }
39234 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39235 PyObject *resultobj = NULL;
39236 wxSizerItem *result;
39237 char *kwnames[] = {
39238 NULL
39239 };
39240
39241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39242 {
39243 PyThreadState* __tstate = wxPyBeginAllowThreads();
39244 result = (wxSizerItem *)new wxSizerItem();
39245
39246 wxPyEndAllowThreads(__tstate);
39247 if (PyErr_Occurred()) SWIG_fail;
39248 }
39249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39250 return resultobj;
39251 fail:
39252 return NULL;
39253 }
39254
39255
39256 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39257 PyObject *resultobj = NULL;
39258 wxWindow *arg1 = (wxWindow *) 0 ;
39259 int arg2 ;
39260 int arg3 ;
39261 int arg4 ;
39262 PyObject *arg5 = (PyObject *) NULL ;
39263 wxSizerItem *result;
39264 PyObject * obj0 = 0 ;
39265 PyObject * obj1 = 0 ;
39266 PyObject * obj2 = 0 ;
39267 PyObject * obj3 = 0 ;
39268 PyObject * obj4 = 0 ;
39269 char *kwnames[] = {
39270 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39271 };
39272
39273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39275 if (SWIG_arg_fail(1)) SWIG_fail;
39276 {
39277 arg2 = static_cast<int >(SWIG_As_int(obj1));
39278 if (SWIG_arg_fail(2)) SWIG_fail;
39279 }
39280 {
39281 arg3 = static_cast<int >(SWIG_As_int(obj2));
39282 if (SWIG_arg_fail(3)) SWIG_fail;
39283 }
39284 {
39285 arg4 = static_cast<int >(SWIG_As_int(obj3));
39286 if (SWIG_arg_fail(4)) SWIG_fail;
39287 }
39288 if (obj4) {
39289 arg5 = obj4;
39290 }
39291 {
39292 PyThreadState* __tstate = wxPyBeginAllowThreads();
39293 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39294
39295 wxPyEndAllowThreads(__tstate);
39296 if (PyErr_Occurred()) SWIG_fail;
39297 }
39298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39299 return resultobj;
39300 fail:
39301 return NULL;
39302 }
39303
39304
39305 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39306 PyObject *resultobj = NULL;
39307 int arg1 ;
39308 int arg2 ;
39309 int arg3 ;
39310 int arg4 ;
39311 int arg5 ;
39312 PyObject *arg6 = (PyObject *) NULL ;
39313 wxSizerItem *result;
39314 PyObject * obj0 = 0 ;
39315 PyObject * obj1 = 0 ;
39316 PyObject * obj2 = 0 ;
39317 PyObject * obj3 = 0 ;
39318 PyObject * obj4 = 0 ;
39319 PyObject * obj5 = 0 ;
39320 char *kwnames[] = {
39321 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39322 };
39323
39324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39325 {
39326 arg1 = static_cast<int >(SWIG_As_int(obj0));
39327 if (SWIG_arg_fail(1)) SWIG_fail;
39328 }
39329 {
39330 arg2 = static_cast<int >(SWIG_As_int(obj1));
39331 if (SWIG_arg_fail(2)) SWIG_fail;
39332 }
39333 {
39334 arg3 = static_cast<int >(SWIG_As_int(obj2));
39335 if (SWIG_arg_fail(3)) SWIG_fail;
39336 }
39337 {
39338 arg4 = static_cast<int >(SWIG_As_int(obj3));
39339 if (SWIG_arg_fail(4)) SWIG_fail;
39340 }
39341 {
39342 arg5 = static_cast<int >(SWIG_As_int(obj4));
39343 if (SWIG_arg_fail(5)) SWIG_fail;
39344 }
39345 if (obj5) {
39346 arg6 = obj5;
39347 }
39348 {
39349 PyThreadState* __tstate = wxPyBeginAllowThreads();
39350 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39351
39352 wxPyEndAllowThreads(__tstate);
39353 if (PyErr_Occurred()) SWIG_fail;
39354 }
39355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39356 return resultobj;
39357 fail:
39358 return NULL;
39359 }
39360
39361
39362 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39363 PyObject *resultobj = NULL;
39364 wxSizer *arg1 = (wxSizer *) 0 ;
39365 int arg2 ;
39366 int arg3 ;
39367 int arg4 ;
39368 PyObject *arg5 = (PyObject *) NULL ;
39369 wxSizerItem *result;
39370 PyObject * obj0 = 0 ;
39371 PyObject * obj1 = 0 ;
39372 PyObject * obj2 = 0 ;
39373 PyObject * obj3 = 0 ;
39374 PyObject * obj4 = 0 ;
39375 char *kwnames[] = {
39376 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39377 };
39378
39379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39381 if (SWIG_arg_fail(1)) SWIG_fail;
39382 {
39383 arg2 = static_cast<int >(SWIG_As_int(obj1));
39384 if (SWIG_arg_fail(2)) SWIG_fail;
39385 }
39386 {
39387 arg3 = static_cast<int >(SWIG_As_int(obj2));
39388 if (SWIG_arg_fail(3)) SWIG_fail;
39389 }
39390 {
39391 arg4 = static_cast<int >(SWIG_As_int(obj3));
39392 if (SWIG_arg_fail(4)) SWIG_fail;
39393 }
39394 if (obj4) {
39395 arg5 = obj4;
39396 }
39397 {
39398 PyThreadState* __tstate = wxPyBeginAllowThreads();
39399 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39400
39401 wxPyEndAllowThreads(__tstate);
39402 if (PyErr_Occurred()) SWIG_fail;
39403 }
39404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39405 return resultobj;
39406 fail:
39407 return NULL;
39408 }
39409
39410
39411 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39412 PyObject *resultobj = NULL;
39413 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39414 PyObject * obj0 = 0 ;
39415 char *kwnames[] = {
39416 (char *) "self", NULL
39417 };
39418
39419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39421 if (SWIG_arg_fail(1)) SWIG_fail;
39422 {
39423 PyThreadState* __tstate = wxPyBeginAllowThreads();
39424 (arg1)->DeleteWindows();
39425
39426 wxPyEndAllowThreads(__tstate);
39427 if (PyErr_Occurred()) SWIG_fail;
39428 }
39429 Py_INCREF(Py_None); resultobj = Py_None;
39430 return resultobj;
39431 fail:
39432 return NULL;
39433 }
39434
39435
39436 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39437 PyObject *resultobj = NULL;
39438 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39439 PyObject * obj0 = 0 ;
39440 char *kwnames[] = {
39441 (char *) "self", NULL
39442 };
39443
39444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39446 if (SWIG_arg_fail(1)) SWIG_fail;
39447 {
39448 PyThreadState* __tstate = wxPyBeginAllowThreads();
39449 (arg1)->DetachSizer();
39450
39451 wxPyEndAllowThreads(__tstate);
39452 if (PyErr_Occurred()) SWIG_fail;
39453 }
39454 Py_INCREF(Py_None); resultobj = Py_None;
39455 return resultobj;
39456 fail:
39457 return NULL;
39458 }
39459
39460
39461 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39462 PyObject *resultobj = NULL;
39463 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39464 wxSize result;
39465 PyObject * obj0 = 0 ;
39466 char *kwnames[] = {
39467 (char *) "self", NULL
39468 };
39469
39470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39472 if (SWIG_arg_fail(1)) SWIG_fail;
39473 {
39474 PyThreadState* __tstate = wxPyBeginAllowThreads();
39475 result = (arg1)->GetSize();
39476
39477 wxPyEndAllowThreads(__tstate);
39478 if (PyErr_Occurred()) SWIG_fail;
39479 }
39480 {
39481 wxSize * resultptr;
39482 resultptr = new wxSize(static_cast<wxSize & >(result));
39483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39484 }
39485 return resultobj;
39486 fail:
39487 return NULL;
39488 }
39489
39490
39491 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39492 PyObject *resultobj = NULL;
39493 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39494 wxSize result;
39495 PyObject * obj0 = 0 ;
39496 char *kwnames[] = {
39497 (char *) "self", NULL
39498 };
39499
39500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39502 if (SWIG_arg_fail(1)) SWIG_fail;
39503 {
39504 PyThreadState* __tstate = wxPyBeginAllowThreads();
39505 result = (arg1)->CalcMin();
39506
39507 wxPyEndAllowThreads(__tstate);
39508 if (PyErr_Occurred()) SWIG_fail;
39509 }
39510 {
39511 wxSize * resultptr;
39512 resultptr = new wxSize(static_cast<wxSize & >(result));
39513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39514 }
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39522 PyObject *resultobj = NULL;
39523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39524 wxPoint arg2 ;
39525 wxSize arg3 ;
39526 PyObject * obj0 = 0 ;
39527 PyObject * obj1 = 0 ;
39528 PyObject * obj2 = 0 ;
39529 char *kwnames[] = {
39530 (char *) "self",(char *) "pos",(char *) "size", NULL
39531 };
39532
39533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39535 if (SWIG_arg_fail(1)) SWIG_fail;
39536 {
39537 wxPoint * argp;
39538 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39539 if (SWIG_arg_fail(2)) SWIG_fail;
39540 if (argp == NULL) {
39541 SWIG_null_ref("wxPoint");
39542 }
39543 if (SWIG_arg_fail(2)) SWIG_fail;
39544 arg2 = *argp;
39545 }
39546 {
39547 wxSize * argp;
39548 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39549 if (SWIG_arg_fail(3)) SWIG_fail;
39550 if (argp == NULL) {
39551 SWIG_null_ref("wxSize");
39552 }
39553 if (SWIG_arg_fail(3)) SWIG_fail;
39554 arg3 = *argp;
39555 }
39556 {
39557 PyThreadState* __tstate = wxPyBeginAllowThreads();
39558 (arg1)->SetDimension(arg2,arg3);
39559
39560 wxPyEndAllowThreads(__tstate);
39561 if (PyErr_Occurred()) SWIG_fail;
39562 }
39563 Py_INCREF(Py_None); resultobj = Py_None;
39564 return resultobj;
39565 fail:
39566 return NULL;
39567 }
39568
39569
39570 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39571 PyObject *resultobj = NULL;
39572 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39573 wxSize result;
39574 PyObject * obj0 = 0 ;
39575 char *kwnames[] = {
39576 (char *) "self", NULL
39577 };
39578
39579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39581 if (SWIG_arg_fail(1)) SWIG_fail;
39582 {
39583 PyThreadState* __tstate = wxPyBeginAllowThreads();
39584 result = (arg1)->GetMinSize();
39585
39586 wxPyEndAllowThreads(__tstate);
39587 if (PyErr_Occurred()) SWIG_fail;
39588 }
39589 {
39590 wxSize * resultptr;
39591 resultptr = new wxSize(static_cast<wxSize & >(result));
39592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39593 }
39594 return resultobj;
39595 fail:
39596 return NULL;
39597 }
39598
39599
39600 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39601 PyObject *resultobj = NULL;
39602 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39603 wxSize result;
39604 PyObject * obj0 = 0 ;
39605 char *kwnames[] = {
39606 (char *) "self", NULL
39607 };
39608
39609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39611 if (SWIG_arg_fail(1)) SWIG_fail;
39612 {
39613 PyThreadState* __tstate = wxPyBeginAllowThreads();
39614 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39615
39616 wxPyEndAllowThreads(__tstate);
39617 if (PyErr_Occurred()) SWIG_fail;
39618 }
39619 {
39620 wxSize * resultptr;
39621 resultptr = new wxSize(static_cast<wxSize & >(result));
39622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39623 }
39624 return resultobj;
39625 fail:
39626 return NULL;
39627 }
39628
39629
39630 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39631 PyObject *resultobj = NULL;
39632 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39633 int arg2 ;
39634 int arg3 ;
39635 PyObject * obj0 = 0 ;
39636 PyObject * obj1 = 0 ;
39637 PyObject * obj2 = 0 ;
39638 char *kwnames[] = {
39639 (char *) "self",(char *) "x",(char *) "y", NULL
39640 };
39641
39642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39644 if (SWIG_arg_fail(1)) SWIG_fail;
39645 {
39646 arg2 = static_cast<int >(SWIG_As_int(obj1));
39647 if (SWIG_arg_fail(2)) SWIG_fail;
39648 }
39649 {
39650 arg3 = static_cast<int >(SWIG_As_int(obj2));
39651 if (SWIG_arg_fail(3)) SWIG_fail;
39652 }
39653 {
39654 PyThreadState* __tstate = wxPyBeginAllowThreads();
39655 (arg1)->SetInitSize(arg2,arg3);
39656
39657 wxPyEndAllowThreads(__tstate);
39658 if (PyErr_Occurred()) SWIG_fail;
39659 }
39660 Py_INCREF(Py_None); resultobj = Py_None;
39661 return resultobj;
39662 fail:
39663 return NULL;
39664 }
39665
39666
39667 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39668 PyObject *resultobj = NULL;
39669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39670 int arg2 ;
39671 int arg3 ;
39672 PyObject * obj0 = 0 ;
39673 PyObject * obj1 = 0 ;
39674 PyObject * obj2 = 0 ;
39675 char *kwnames[] = {
39676 (char *) "self",(char *) "width",(char *) "height", NULL
39677 };
39678
39679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39681 if (SWIG_arg_fail(1)) SWIG_fail;
39682 {
39683 arg2 = static_cast<int >(SWIG_As_int(obj1));
39684 if (SWIG_arg_fail(2)) SWIG_fail;
39685 }
39686 {
39687 arg3 = static_cast<int >(SWIG_As_int(obj2));
39688 if (SWIG_arg_fail(3)) SWIG_fail;
39689 }
39690 {
39691 PyThreadState* __tstate = wxPyBeginAllowThreads();
39692 (arg1)->SetRatio(arg2,arg3);
39693
39694 wxPyEndAllowThreads(__tstate);
39695 if (PyErr_Occurred()) SWIG_fail;
39696 }
39697 Py_INCREF(Py_None); resultobj = Py_None;
39698 return resultobj;
39699 fail:
39700 return NULL;
39701 }
39702
39703
39704 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39705 PyObject *resultobj = NULL;
39706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39707 wxSize *arg2 = 0 ;
39708 wxSize temp2 ;
39709 PyObject * obj0 = 0 ;
39710 PyObject * obj1 = 0 ;
39711 char *kwnames[] = {
39712 (char *) "self",(char *) "size", NULL
39713 };
39714
39715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39717 if (SWIG_arg_fail(1)) SWIG_fail;
39718 {
39719 arg2 = &temp2;
39720 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39721 }
39722 {
39723 PyThreadState* __tstate = wxPyBeginAllowThreads();
39724 (arg1)->SetRatio((wxSize const &)*arg2);
39725
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 Py_INCREF(Py_None); resultobj = Py_None;
39730 return resultobj;
39731 fail:
39732 return NULL;
39733 }
39734
39735
39736 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj = NULL;
39738 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39739 float arg2 ;
39740 PyObject * obj0 = 0 ;
39741 PyObject * obj1 = 0 ;
39742 char *kwnames[] = {
39743 (char *) "self",(char *) "ratio", NULL
39744 };
39745
39746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39748 if (SWIG_arg_fail(1)) SWIG_fail;
39749 {
39750 arg2 = static_cast<float >(SWIG_As_float(obj1));
39751 if (SWIG_arg_fail(2)) SWIG_fail;
39752 }
39753 {
39754 PyThreadState* __tstate = wxPyBeginAllowThreads();
39755 (arg1)->SetRatio(arg2);
39756
39757 wxPyEndAllowThreads(__tstate);
39758 if (PyErr_Occurred()) SWIG_fail;
39759 }
39760 Py_INCREF(Py_None); resultobj = Py_None;
39761 return resultobj;
39762 fail:
39763 return NULL;
39764 }
39765
39766
39767 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39768 PyObject *resultobj = NULL;
39769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39770 float result;
39771 PyObject * obj0 = 0 ;
39772 char *kwnames[] = {
39773 (char *) "self", NULL
39774 };
39775
39776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39778 if (SWIG_arg_fail(1)) SWIG_fail;
39779 {
39780 PyThreadState* __tstate = wxPyBeginAllowThreads();
39781 result = (float)(arg1)->GetRatio();
39782
39783 wxPyEndAllowThreads(__tstate);
39784 if (PyErr_Occurred()) SWIG_fail;
39785 }
39786 {
39787 resultobj = SWIG_From_float(static_cast<float >(result));
39788 }
39789 return resultobj;
39790 fail:
39791 return NULL;
39792 }
39793
39794
39795 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39796 PyObject *resultobj = NULL;
39797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39798 wxRect result;
39799 PyObject * obj0 = 0 ;
39800 char *kwnames[] = {
39801 (char *) "self", NULL
39802 };
39803
39804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39806 if (SWIG_arg_fail(1)) SWIG_fail;
39807 {
39808 PyThreadState* __tstate = wxPyBeginAllowThreads();
39809 result = (arg1)->GetRect();
39810
39811 wxPyEndAllowThreads(__tstate);
39812 if (PyErr_Occurred()) SWIG_fail;
39813 }
39814 {
39815 wxRect * resultptr;
39816 resultptr = new wxRect(static_cast<wxRect & >(result));
39817 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39818 }
39819 return resultobj;
39820 fail:
39821 return NULL;
39822 }
39823
39824
39825 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39826 PyObject *resultobj = NULL;
39827 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39828 bool result;
39829 PyObject * obj0 = 0 ;
39830 char *kwnames[] = {
39831 (char *) "self", NULL
39832 };
39833
39834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39836 if (SWIG_arg_fail(1)) SWIG_fail;
39837 {
39838 PyThreadState* __tstate = wxPyBeginAllowThreads();
39839 result = (bool)(arg1)->IsWindow();
39840
39841 wxPyEndAllowThreads(__tstate);
39842 if (PyErr_Occurred()) SWIG_fail;
39843 }
39844 {
39845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39846 }
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj = NULL;
39855 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39856 bool result;
39857 PyObject * obj0 = 0 ;
39858 char *kwnames[] = {
39859 (char *) "self", NULL
39860 };
39861
39862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39864 if (SWIG_arg_fail(1)) SWIG_fail;
39865 {
39866 PyThreadState* __tstate = wxPyBeginAllowThreads();
39867 result = (bool)(arg1)->IsSizer();
39868
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 {
39873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39874 }
39875 return resultobj;
39876 fail:
39877 return NULL;
39878 }
39879
39880
39881 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39882 PyObject *resultobj = NULL;
39883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39884 bool result;
39885 PyObject * obj0 = 0 ;
39886 char *kwnames[] = {
39887 (char *) "self", NULL
39888 };
39889
39890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39892 if (SWIG_arg_fail(1)) SWIG_fail;
39893 {
39894 PyThreadState* __tstate = wxPyBeginAllowThreads();
39895 result = (bool)(arg1)->IsSpacer();
39896
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 {
39901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39902 }
39903 return resultobj;
39904 fail:
39905 return NULL;
39906 }
39907
39908
39909 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39910 PyObject *resultobj = NULL;
39911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39912 int arg2 ;
39913 PyObject * obj0 = 0 ;
39914 PyObject * obj1 = 0 ;
39915 char *kwnames[] = {
39916 (char *) "self",(char *) "proportion", NULL
39917 };
39918
39919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39921 if (SWIG_arg_fail(1)) SWIG_fail;
39922 {
39923 arg2 = static_cast<int >(SWIG_As_int(obj1));
39924 if (SWIG_arg_fail(2)) SWIG_fail;
39925 }
39926 {
39927 PyThreadState* __tstate = wxPyBeginAllowThreads();
39928 (arg1)->SetProportion(arg2);
39929
39930 wxPyEndAllowThreads(__tstate);
39931 if (PyErr_Occurred()) SWIG_fail;
39932 }
39933 Py_INCREF(Py_None); resultobj = Py_None;
39934 return resultobj;
39935 fail:
39936 return NULL;
39937 }
39938
39939
39940 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39941 PyObject *resultobj = NULL;
39942 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39943 int result;
39944 PyObject * obj0 = 0 ;
39945 char *kwnames[] = {
39946 (char *) "self", NULL
39947 };
39948
39949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",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 = (int)(arg1)->GetProportion();
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 {
39960 resultobj = SWIG_From_int(static_cast<int >(result));
39961 }
39962 return resultobj;
39963 fail:
39964 return NULL;
39965 }
39966
39967
39968 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39969 PyObject *resultobj = NULL;
39970 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39971 int arg2 ;
39972 PyObject * obj0 = 0 ;
39973 PyObject * obj1 = 0 ;
39974 char *kwnames[] = {
39975 (char *) "self",(char *) "flag", NULL
39976 };
39977
39978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39980 if (SWIG_arg_fail(1)) SWIG_fail;
39981 {
39982 arg2 = static_cast<int >(SWIG_As_int(obj1));
39983 if (SWIG_arg_fail(2)) SWIG_fail;
39984 }
39985 {
39986 PyThreadState* __tstate = wxPyBeginAllowThreads();
39987 (arg1)->SetFlag(arg2);
39988
39989 wxPyEndAllowThreads(__tstate);
39990 if (PyErr_Occurred()) SWIG_fail;
39991 }
39992 Py_INCREF(Py_None); resultobj = Py_None;
39993 return resultobj;
39994 fail:
39995 return NULL;
39996 }
39997
39998
39999 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40000 PyObject *resultobj = NULL;
40001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40002 int result;
40003 PyObject * obj0 = 0 ;
40004 char *kwnames[] = {
40005 (char *) "self", NULL
40006 };
40007
40008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40010 if (SWIG_arg_fail(1)) SWIG_fail;
40011 {
40012 PyThreadState* __tstate = wxPyBeginAllowThreads();
40013 result = (int)(arg1)->GetFlag();
40014
40015 wxPyEndAllowThreads(__tstate);
40016 if (PyErr_Occurred()) SWIG_fail;
40017 }
40018 {
40019 resultobj = SWIG_From_int(static_cast<int >(result));
40020 }
40021 return resultobj;
40022 fail:
40023 return NULL;
40024 }
40025
40026
40027 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40028 PyObject *resultobj = NULL;
40029 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40030 int arg2 ;
40031 PyObject * obj0 = 0 ;
40032 PyObject * obj1 = 0 ;
40033 char *kwnames[] = {
40034 (char *) "self",(char *) "border", NULL
40035 };
40036
40037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40039 if (SWIG_arg_fail(1)) SWIG_fail;
40040 {
40041 arg2 = static_cast<int >(SWIG_As_int(obj1));
40042 if (SWIG_arg_fail(2)) SWIG_fail;
40043 }
40044 {
40045 PyThreadState* __tstate = wxPyBeginAllowThreads();
40046 (arg1)->SetBorder(arg2);
40047
40048 wxPyEndAllowThreads(__tstate);
40049 if (PyErr_Occurred()) SWIG_fail;
40050 }
40051 Py_INCREF(Py_None); resultobj = Py_None;
40052 return resultobj;
40053 fail:
40054 return NULL;
40055 }
40056
40057
40058 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40059 PyObject *resultobj = NULL;
40060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40061 int result;
40062 PyObject * obj0 = 0 ;
40063 char *kwnames[] = {
40064 (char *) "self", NULL
40065 };
40066
40067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40069 if (SWIG_arg_fail(1)) SWIG_fail;
40070 {
40071 PyThreadState* __tstate = wxPyBeginAllowThreads();
40072 result = (int)(arg1)->GetBorder();
40073
40074 wxPyEndAllowThreads(__tstate);
40075 if (PyErr_Occurred()) SWIG_fail;
40076 }
40077 {
40078 resultobj = SWIG_From_int(static_cast<int >(result));
40079 }
40080 return resultobj;
40081 fail:
40082 return NULL;
40083 }
40084
40085
40086 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40087 PyObject *resultobj = NULL;
40088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40089 wxWindow *result;
40090 PyObject * obj0 = 0 ;
40091 char *kwnames[] = {
40092 (char *) "self", NULL
40093 };
40094
40095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40097 if (SWIG_arg_fail(1)) SWIG_fail;
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 result = (wxWindow *)(arg1)->GetWindow();
40101
40102 wxPyEndAllowThreads(__tstate);
40103 if (PyErr_Occurred()) SWIG_fail;
40104 }
40105 {
40106 resultobj = wxPyMake_wxObject(result, 0);
40107 }
40108 return resultobj;
40109 fail:
40110 return NULL;
40111 }
40112
40113
40114 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40115 PyObject *resultobj = NULL;
40116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40117 wxWindow *arg2 = (wxWindow *) 0 ;
40118 PyObject * obj0 = 0 ;
40119 PyObject * obj1 = 0 ;
40120 char *kwnames[] = {
40121 (char *) "self",(char *) "window", NULL
40122 };
40123
40124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
40125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40126 if (SWIG_arg_fail(1)) SWIG_fail;
40127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40128 if (SWIG_arg_fail(2)) SWIG_fail;
40129 {
40130 PyThreadState* __tstate = wxPyBeginAllowThreads();
40131 (arg1)->SetWindow(arg2);
40132
40133 wxPyEndAllowThreads(__tstate);
40134 if (PyErr_Occurred()) SWIG_fail;
40135 }
40136 Py_INCREF(Py_None); resultobj = Py_None;
40137 return resultobj;
40138 fail:
40139 return NULL;
40140 }
40141
40142
40143 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40144 PyObject *resultobj = NULL;
40145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40146 wxSizer *result;
40147 PyObject * obj0 = 0 ;
40148 char *kwnames[] = {
40149 (char *) "self", NULL
40150 };
40151
40152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40154 if (SWIG_arg_fail(1)) SWIG_fail;
40155 {
40156 PyThreadState* __tstate = wxPyBeginAllowThreads();
40157 result = (wxSizer *)(arg1)->GetSizer();
40158
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 {
40163 resultobj = wxPyMake_wxObject(result, 0);
40164 }
40165 return resultobj;
40166 fail:
40167 return NULL;
40168 }
40169
40170
40171 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40172 PyObject *resultobj = NULL;
40173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40174 wxSizer *arg2 = (wxSizer *) 0 ;
40175 PyObject * obj0 = 0 ;
40176 PyObject * obj1 = 0 ;
40177 char *kwnames[] = {
40178 (char *) "self",(char *) "sizer", NULL
40179 };
40180
40181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40183 if (SWIG_arg_fail(1)) SWIG_fail;
40184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40185 if (SWIG_arg_fail(2)) SWIG_fail;
40186 {
40187 PyThreadState* __tstate = wxPyBeginAllowThreads();
40188 (arg1)->SetSizer(arg2);
40189
40190 wxPyEndAllowThreads(__tstate);
40191 if (PyErr_Occurred()) SWIG_fail;
40192 }
40193 Py_INCREF(Py_None); resultobj = Py_None;
40194 return resultobj;
40195 fail:
40196 return NULL;
40197 }
40198
40199
40200 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40201 PyObject *resultobj = NULL;
40202 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40203 wxSize *result;
40204 PyObject * obj0 = 0 ;
40205 char *kwnames[] = {
40206 (char *) "self", NULL
40207 };
40208
40209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40211 if (SWIG_arg_fail(1)) SWIG_fail;
40212 {
40213 PyThreadState* __tstate = wxPyBeginAllowThreads();
40214 {
40215 wxSize const &_result_ref = (arg1)->GetSpacer();
40216 result = (wxSize *) &_result_ref;
40217 }
40218
40219 wxPyEndAllowThreads(__tstate);
40220 if (PyErr_Occurred()) SWIG_fail;
40221 }
40222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40223 return resultobj;
40224 fail:
40225 return NULL;
40226 }
40227
40228
40229 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40230 PyObject *resultobj = NULL;
40231 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40232 wxSize *arg2 = 0 ;
40233 wxSize temp2 ;
40234 PyObject * obj0 = 0 ;
40235 PyObject * obj1 = 0 ;
40236 char *kwnames[] = {
40237 (char *) "self",(char *) "size", NULL
40238 };
40239
40240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
40245 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40246 }
40247 {
40248 PyThreadState* __tstate = wxPyBeginAllowThreads();
40249 (arg1)->SetSpacer((wxSize const &)*arg2);
40250
40251 wxPyEndAllowThreads(__tstate);
40252 if (PyErr_Occurred()) SWIG_fail;
40253 }
40254 Py_INCREF(Py_None); resultobj = Py_None;
40255 return resultobj;
40256 fail:
40257 return NULL;
40258 }
40259
40260
40261 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40262 PyObject *resultobj = NULL;
40263 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40264 bool arg2 ;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 char *kwnames[] = {
40268 (char *) "self",(char *) "show", NULL
40269 };
40270
40271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40273 if (SWIG_arg_fail(1)) SWIG_fail;
40274 {
40275 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40276 if (SWIG_arg_fail(2)) SWIG_fail;
40277 }
40278 {
40279 PyThreadState* __tstate = wxPyBeginAllowThreads();
40280 (arg1)->Show(arg2);
40281
40282 wxPyEndAllowThreads(__tstate);
40283 if (PyErr_Occurred()) SWIG_fail;
40284 }
40285 Py_INCREF(Py_None); resultobj = Py_None;
40286 return resultobj;
40287 fail:
40288 return NULL;
40289 }
40290
40291
40292 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40293 PyObject *resultobj = NULL;
40294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40295 bool result;
40296 PyObject * obj0 = 0 ;
40297 char *kwnames[] = {
40298 (char *) "self", NULL
40299 };
40300
40301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40303 if (SWIG_arg_fail(1)) SWIG_fail;
40304 {
40305 PyThreadState* __tstate = wxPyBeginAllowThreads();
40306 result = (bool)(arg1)->IsShown();
40307
40308 wxPyEndAllowThreads(__tstate);
40309 if (PyErr_Occurred()) SWIG_fail;
40310 }
40311 {
40312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40313 }
40314 return resultobj;
40315 fail:
40316 return NULL;
40317 }
40318
40319
40320 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40321 PyObject *resultobj = NULL;
40322 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40323 wxPoint result;
40324 PyObject * obj0 = 0 ;
40325 char *kwnames[] = {
40326 (char *) "self", NULL
40327 };
40328
40329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40331 if (SWIG_arg_fail(1)) SWIG_fail;
40332 {
40333 PyThreadState* __tstate = wxPyBeginAllowThreads();
40334 result = (arg1)->GetPosition();
40335
40336 wxPyEndAllowThreads(__tstate);
40337 if (PyErr_Occurred()) SWIG_fail;
40338 }
40339 {
40340 wxPoint * resultptr;
40341 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40342 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40343 }
40344 return resultobj;
40345 fail:
40346 return NULL;
40347 }
40348
40349
40350 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40351 PyObject *resultobj = NULL;
40352 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40353 PyObject *result;
40354 PyObject * obj0 = 0 ;
40355 char *kwnames[] = {
40356 (char *) "self", NULL
40357 };
40358
40359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40361 if (SWIG_arg_fail(1)) SWIG_fail;
40362 {
40363 PyThreadState* __tstate = wxPyBeginAllowThreads();
40364 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40365
40366 wxPyEndAllowThreads(__tstate);
40367 if (PyErr_Occurred()) SWIG_fail;
40368 }
40369 resultobj = result;
40370 return resultobj;
40371 fail:
40372 return NULL;
40373 }
40374
40375
40376 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40377 PyObject *resultobj = NULL;
40378 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40379 PyObject *arg2 = (PyObject *) 0 ;
40380 PyObject * obj0 = 0 ;
40381 PyObject * obj1 = 0 ;
40382 char *kwnames[] = {
40383 (char *) "self",(char *) "userData", NULL
40384 };
40385
40386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40388 if (SWIG_arg_fail(1)) SWIG_fail;
40389 arg2 = obj1;
40390 {
40391 PyThreadState* __tstate = wxPyBeginAllowThreads();
40392 wxSizerItem_SetUserData(arg1,arg2);
40393
40394 wxPyEndAllowThreads(__tstate);
40395 if (PyErr_Occurred()) SWIG_fail;
40396 }
40397 Py_INCREF(Py_None); resultobj = Py_None;
40398 return resultobj;
40399 fail:
40400 return NULL;
40401 }
40402
40403
40404 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40405 PyObject *obj;
40406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40407 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40408 Py_INCREF(obj);
40409 return Py_BuildValue((char *)"");
40410 }
40411 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40412 PyObject *resultobj = NULL;
40413 wxSizer *arg1 = (wxSizer *) 0 ;
40414 PyObject *arg2 = (PyObject *) 0 ;
40415 PyObject * obj0 = 0 ;
40416 PyObject * obj1 = 0 ;
40417 char *kwnames[] = {
40418 (char *) "self",(char *) "_self", NULL
40419 };
40420
40421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40423 if (SWIG_arg_fail(1)) SWIG_fail;
40424 arg2 = obj1;
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 wxSizer__setOORInfo(arg1,arg2);
40428
40429 wxPyEndAllowThreads(__tstate);
40430 if (PyErr_Occurred()) SWIG_fail;
40431 }
40432 Py_INCREF(Py_None); resultobj = Py_None;
40433 return resultobj;
40434 fail:
40435 return NULL;
40436 }
40437
40438
40439 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40440 PyObject *resultobj = NULL;
40441 wxSizer *arg1 = (wxSizer *) 0 ;
40442 PyObject *arg2 = (PyObject *) 0 ;
40443 int arg3 = (int) 0 ;
40444 int arg4 = (int) 0 ;
40445 int arg5 = (int) 0 ;
40446 PyObject *arg6 = (PyObject *) NULL ;
40447 wxSizerItem *result;
40448 PyObject * obj0 = 0 ;
40449 PyObject * obj1 = 0 ;
40450 PyObject * obj2 = 0 ;
40451 PyObject * obj3 = 0 ;
40452 PyObject * obj4 = 0 ;
40453 PyObject * obj5 = 0 ;
40454 char *kwnames[] = {
40455 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40456 };
40457
40458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40460 if (SWIG_arg_fail(1)) SWIG_fail;
40461 arg2 = obj1;
40462 if (obj2) {
40463 {
40464 arg3 = static_cast<int >(SWIG_As_int(obj2));
40465 if (SWIG_arg_fail(3)) SWIG_fail;
40466 }
40467 }
40468 if (obj3) {
40469 {
40470 arg4 = static_cast<int >(SWIG_As_int(obj3));
40471 if (SWIG_arg_fail(4)) SWIG_fail;
40472 }
40473 }
40474 if (obj4) {
40475 {
40476 arg5 = static_cast<int >(SWIG_As_int(obj4));
40477 if (SWIG_arg_fail(5)) SWIG_fail;
40478 }
40479 }
40480 if (obj5) {
40481 arg6 = obj5;
40482 }
40483 {
40484 PyThreadState* __tstate = wxPyBeginAllowThreads();
40485 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40486
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40491 return resultobj;
40492 fail:
40493 return NULL;
40494 }
40495
40496
40497 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj = NULL;
40499 wxSizer *arg1 = (wxSizer *) 0 ;
40500 int arg2 ;
40501 PyObject *arg3 = (PyObject *) 0 ;
40502 int arg4 = (int) 0 ;
40503 int arg5 = (int) 0 ;
40504 int arg6 = (int) 0 ;
40505 PyObject *arg7 = (PyObject *) NULL ;
40506 wxSizerItem *result;
40507 PyObject * obj0 = 0 ;
40508 PyObject * obj1 = 0 ;
40509 PyObject * obj2 = 0 ;
40510 PyObject * obj3 = 0 ;
40511 PyObject * obj4 = 0 ;
40512 PyObject * obj5 = 0 ;
40513 PyObject * obj6 = 0 ;
40514 char *kwnames[] = {
40515 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40516 };
40517
40518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40520 if (SWIG_arg_fail(1)) SWIG_fail;
40521 {
40522 arg2 = static_cast<int >(SWIG_As_int(obj1));
40523 if (SWIG_arg_fail(2)) SWIG_fail;
40524 }
40525 arg3 = obj2;
40526 if (obj3) {
40527 {
40528 arg4 = static_cast<int >(SWIG_As_int(obj3));
40529 if (SWIG_arg_fail(4)) SWIG_fail;
40530 }
40531 }
40532 if (obj4) {
40533 {
40534 arg5 = static_cast<int >(SWIG_As_int(obj4));
40535 if (SWIG_arg_fail(5)) SWIG_fail;
40536 }
40537 }
40538 if (obj5) {
40539 {
40540 arg6 = static_cast<int >(SWIG_As_int(obj5));
40541 if (SWIG_arg_fail(6)) SWIG_fail;
40542 }
40543 }
40544 if (obj6) {
40545 arg7 = obj6;
40546 }
40547 {
40548 PyThreadState* __tstate = wxPyBeginAllowThreads();
40549 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40550
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40562 PyObject *resultobj = NULL;
40563 wxSizer *arg1 = (wxSizer *) 0 ;
40564 PyObject *arg2 = (PyObject *) 0 ;
40565 int arg3 = (int) 0 ;
40566 int arg4 = (int) 0 ;
40567 int arg5 = (int) 0 ;
40568 PyObject *arg6 = (PyObject *) NULL ;
40569 wxSizerItem *result;
40570 PyObject * obj0 = 0 ;
40571 PyObject * obj1 = 0 ;
40572 PyObject * obj2 = 0 ;
40573 PyObject * obj3 = 0 ;
40574 PyObject * obj4 = 0 ;
40575 PyObject * obj5 = 0 ;
40576 char *kwnames[] = {
40577 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40578 };
40579
40580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40582 if (SWIG_arg_fail(1)) SWIG_fail;
40583 arg2 = obj1;
40584 if (obj2) {
40585 {
40586 arg3 = static_cast<int >(SWIG_As_int(obj2));
40587 if (SWIG_arg_fail(3)) SWIG_fail;
40588 }
40589 }
40590 if (obj3) {
40591 {
40592 arg4 = static_cast<int >(SWIG_As_int(obj3));
40593 if (SWIG_arg_fail(4)) SWIG_fail;
40594 }
40595 }
40596 if (obj4) {
40597 {
40598 arg5 = static_cast<int >(SWIG_As_int(obj4));
40599 if (SWIG_arg_fail(5)) SWIG_fail;
40600 }
40601 }
40602 if (obj5) {
40603 arg6 = obj5;
40604 }
40605 {
40606 PyThreadState* __tstate = wxPyBeginAllowThreads();
40607 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40608
40609 wxPyEndAllowThreads(__tstate);
40610 if (PyErr_Occurred()) SWIG_fail;
40611 }
40612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40613 return resultobj;
40614 fail:
40615 return NULL;
40616 }
40617
40618
40619 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40620 PyObject *resultobj = NULL;
40621 wxSizer *arg1 = (wxSizer *) 0 ;
40622 PyObject *arg2 = (PyObject *) 0 ;
40623 bool result;
40624 PyObject * obj0 = 0 ;
40625 PyObject * obj1 = 0 ;
40626 char *kwnames[] = {
40627 (char *) "self",(char *) "item", NULL
40628 };
40629
40630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40632 if (SWIG_arg_fail(1)) SWIG_fail;
40633 arg2 = obj1;
40634 {
40635 PyThreadState* __tstate = wxPyBeginAllowThreads();
40636 result = (bool)wxSizer_Remove(arg1,arg2);
40637
40638 wxPyEndAllowThreads(__tstate);
40639 if (PyErr_Occurred()) SWIG_fail;
40640 }
40641 {
40642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40643 }
40644 return resultobj;
40645 fail:
40646 return NULL;
40647 }
40648
40649
40650 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40651 PyObject *resultobj = NULL;
40652 wxSizer *arg1 = (wxSizer *) 0 ;
40653 PyObject *arg2 = (PyObject *) 0 ;
40654 bool result;
40655 PyObject * obj0 = 0 ;
40656 PyObject * obj1 = 0 ;
40657 char *kwnames[] = {
40658 (char *) "self",(char *) "item", NULL
40659 };
40660
40661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40663 if (SWIG_arg_fail(1)) SWIG_fail;
40664 arg2 = obj1;
40665 {
40666 PyThreadState* __tstate = wxPyBeginAllowThreads();
40667 result = (bool)wxSizer_Detach(arg1,arg2);
40668
40669 wxPyEndAllowThreads(__tstate);
40670 if (PyErr_Occurred()) SWIG_fail;
40671 }
40672 {
40673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40674 }
40675 return resultobj;
40676 fail:
40677 return NULL;
40678 }
40679
40680
40681 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40682 PyObject *resultobj = NULL;
40683 wxSizer *arg1 = (wxSizer *) 0 ;
40684 PyObject *arg2 = (PyObject *) 0 ;
40685 wxSizerItem *result;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 char *kwnames[] = {
40689 (char *) "self",(char *) "item", NULL
40690 };
40691
40692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40694 if (SWIG_arg_fail(1)) SWIG_fail;
40695 arg2 = obj1;
40696 {
40697 PyThreadState* __tstate = wxPyBeginAllowThreads();
40698 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40699
40700 wxPyEndAllowThreads(__tstate);
40701 if (PyErr_Occurred()) SWIG_fail;
40702 }
40703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40704 return resultobj;
40705 fail:
40706 return NULL;
40707 }
40708
40709
40710 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40711 PyObject *resultobj = NULL;
40712 wxSizer *arg1 = (wxSizer *) 0 ;
40713 PyObject *arg2 = (PyObject *) 0 ;
40714 wxSize *arg3 = 0 ;
40715 wxSize temp3 ;
40716 PyObject * obj0 = 0 ;
40717 PyObject * obj1 = 0 ;
40718 PyObject * obj2 = 0 ;
40719 char *kwnames[] = {
40720 (char *) "self",(char *) "item",(char *) "size", NULL
40721 };
40722
40723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40725 if (SWIG_arg_fail(1)) SWIG_fail;
40726 arg2 = obj1;
40727 {
40728 arg3 = &temp3;
40729 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40730 }
40731 {
40732 PyThreadState* __tstate = wxPyBeginAllowThreads();
40733 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40734
40735 wxPyEndAllowThreads(__tstate);
40736 if (PyErr_Occurred()) SWIG_fail;
40737 }
40738 Py_INCREF(Py_None); resultobj = Py_None;
40739 return resultobj;
40740 fail:
40741 return NULL;
40742 }
40743
40744
40745 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40746 PyObject *resultobj = NULL;
40747 wxSizer *arg1 = (wxSizer *) 0 ;
40748 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40749 wxSizerItem *result;
40750 PyObject * obj0 = 0 ;
40751 PyObject * obj1 = 0 ;
40752 char *kwnames[] = {
40753 (char *) "self",(char *) "item", NULL
40754 };
40755
40756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40758 if (SWIG_arg_fail(1)) SWIG_fail;
40759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40760 if (SWIG_arg_fail(2)) SWIG_fail;
40761 {
40762 PyThreadState* __tstate = wxPyBeginAllowThreads();
40763 result = (wxSizerItem *)(arg1)->Add(arg2);
40764
40765 wxPyEndAllowThreads(__tstate);
40766 if (PyErr_Occurred()) SWIG_fail;
40767 }
40768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40769 return resultobj;
40770 fail:
40771 return NULL;
40772 }
40773
40774
40775 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40776 PyObject *resultobj = NULL;
40777 wxSizer *arg1 = (wxSizer *) 0 ;
40778 size_t arg2 ;
40779 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40780 wxSizerItem *result;
40781 PyObject * obj0 = 0 ;
40782 PyObject * obj1 = 0 ;
40783 PyObject * obj2 = 0 ;
40784 char *kwnames[] = {
40785 (char *) "self",(char *) "index",(char *) "item", NULL
40786 };
40787
40788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40790 if (SWIG_arg_fail(1)) SWIG_fail;
40791 {
40792 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40793 if (SWIG_arg_fail(2)) SWIG_fail;
40794 }
40795 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40796 if (SWIG_arg_fail(3)) SWIG_fail;
40797 {
40798 PyThreadState* __tstate = wxPyBeginAllowThreads();
40799 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40800
40801 wxPyEndAllowThreads(__tstate);
40802 if (PyErr_Occurred()) SWIG_fail;
40803 }
40804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40805 return resultobj;
40806 fail:
40807 return NULL;
40808 }
40809
40810
40811 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40812 PyObject *resultobj = NULL;
40813 wxSizer *arg1 = (wxSizer *) 0 ;
40814 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40815 wxSizerItem *result;
40816 PyObject * obj0 = 0 ;
40817 PyObject * obj1 = 0 ;
40818 char *kwnames[] = {
40819 (char *) "self",(char *) "item", NULL
40820 };
40821
40822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40824 if (SWIG_arg_fail(1)) SWIG_fail;
40825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40826 if (SWIG_arg_fail(2)) SWIG_fail;
40827 {
40828 PyThreadState* __tstate = wxPyBeginAllowThreads();
40829 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40830
40831 wxPyEndAllowThreads(__tstate);
40832 if (PyErr_Occurred()) SWIG_fail;
40833 }
40834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40835 return resultobj;
40836 fail:
40837 return NULL;
40838 }
40839
40840
40841 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40842 PyObject *resultobj = NULL;
40843 wxSizer *arg1 = (wxSizer *) 0 ;
40844 int arg2 ;
40845 int arg3 ;
40846 int arg4 ;
40847 int arg5 ;
40848 PyObject * obj0 = 0 ;
40849 PyObject * obj1 = 0 ;
40850 PyObject * obj2 = 0 ;
40851 PyObject * obj3 = 0 ;
40852 PyObject * obj4 = 0 ;
40853 char *kwnames[] = {
40854 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40855 };
40856
40857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40859 if (SWIG_arg_fail(1)) SWIG_fail;
40860 {
40861 arg2 = static_cast<int >(SWIG_As_int(obj1));
40862 if (SWIG_arg_fail(2)) SWIG_fail;
40863 }
40864 {
40865 arg3 = static_cast<int >(SWIG_As_int(obj2));
40866 if (SWIG_arg_fail(3)) SWIG_fail;
40867 }
40868 {
40869 arg4 = static_cast<int >(SWIG_As_int(obj3));
40870 if (SWIG_arg_fail(4)) SWIG_fail;
40871 }
40872 {
40873 arg5 = static_cast<int >(SWIG_As_int(obj4));
40874 if (SWIG_arg_fail(5)) SWIG_fail;
40875 }
40876 {
40877 PyThreadState* __tstate = wxPyBeginAllowThreads();
40878 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40879
40880 wxPyEndAllowThreads(__tstate);
40881 if (PyErr_Occurred()) SWIG_fail;
40882 }
40883 Py_INCREF(Py_None); resultobj = Py_None;
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40891 PyObject *resultobj = NULL;
40892 wxSizer *arg1 = (wxSizer *) 0 ;
40893 wxSize *arg2 = 0 ;
40894 wxSize temp2 ;
40895 PyObject * obj0 = 0 ;
40896 PyObject * obj1 = 0 ;
40897 char *kwnames[] = {
40898 (char *) "self",(char *) "size", NULL
40899 };
40900
40901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40903 if (SWIG_arg_fail(1)) SWIG_fail;
40904 {
40905 arg2 = &temp2;
40906 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40907 }
40908 {
40909 PyThreadState* __tstate = wxPyBeginAllowThreads();
40910 (arg1)->SetMinSize((wxSize const &)*arg2);
40911
40912 wxPyEndAllowThreads(__tstate);
40913 if (PyErr_Occurred()) SWIG_fail;
40914 }
40915 Py_INCREF(Py_None); resultobj = Py_None;
40916 return resultobj;
40917 fail:
40918 return NULL;
40919 }
40920
40921
40922 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40923 PyObject *resultobj = NULL;
40924 wxSizer *arg1 = (wxSizer *) 0 ;
40925 wxSize result;
40926 PyObject * obj0 = 0 ;
40927 char *kwnames[] = {
40928 (char *) "self", NULL
40929 };
40930
40931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40933 if (SWIG_arg_fail(1)) SWIG_fail;
40934 {
40935 PyThreadState* __tstate = wxPyBeginAllowThreads();
40936 result = (arg1)->GetSize();
40937
40938 wxPyEndAllowThreads(__tstate);
40939 if (PyErr_Occurred()) SWIG_fail;
40940 }
40941 {
40942 wxSize * resultptr;
40943 resultptr = new wxSize(static_cast<wxSize & >(result));
40944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40945 }
40946 return resultobj;
40947 fail:
40948 return NULL;
40949 }
40950
40951
40952 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40953 PyObject *resultobj = NULL;
40954 wxSizer *arg1 = (wxSizer *) 0 ;
40955 wxPoint result;
40956 PyObject * obj0 = 0 ;
40957 char *kwnames[] = {
40958 (char *) "self", NULL
40959 };
40960
40961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40963 if (SWIG_arg_fail(1)) SWIG_fail;
40964 {
40965 PyThreadState* __tstate = wxPyBeginAllowThreads();
40966 result = (arg1)->GetPosition();
40967
40968 wxPyEndAllowThreads(__tstate);
40969 if (PyErr_Occurred()) SWIG_fail;
40970 }
40971 {
40972 wxPoint * resultptr;
40973 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40975 }
40976 return resultobj;
40977 fail:
40978 return NULL;
40979 }
40980
40981
40982 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40983 PyObject *resultobj = NULL;
40984 wxSizer *arg1 = (wxSizer *) 0 ;
40985 wxSize result;
40986 PyObject * obj0 = 0 ;
40987 char *kwnames[] = {
40988 (char *) "self", NULL
40989 };
40990
40991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40993 if (SWIG_arg_fail(1)) SWIG_fail;
40994 {
40995 PyThreadState* __tstate = wxPyBeginAllowThreads();
40996 result = (arg1)->GetMinSize();
40997
40998 wxPyEndAllowThreads(__tstate);
40999 if (PyErr_Occurred()) SWIG_fail;
41000 }
41001 {
41002 wxSize * resultptr;
41003 resultptr = new wxSize(static_cast<wxSize & >(result));
41004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41005 }
41006 return resultobj;
41007 fail:
41008 return NULL;
41009 }
41010
41011
41012 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41013 PyObject *resultobj = NULL;
41014 wxSizer *arg1 = (wxSizer *) 0 ;
41015 PyObject * obj0 = 0 ;
41016 char *kwnames[] = {
41017 (char *) "self", NULL
41018 };
41019
41020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41022 if (SWIG_arg_fail(1)) SWIG_fail;
41023 {
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 (arg1)->RecalcSizes();
41026
41027 wxPyEndAllowThreads(__tstate);
41028 if (PyErr_Occurred()) SWIG_fail;
41029 }
41030 Py_INCREF(Py_None); resultobj = Py_None;
41031 return resultobj;
41032 fail:
41033 return NULL;
41034 }
41035
41036
41037 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41038 PyObject *resultobj = NULL;
41039 wxSizer *arg1 = (wxSizer *) 0 ;
41040 wxSize result;
41041 PyObject * obj0 = 0 ;
41042 char *kwnames[] = {
41043 (char *) "self", NULL
41044 };
41045
41046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41048 if (SWIG_arg_fail(1)) SWIG_fail;
41049 {
41050 PyThreadState* __tstate = wxPyBeginAllowThreads();
41051 result = (arg1)->CalcMin();
41052
41053 wxPyEndAllowThreads(__tstate);
41054 if (PyErr_Occurred()) SWIG_fail;
41055 }
41056 {
41057 wxSize * resultptr;
41058 resultptr = new wxSize(static_cast<wxSize & >(result));
41059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41060 }
41061 return resultobj;
41062 fail:
41063 return NULL;
41064 }
41065
41066
41067 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41068 PyObject *resultobj = NULL;
41069 wxSizer *arg1 = (wxSizer *) 0 ;
41070 PyObject * obj0 = 0 ;
41071 char *kwnames[] = {
41072 (char *) "self", NULL
41073 };
41074
41075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41077 if (SWIG_arg_fail(1)) SWIG_fail;
41078 {
41079 PyThreadState* __tstate = wxPyBeginAllowThreads();
41080 (arg1)->Layout();
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_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41093 PyObject *resultobj = NULL;
41094 wxSizer *arg1 = (wxSizer *) 0 ;
41095 wxWindow *arg2 = (wxWindow *) 0 ;
41096 wxSize result;
41097 PyObject * obj0 = 0 ;
41098 PyObject * obj1 = 0 ;
41099 char *kwnames[] = {
41100 (char *) "self",(char *) "window", NULL
41101 };
41102
41103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41105 if (SWIG_arg_fail(1)) SWIG_fail;
41106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41107 if (SWIG_arg_fail(2)) SWIG_fail;
41108 {
41109 PyThreadState* __tstate = wxPyBeginAllowThreads();
41110 result = (arg1)->Fit(arg2);
41111
41112 wxPyEndAllowThreads(__tstate);
41113 if (PyErr_Occurred()) SWIG_fail;
41114 }
41115 {
41116 wxSize * resultptr;
41117 resultptr = new wxSize(static_cast<wxSize & >(result));
41118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41119 }
41120 return resultobj;
41121 fail:
41122 return NULL;
41123 }
41124
41125
41126 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41127 PyObject *resultobj = NULL;
41128 wxSizer *arg1 = (wxSizer *) 0 ;
41129 wxWindow *arg2 = (wxWindow *) 0 ;
41130 PyObject * obj0 = 0 ;
41131 PyObject * obj1 = 0 ;
41132 char *kwnames[] = {
41133 (char *) "self",(char *) "window", NULL
41134 };
41135
41136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41138 if (SWIG_arg_fail(1)) SWIG_fail;
41139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41140 if (SWIG_arg_fail(2)) SWIG_fail;
41141 {
41142 PyThreadState* __tstate = wxPyBeginAllowThreads();
41143 (arg1)->FitInside(arg2);
41144
41145 wxPyEndAllowThreads(__tstate);
41146 if (PyErr_Occurred()) SWIG_fail;
41147 }
41148 Py_INCREF(Py_None); resultobj = Py_None;
41149 return resultobj;
41150 fail:
41151 return NULL;
41152 }
41153
41154
41155 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41156 PyObject *resultobj = NULL;
41157 wxSizer *arg1 = (wxSizer *) 0 ;
41158 wxWindow *arg2 = (wxWindow *) 0 ;
41159 PyObject * obj0 = 0 ;
41160 PyObject * obj1 = 0 ;
41161 char *kwnames[] = {
41162 (char *) "self",(char *) "window", NULL
41163 };
41164
41165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41167 if (SWIG_arg_fail(1)) SWIG_fail;
41168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41169 if (SWIG_arg_fail(2)) SWIG_fail;
41170 {
41171 PyThreadState* __tstate = wxPyBeginAllowThreads();
41172 (arg1)->SetSizeHints(arg2);
41173
41174 wxPyEndAllowThreads(__tstate);
41175 if (PyErr_Occurred()) SWIG_fail;
41176 }
41177 Py_INCREF(Py_None); resultobj = Py_None;
41178 return resultobj;
41179 fail:
41180 return NULL;
41181 }
41182
41183
41184 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41185 PyObject *resultobj = NULL;
41186 wxSizer *arg1 = (wxSizer *) 0 ;
41187 wxWindow *arg2 = (wxWindow *) 0 ;
41188 PyObject * obj0 = 0 ;
41189 PyObject * obj1 = 0 ;
41190 char *kwnames[] = {
41191 (char *) "self",(char *) "window", NULL
41192 };
41193
41194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41196 if (SWIG_arg_fail(1)) SWIG_fail;
41197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41198 if (SWIG_arg_fail(2)) SWIG_fail;
41199 {
41200 PyThreadState* __tstate = wxPyBeginAllowThreads();
41201 (arg1)->SetVirtualSizeHints(arg2);
41202
41203 wxPyEndAllowThreads(__tstate);
41204 if (PyErr_Occurred()) SWIG_fail;
41205 }
41206 Py_INCREF(Py_None); resultobj = Py_None;
41207 return resultobj;
41208 fail:
41209 return NULL;
41210 }
41211
41212
41213 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41214 PyObject *resultobj = NULL;
41215 wxSizer *arg1 = (wxSizer *) 0 ;
41216 bool arg2 = (bool) false ;
41217 PyObject * obj0 = 0 ;
41218 PyObject * obj1 = 0 ;
41219 char *kwnames[] = {
41220 (char *) "self",(char *) "deleteWindows", NULL
41221 };
41222
41223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41225 if (SWIG_arg_fail(1)) SWIG_fail;
41226 if (obj1) {
41227 {
41228 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41229 if (SWIG_arg_fail(2)) SWIG_fail;
41230 }
41231 }
41232 {
41233 PyThreadState* __tstate = wxPyBeginAllowThreads();
41234 (arg1)->Clear(arg2);
41235
41236 wxPyEndAllowThreads(__tstate);
41237 if (PyErr_Occurred()) SWIG_fail;
41238 }
41239 Py_INCREF(Py_None); resultobj = Py_None;
41240 return resultobj;
41241 fail:
41242 return NULL;
41243 }
41244
41245
41246 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41247 PyObject *resultobj = NULL;
41248 wxSizer *arg1 = (wxSizer *) 0 ;
41249 PyObject * obj0 = 0 ;
41250 char *kwnames[] = {
41251 (char *) "self", NULL
41252 };
41253
41254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41256 if (SWIG_arg_fail(1)) SWIG_fail;
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 (arg1)->DeleteWindows();
41260
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 Py_INCREF(Py_None); resultobj = Py_None;
41265 return resultobj;
41266 fail:
41267 return NULL;
41268 }
41269
41270
41271 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41272 PyObject *resultobj = NULL;
41273 wxSizer *arg1 = (wxSizer *) 0 ;
41274 PyObject *result;
41275 PyObject * obj0 = 0 ;
41276 char *kwnames[] = {
41277 (char *) "self", NULL
41278 };
41279
41280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41282 if (SWIG_arg_fail(1)) SWIG_fail;
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 result = (PyObject *)wxSizer_GetChildren(arg1);
41286
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 resultobj = result;
41291 return resultobj;
41292 fail:
41293 return NULL;
41294 }
41295
41296
41297 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41298 PyObject *resultobj = NULL;
41299 wxSizer *arg1 = (wxSizer *) 0 ;
41300 PyObject *arg2 = (PyObject *) 0 ;
41301 bool arg3 = (bool) true ;
41302 bool arg4 = (bool) false ;
41303 bool result;
41304 PyObject * obj0 = 0 ;
41305 PyObject * obj1 = 0 ;
41306 PyObject * obj2 = 0 ;
41307 PyObject * obj3 = 0 ;
41308 char *kwnames[] = {
41309 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41310 };
41311
41312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41314 if (SWIG_arg_fail(1)) SWIG_fail;
41315 arg2 = obj1;
41316 if (obj2) {
41317 {
41318 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41319 if (SWIG_arg_fail(3)) SWIG_fail;
41320 }
41321 }
41322 if (obj3) {
41323 {
41324 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41325 if (SWIG_arg_fail(4)) SWIG_fail;
41326 }
41327 }
41328 {
41329 PyThreadState* __tstate = wxPyBeginAllowThreads();
41330 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41331
41332 wxPyEndAllowThreads(__tstate);
41333 if (PyErr_Occurred()) SWIG_fail;
41334 }
41335 {
41336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41337 }
41338 return resultobj;
41339 fail:
41340 return NULL;
41341 }
41342
41343
41344 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41345 PyObject *resultobj = NULL;
41346 wxSizer *arg1 = (wxSizer *) 0 ;
41347 PyObject *arg2 = (PyObject *) 0 ;
41348 bool result;
41349 PyObject * obj0 = 0 ;
41350 PyObject * obj1 = 0 ;
41351 char *kwnames[] = {
41352 (char *) "self",(char *) "item", NULL
41353 };
41354
41355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41357 if (SWIG_arg_fail(1)) SWIG_fail;
41358 arg2 = obj1;
41359 {
41360 PyThreadState* __tstate = wxPyBeginAllowThreads();
41361 result = (bool)wxSizer_IsShown(arg1,arg2);
41362
41363 wxPyEndAllowThreads(__tstate);
41364 if (PyErr_Occurred()) SWIG_fail;
41365 }
41366 {
41367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41368 }
41369 return resultobj;
41370 fail:
41371 return NULL;
41372 }
41373
41374
41375 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41376 PyObject *resultobj = NULL;
41377 wxSizer *arg1 = (wxSizer *) 0 ;
41378 bool arg2 ;
41379 PyObject * obj0 = 0 ;
41380 PyObject * obj1 = 0 ;
41381 char *kwnames[] = {
41382 (char *) "self",(char *) "show", NULL
41383 };
41384
41385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41387 if (SWIG_arg_fail(1)) SWIG_fail;
41388 {
41389 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41390 if (SWIG_arg_fail(2)) SWIG_fail;
41391 }
41392 {
41393 PyThreadState* __tstate = wxPyBeginAllowThreads();
41394 (arg1)->ShowItems(arg2);
41395
41396 wxPyEndAllowThreads(__tstate);
41397 if (PyErr_Occurred()) SWIG_fail;
41398 }
41399 Py_INCREF(Py_None); resultobj = Py_None;
41400 return resultobj;
41401 fail:
41402 return NULL;
41403 }
41404
41405
41406 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41407 PyObject *obj;
41408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41409 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41410 Py_INCREF(obj);
41411 return Py_BuildValue((char *)"");
41412 }
41413 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41414 PyObject *resultobj = NULL;
41415 wxPySizer *result;
41416 char *kwnames[] = {
41417 NULL
41418 };
41419
41420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41421 {
41422 PyThreadState* __tstate = wxPyBeginAllowThreads();
41423 result = (wxPySizer *)new wxPySizer();
41424
41425 wxPyEndAllowThreads(__tstate);
41426 if (PyErr_Occurred()) SWIG_fail;
41427 }
41428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41429 return resultobj;
41430 fail:
41431 return NULL;
41432 }
41433
41434
41435 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41436 PyObject *resultobj = NULL;
41437 wxPySizer *arg1 = (wxPySizer *) 0 ;
41438 PyObject *arg2 = (PyObject *) 0 ;
41439 PyObject *arg3 = (PyObject *) 0 ;
41440 PyObject * obj0 = 0 ;
41441 PyObject * obj1 = 0 ;
41442 PyObject * obj2 = 0 ;
41443 char *kwnames[] = {
41444 (char *) "self",(char *) "self",(char *) "_class", NULL
41445 };
41446
41447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41449 if (SWIG_arg_fail(1)) SWIG_fail;
41450 arg2 = obj1;
41451 arg3 = obj2;
41452 {
41453 PyThreadState* __tstate = wxPyBeginAllowThreads();
41454 (arg1)->_setCallbackInfo(arg2,arg3);
41455
41456 wxPyEndAllowThreads(__tstate);
41457 if (PyErr_Occurred()) SWIG_fail;
41458 }
41459 Py_INCREF(Py_None); resultobj = Py_None;
41460 return resultobj;
41461 fail:
41462 return NULL;
41463 }
41464
41465
41466 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41467 PyObject *obj;
41468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41469 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41470 Py_INCREF(obj);
41471 return Py_BuildValue((char *)"");
41472 }
41473 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41474 PyObject *resultobj = NULL;
41475 int arg1 = (int) wxHORIZONTAL ;
41476 wxBoxSizer *result;
41477 PyObject * obj0 = 0 ;
41478 char *kwnames[] = {
41479 (char *) "orient", NULL
41480 };
41481
41482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41483 if (obj0) {
41484 {
41485 arg1 = static_cast<int >(SWIG_As_int(obj0));
41486 if (SWIG_arg_fail(1)) SWIG_fail;
41487 }
41488 }
41489 {
41490 PyThreadState* __tstate = wxPyBeginAllowThreads();
41491 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41492
41493 wxPyEndAllowThreads(__tstate);
41494 if (PyErr_Occurred()) SWIG_fail;
41495 }
41496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41497 return resultobj;
41498 fail:
41499 return NULL;
41500 }
41501
41502
41503 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41504 PyObject *resultobj = NULL;
41505 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41506 int result;
41507 PyObject * obj0 = 0 ;
41508 char *kwnames[] = {
41509 (char *) "self", NULL
41510 };
41511
41512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41514 if (SWIG_arg_fail(1)) SWIG_fail;
41515 {
41516 PyThreadState* __tstate = wxPyBeginAllowThreads();
41517 result = (int)(arg1)->GetOrientation();
41518
41519 wxPyEndAllowThreads(__tstate);
41520 if (PyErr_Occurred()) SWIG_fail;
41521 }
41522 {
41523 resultobj = SWIG_From_int(static_cast<int >(result));
41524 }
41525 return resultobj;
41526 fail:
41527 return NULL;
41528 }
41529
41530
41531 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41532 PyObject *resultobj = NULL;
41533 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41534 int arg2 ;
41535 PyObject * obj0 = 0 ;
41536 PyObject * obj1 = 0 ;
41537 char *kwnames[] = {
41538 (char *) "self",(char *) "orient", NULL
41539 };
41540
41541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41543 if (SWIG_arg_fail(1)) SWIG_fail;
41544 {
41545 arg2 = static_cast<int >(SWIG_As_int(obj1));
41546 if (SWIG_arg_fail(2)) SWIG_fail;
41547 }
41548 {
41549 PyThreadState* __tstate = wxPyBeginAllowThreads();
41550 (arg1)->SetOrientation(arg2);
41551
41552 wxPyEndAllowThreads(__tstate);
41553 if (PyErr_Occurred()) SWIG_fail;
41554 }
41555 Py_INCREF(Py_None); resultobj = Py_None;
41556 return resultobj;
41557 fail:
41558 return NULL;
41559 }
41560
41561
41562 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41563 PyObject *obj;
41564 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41565 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41566 Py_INCREF(obj);
41567 return Py_BuildValue((char *)"");
41568 }
41569 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41570 PyObject *resultobj = NULL;
41571 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41572 int arg2 = (int) wxHORIZONTAL ;
41573 wxStaticBoxSizer *result;
41574 PyObject * obj0 = 0 ;
41575 PyObject * obj1 = 0 ;
41576 char *kwnames[] = {
41577 (char *) "box",(char *) "orient", NULL
41578 };
41579
41580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41582 if (SWIG_arg_fail(1)) SWIG_fail;
41583 if (obj1) {
41584 {
41585 arg2 = static_cast<int >(SWIG_As_int(obj1));
41586 if (SWIG_arg_fail(2)) SWIG_fail;
41587 }
41588 }
41589 {
41590 PyThreadState* __tstate = wxPyBeginAllowThreads();
41591 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41592
41593 wxPyEndAllowThreads(__tstate);
41594 if (PyErr_Occurred()) SWIG_fail;
41595 }
41596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41597 return resultobj;
41598 fail:
41599 return NULL;
41600 }
41601
41602
41603 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41604 PyObject *resultobj = NULL;
41605 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41606 wxStaticBox *result;
41607 PyObject * obj0 = 0 ;
41608 char *kwnames[] = {
41609 (char *) "self", NULL
41610 };
41611
41612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41614 if (SWIG_arg_fail(1)) SWIG_fail;
41615 {
41616 PyThreadState* __tstate = wxPyBeginAllowThreads();
41617 result = (wxStaticBox *)(arg1)->GetStaticBox();
41618
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 {
41623 resultobj = wxPyMake_wxObject(result, 0);
41624 }
41625 return resultobj;
41626 fail:
41627 return NULL;
41628 }
41629
41630
41631 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41632 PyObject *obj;
41633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41634 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41635 Py_INCREF(obj);
41636 return Py_BuildValue((char *)"");
41637 }
41638 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41639 PyObject *resultobj = NULL;
41640 int arg1 = (int) 1 ;
41641 int arg2 = (int) 0 ;
41642 int arg3 = (int) 0 ;
41643 int arg4 = (int) 0 ;
41644 wxGridSizer *result;
41645 PyObject * obj0 = 0 ;
41646 PyObject * obj1 = 0 ;
41647 PyObject * obj2 = 0 ;
41648 PyObject * obj3 = 0 ;
41649 char *kwnames[] = {
41650 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41651 };
41652
41653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41654 if (obj0) {
41655 {
41656 arg1 = static_cast<int >(SWIG_As_int(obj0));
41657 if (SWIG_arg_fail(1)) SWIG_fail;
41658 }
41659 }
41660 if (obj1) {
41661 {
41662 arg2 = static_cast<int >(SWIG_As_int(obj1));
41663 if (SWIG_arg_fail(2)) SWIG_fail;
41664 }
41665 }
41666 if (obj2) {
41667 {
41668 arg3 = static_cast<int >(SWIG_As_int(obj2));
41669 if (SWIG_arg_fail(3)) SWIG_fail;
41670 }
41671 }
41672 if (obj3) {
41673 {
41674 arg4 = static_cast<int >(SWIG_As_int(obj3));
41675 if (SWIG_arg_fail(4)) SWIG_fail;
41676 }
41677 }
41678 {
41679 PyThreadState* __tstate = wxPyBeginAllowThreads();
41680 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41681
41682 wxPyEndAllowThreads(__tstate);
41683 if (PyErr_Occurred()) SWIG_fail;
41684 }
41685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41686 return resultobj;
41687 fail:
41688 return NULL;
41689 }
41690
41691
41692 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41693 PyObject *resultobj = NULL;
41694 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41695 int arg2 ;
41696 PyObject * obj0 = 0 ;
41697 PyObject * obj1 = 0 ;
41698 char *kwnames[] = {
41699 (char *) "self",(char *) "cols", NULL
41700 };
41701
41702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41704 if (SWIG_arg_fail(1)) SWIG_fail;
41705 {
41706 arg2 = static_cast<int >(SWIG_As_int(obj1));
41707 if (SWIG_arg_fail(2)) SWIG_fail;
41708 }
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 (arg1)->SetCols(arg2);
41712
41713 wxPyEndAllowThreads(__tstate);
41714 if (PyErr_Occurred()) SWIG_fail;
41715 }
41716 Py_INCREF(Py_None); resultobj = Py_None;
41717 return resultobj;
41718 fail:
41719 return NULL;
41720 }
41721
41722
41723 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41724 PyObject *resultobj = NULL;
41725 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41726 int arg2 ;
41727 PyObject * obj0 = 0 ;
41728 PyObject * obj1 = 0 ;
41729 char *kwnames[] = {
41730 (char *) "self",(char *) "rows", NULL
41731 };
41732
41733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41735 if (SWIG_arg_fail(1)) SWIG_fail;
41736 {
41737 arg2 = static_cast<int >(SWIG_As_int(obj1));
41738 if (SWIG_arg_fail(2)) SWIG_fail;
41739 }
41740 {
41741 PyThreadState* __tstate = wxPyBeginAllowThreads();
41742 (arg1)->SetRows(arg2);
41743
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 Py_INCREF(Py_None); resultobj = Py_None;
41748 return resultobj;
41749 fail:
41750 return NULL;
41751 }
41752
41753
41754 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41755 PyObject *resultobj = NULL;
41756 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41757 int arg2 ;
41758 PyObject * obj0 = 0 ;
41759 PyObject * obj1 = 0 ;
41760 char *kwnames[] = {
41761 (char *) "self",(char *) "gap", NULL
41762 };
41763
41764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41766 if (SWIG_arg_fail(1)) SWIG_fail;
41767 {
41768 arg2 = static_cast<int >(SWIG_As_int(obj1));
41769 if (SWIG_arg_fail(2)) SWIG_fail;
41770 }
41771 {
41772 PyThreadState* __tstate = wxPyBeginAllowThreads();
41773 (arg1)->SetVGap(arg2);
41774
41775 wxPyEndAllowThreads(__tstate);
41776 if (PyErr_Occurred()) SWIG_fail;
41777 }
41778 Py_INCREF(Py_None); resultobj = Py_None;
41779 return resultobj;
41780 fail:
41781 return NULL;
41782 }
41783
41784
41785 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41786 PyObject *resultobj = NULL;
41787 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41788 int arg2 ;
41789 PyObject * obj0 = 0 ;
41790 PyObject * obj1 = 0 ;
41791 char *kwnames[] = {
41792 (char *) "self",(char *) "gap", NULL
41793 };
41794
41795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41797 if (SWIG_arg_fail(1)) SWIG_fail;
41798 {
41799 arg2 = static_cast<int >(SWIG_As_int(obj1));
41800 if (SWIG_arg_fail(2)) SWIG_fail;
41801 }
41802 {
41803 PyThreadState* __tstate = wxPyBeginAllowThreads();
41804 (arg1)->SetHGap(arg2);
41805
41806 wxPyEndAllowThreads(__tstate);
41807 if (PyErr_Occurred()) SWIG_fail;
41808 }
41809 Py_INCREF(Py_None); resultobj = Py_None;
41810 return resultobj;
41811 fail:
41812 return NULL;
41813 }
41814
41815
41816 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41817 PyObject *resultobj = NULL;
41818 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41819 int result;
41820 PyObject * obj0 = 0 ;
41821 char *kwnames[] = {
41822 (char *) "self", NULL
41823 };
41824
41825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41827 if (SWIG_arg_fail(1)) SWIG_fail;
41828 {
41829 PyThreadState* __tstate = wxPyBeginAllowThreads();
41830 result = (int)(arg1)->GetCols();
41831
41832 wxPyEndAllowThreads(__tstate);
41833 if (PyErr_Occurred()) SWIG_fail;
41834 }
41835 {
41836 resultobj = SWIG_From_int(static_cast<int >(result));
41837 }
41838 return resultobj;
41839 fail:
41840 return NULL;
41841 }
41842
41843
41844 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41845 PyObject *resultobj = NULL;
41846 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41847 int result;
41848 PyObject * obj0 = 0 ;
41849 char *kwnames[] = {
41850 (char *) "self", NULL
41851 };
41852
41853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41855 if (SWIG_arg_fail(1)) SWIG_fail;
41856 {
41857 PyThreadState* __tstate = wxPyBeginAllowThreads();
41858 result = (int)(arg1)->GetRows();
41859
41860 wxPyEndAllowThreads(__tstate);
41861 if (PyErr_Occurred()) SWIG_fail;
41862 }
41863 {
41864 resultobj = SWIG_From_int(static_cast<int >(result));
41865 }
41866 return resultobj;
41867 fail:
41868 return NULL;
41869 }
41870
41871
41872 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj = NULL;
41874 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41875 int result;
41876 PyObject * obj0 = 0 ;
41877 char *kwnames[] = {
41878 (char *) "self", NULL
41879 };
41880
41881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41883 if (SWIG_arg_fail(1)) SWIG_fail;
41884 {
41885 PyThreadState* __tstate = wxPyBeginAllowThreads();
41886 result = (int)(arg1)->GetVGap();
41887
41888 wxPyEndAllowThreads(__tstate);
41889 if (PyErr_Occurred()) SWIG_fail;
41890 }
41891 {
41892 resultobj = SWIG_From_int(static_cast<int >(result));
41893 }
41894 return resultobj;
41895 fail:
41896 return NULL;
41897 }
41898
41899
41900 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41901 PyObject *resultobj = NULL;
41902 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41903 int result;
41904 PyObject * obj0 = 0 ;
41905 char *kwnames[] = {
41906 (char *) "self", NULL
41907 };
41908
41909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41911 if (SWIG_arg_fail(1)) SWIG_fail;
41912 {
41913 PyThreadState* __tstate = wxPyBeginAllowThreads();
41914 result = (int)(arg1)->GetHGap();
41915
41916 wxPyEndAllowThreads(__tstate);
41917 if (PyErr_Occurred()) SWIG_fail;
41918 }
41919 {
41920 resultobj = SWIG_From_int(static_cast<int >(result));
41921 }
41922 return resultobj;
41923 fail:
41924 return NULL;
41925 }
41926
41927
41928 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41929 PyObject *obj;
41930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41931 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41932 Py_INCREF(obj);
41933 return Py_BuildValue((char *)"");
41934 }
41935 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41936 PyObject *resultobj = NULL;
41937 int arg1 = (int) 1 ;
41938 int arg2 = (int) 0 ;
41939 int arg3 = (int) 0 ;
41940 int arg4 = (int) 0 ;
41941 wxFlexGridSizer *result;
41942 PyObject * obj0 = 0 ;
41943 PyObject * obj1 = 0 ;
41944 PyObject * obj2 = 0 ;
41945 PyObject * obj3 = 0 ;
41946 char *kwnames[] = {
41947 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41948 };
41949
41950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41951 if (obj0) {
41952 {
41953 arg1 = static_cast<int >(SWIG_As_int(obj0));
41954 if (SWIG_arg_fail(1)) SWIG_fail;
41955 }
41956 }
41957 if (obj1) {
41958 {
41959 arg2 = static_cast<int >(SWIG_As_int(obj1));
41960 if (SWIG_arg_fail(2)) SWIG_fail;
41961 }
41962 }
41963 if (obj2) {
41964 {
41965 arg3 = static_cast<int >(SWIG_As_int(obj2));
41966 if (SWIG_arg_fail(3)) SWIG_fail;
41967 }
41968 }
41969 if (obj3) {
41970 {
41971 arg4 = static_cast<int >(SWIG_As_int(obj3));
41972 if (SWIG_arg_fail(4)) SWIG_fail;
41973 }
41974 }
41975 {
41976 PyThreadState* __tstate = wxPyBeginAllowThreads();
41977 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41978
41979 wxPyEndAllowThreads(__tstate);
41980 if (PyErr_Occurred()) SWIG_fail;
41981 }
41982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41983 return resultobj;
41984 fail:
41985 return NULL;
41986 }
41987
41988
41989 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41990 PyObject *resultobj = NULL;
41991 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41992 size_t arg2 ;
41993 int arg3 = (int) 0 ;
41994 PyObject * obj0 = 0 ;
41995 PyObject * obj1 = 0 ;
41996 PyObject * obj2 = 0 ;
41997 char *kwnames[] = {
41998 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41999 };
42000
42001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42003 if (SWIG_arg_fail(1)) SWIG_fail;
42004 {
42005 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42006 if (SWIG_arg_fail(2)) SWIG_fail;
42007 }
42008 if (obj2) {
42009 {
42010 arg3 = static_cast<int >(SWIG_As_int(obj2));
42011 if (SWIG_arg_fail(3)) SWIG_fail;
42012 }
42013 }
42014 {
42015 PyThreadState* __tstate = wxPyBeginAllowThreads();
42016 (arg1)->AddGrowableRow(arg2,arg3);
42017
42018 wxPyEndAllowThreads(__tstate);
42019 if (PyErr_Occurred()) SWIG_fail;
42020 }
42021 Py_INCREF(Py_None); resultobj = Py_None;
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42029 PyObject *resultobj = NULL;
42030 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42031 size_t arg2 ;
42032 PyObject * obj0 = 0 ;
42033 PyObject * obj1 = 0 ;
42034 char *kwnames[] = {
42035 (char *) "self",(char *) "idx", NULL
42036 };
42037
42038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42040 if (SWIG_arg_fail(1)) SWIG_fail;
42041 {
42042 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42043 if (SWIG_arg_fail(2)) SWIG_fail;
42044 }
42045 {
42046 PyThreadState* __tstate = wxPyBeginAllowThreads();
42047 (arg1)->RemoveGrowableRow(arg2);
42048
42049 wxPyEndAllowThreads(__tstate);
42050 if (PyErr_Occurred()) SWIG_fail;
42051 }
42052 Py_INCREF(Py_None); resultobj = Py_None;
42053 return resultobj;
42054 fail:
42055 return NULL;
42056 }
42057
42058
42059 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42060 PyObject *resultobj = NULL;
42061 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42062 size_t arg2 ;
42063 int arg3 = (int) 0 ;
42064 PyObject * obj0 = 0 ;
42065 PyObject * obj1 = 0 ;
42066 PyObject * obj2 = 0 ;
42067 char *kwnames[] = {
42068 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42069 };
42070
42071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42073 if (SWIG_arg_fail(1)) SWIG_fail;
42074 {
42075 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42076 if (SWIG_arg_fail(2)) SWIG_fail;
42077 }
42078 if (obj2) {
42079 {
42080 arg3 = static_cast<int >(SWIG_As_int(obj2));
42081 if (SWIG_arg_fail(3)) SWIG_fail;
42082 }
42083 }
42084 {
42085 PyThreadState* __tstate = wxPyBeginAllowThreads();
42086 (arg1)->AddGrowableCol(arg2,arg3);
42087
42088 wxPyEndAllowThreads(__tstate);
42089 if (PyErr_Occurred()) SWIG_fail;
42090 }
42091 Py_INCREF(Py_None); resultobj = Py_None;
42092 return resultobj;
42093 fail:
42094 return NULL;
42095 }
42096
42097
42098 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj = NULL;
42100 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42101 size_t arg2 ;
42102 PyObject * obj0 = 0 ;
42103 PyObject * obj1 = 0 ;
42104 char *kwnames[] = {
42105 (char *) "self",(char *) "idx", NULL
42106 };
42107
42108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42110 if (SWIG_arg_fail(1)) SWIG_fail;
42111 {
42112 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42113 if (SWIG_arg_fail(2)) SWIG_fail;
42114 }
42115 {
42116 PyThreadState* __tstate = wxPyBeginAllowThreads();
42117 (arg1)->RemoveGrowableCol(arg2);
42118
42119 wxPyEndAllowThreads(__tstate);
42120 if (PyErr_Occurred()) SWIG_fail;
42121 }
42122 Py_INCREF(Py_None); resultobj = Py_None;
42123 return resultobj;
42124 fail:
42125 return NULL;
42126 }
42127
42128
42129 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42130 PyObject *resultobj = NULL;
42131 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42132 int arg2 ;
42133 PyObject * obj0 = 0 ;
42134 PyObject * obj1 = 0 ;
42135 char *kwnames[] = {
42136 (char *) "self",(char *) "direction", NULL
42137 };
42138
42139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42141 if (SWIG_arg_fail(1)) SWIG_fail;
42142 {
42143 arg2 = static_cast<int >(SWIG_As_int(obj1));
42144 if (SWIG_arg_fail(2)) SWIG_fail;
42145 }
42146 {
42147 PyThreadState* __tstate = wxPyBeginAllowThreads();
42148 (arg1)->SetFlexibleDirection(arg2);
42149
42150 wxPyEndAllowThreads(__tstate);
42151 if (PyErr_Occurred()) SWIG_fail;
42152 }
42153 Py_INCREF(Py_None); resultobj = Py_None;
42154 return resultobj;
42155 fail:
42156 return NULL;
42157 }
42158
42159
42160 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42161 PyObject *resultobj = NULL;
42162 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42163 int result;
42164 PyObject * obj0 = 0 ;
42165 char *kwnames[] = {
42166 (char *) "self", NULL
42167 };
42168
42169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42171 if (SWIG_arg_fail(1)) SWIG_fail;
42172 {
42173 PyThreadState* __tstate = wxPyBeginAllowThreads();
42174 result = (int)(arg1)->GetFlexibleDirection();
42175
42176 wxPyEndAllowThreads(__tstate);
42177 if (PyErr_Occurred()) SWIG_fail;
42178 }
42179 {
42180 resultobj = SWIG_From_int(static_cast<int >(result));
42181 }
42182 return resultobj;
42183 fail:
42184 return NULL;
42185 }
42186
42187
42188 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42189 PyObject *resultobj = NULL;
42190 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42191 wxFlexSizerGrowMode arg2 ;
42192 PyObject * obj0 = 0 ;
42193 PyObject * obj1 = 0 ;
42194 char *kwnames[] = {
42195 (char *) "self",(char *) "mode", NULL
42196 };
42197
42198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42200 if (SWIG_arg_fail(1)) SWIG_fail;
42201 {
42202 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42203 if (SWIG_arg_fail(2)) SWIG_fail;
42204 }
42205 {
42206 PyThreadState* __tstate = wxPyBeginAllowThreads();
42207 (arg1)->SetNonFlexibleGrowMode(arg2);
42208
42209 wxPyEndAllowThreads(__tstate);
42210 if (PyErr_Occurred()) SWIG_fail;
42211 }
42212 Py_INCREF(Py_None); resultobj = Py_None;
42213 return resultobj;
42214 fail:
42215 return NULL;
42216 }
42217
42218
42219 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42220 PyObject *resultobj = NULL;
42221 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42222 wxFlexSizerGrowMode result;
42223 PyObject * obj0 = 0 ;
42224 char *kwnames[] = {
42225 (char *) "self", NULL
42226 };
42227
42228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42230 if (SWIG_arg_fail(1)) SWIG_fail;
42231 {
42232 PyThreadState* __tstate = wxPyBeginAllowThreads();
42233 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42234
42235 wxPyEndAllowThreads(__tstate);
42236 if (PyErr_Occurred()) SWIG_fail;
42237 }
42238 resultobj = SWIG_From_int((result));
42239 return resultobj;
42240 fail:
42241 return NULL;
42242 }
42243
42244
42245 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42246 PyObject *resultobj = NULL;
42247 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42248 wxArrayInt *result;
42249 PyObject * obj0 = 0 ;
42250 char *kwnames[] = {
42251 (char *) "self", NULL
42252 };
42253
42254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42256 if (SWIG_arg_fail(1)) SWIG_fail;
42257 {
42258 PyThreadState* __tstate = wxPyBeginAllowThreads();
42259 {
42260 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42261 result = (wxArrayInt *) &_result_ref;
42262 }
42263
42264 wxPyEndAllowThreads(__tstate);
42265 if (PyErr_Occurred()) SWIG_fail;
42266 }
42267 {
42268 resultobj = PyList_New(0);
42269 size_t idx;
42270 for (idx = 0; idx < result->GetCount(); idx += 1) {
42271 PyObject* val = PyInt_FromLong( result->Item(idx) );
42272 PyList_Append(resultobj, val);
42273 Py_DECREF(val);
42274 }
42275 }
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj = NULL;
42284 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42285 wxArrayInt *result;
42286 PyObject * obj0 = 0 ;
42287 char *kwnames[] = {
42288 (char *) "self", NULL
42289 };
42290
42291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42293 if (SWIG_arg_fail(1)) SWIG_fail;
42294 {
42295 PyThreadState* __tstate = wxPyBeginAllowThreads();
42296 {
42297 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42298 result = (wxArrayInt *) &_result_ref;
42299 }
42300
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 {
42305 resultobj = PyList_New(0);
42306 size_t idx;
42307 for (idx = 0; idx < result->GetCount(); idx += 1) {
42308 PyObject* val = PyInt_FromLong( result->Item(idx) );
42309 PyList_Append(resultobj, val);
42310 Py_DECREF(val);
42311 }
42312 }
42313 return resultobj;
42314 fail:
42315 return NULL;
42316 }
42317
42318
42319 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42320 PyObject *obj;
42321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42322 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42323 Py_INCREF(obj);
42324 return Py_BuildValue((char *)"");
42325 }
42326 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42327 PyObject *resultobj = NULL;
42328 wxStdDialogButtonSizer *result;
42329 char *kwnames[] = {
42330 NULL
42331 };
42332
42333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42334 {
42335 PyThreadState* __tstate = wxPyBeginAllowThreads();
42336 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42337
42338 wxPyEndAllowThreads(__tstate);
42339 if (PyErr_Occurred()) SWIG_fail;
42340 }
42341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42342 return resultobj;
42343 fail:
42344 return NULL;
42345 }
42346
42347
42348 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42349 PyObject *resultobj = NULL;
42350 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42351 wxButton *arg2 = (wxButton *) 0 ;
42352 PyObject * obj0 = 0 ;
42353 PyObject * obj1 = 0 ;
42354 char *kwnames[] = {
42355 (char *) "self",(char *) "button", NULL
42356 };
42357
42358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42360 if (SWIG_arg_fail(1)) SWIG_fail;
42361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42362 if (SWIG_arg_fail(2)) SWIG_fail;
42363 {
42364 PyThreadState* __tstate = wxPyBeginAllowThreads();
42365 (arg1)->AddButton(arg2);
42366
42367 wxPyEndAllowThreads(__tstate);
42368 if (PyErr_Occurred()) SWIG_fail;
42369 }
42370 Py_INCREF(Py_None); resultobj = Py_None;
42371 return resultobj;
42372 fail:
42373 return NULL;
42374 }
42375
42376
42377 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42378 PyObject *resultobj = NULL;
42379 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42380 PyObject * obj0 = 0 ;
42381 char *kwnames[] = {
42382 (char *) "self", NULL
42383 };
42384
42385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42387 if (SWIG_arg_fail(1)) SWIG_fail;
42388 {
42389 PyThreadState* __tstate = wxPyBeginAllowThreads();
42390 (arg1)->Realize();
42391
42392 wxPyEndAllowThreads(__tstate);
42393 if (PyErr_Occurred()) SWIG_fail;
42394 }
42395 Py_INCREF(Py_None); resultobj = Py_None;
42396 return resultobj;
42397 fail:
42398 return NULL;
42399 }
42400
42401
42402 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42403 PyObject *resultobj = NULL;
42404 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42405 wxButton *arg2 = (wxButton *) 0 ;
42406 PyObject * obj0 = 0 ;
42407 PyObject * obj1 = 0 ;
42408 char *kwnames[] = {
42409 (char *) "self",(char *) "button", NULL
42410 };
42411
42412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42414 if (SWIG_arg_fail(1)) SWIG_fail;
42415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42416 if (SWIG_arg_fail(2)) SWIG_fail;
42417 {
42418 PyThreadState* __tstate = wxPyBeginAllowThreads();
42419 (arg1)->SetAffirmativeButton(arg2);
42420
42421 wxPyEndAllowThreads(__tstate);
42422 if (PyErr_Occurred()) SWIG_fail;
42423 }
42424 Py_INCREF(Py_None); resultobj = Py_None;
42425 return resultobj;
42426 fail:
42427 return NULL;
42428 }
42429
42430
42431 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42432 PyObject *resultobj = NULL;
42433 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42434 wxButton *arg2 = (wxButton *) 0 ;
42435 PyObject * obj0 = 0 ;
42436 PyObject * obj1 = 0 ;
42437 char *kwnames[] = {
42438 (char *) "self",(char *) "button", NULL
42439 };
42440
42441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42443 if (SWIG_arg_fail(1)) SWIG_fail;
42444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42445 if (SWIG_arg_fail(2)) SWIG_fail;
42446 {
42447 PyThreadState* __tstate = wxPyBeginAllowThreads();
42448 (arg1)->SetNegativeButton(arg2);
42449
42450 wxPyEndAllowThreads(__tstate);
42451 if (PyErr_Occurred()) SWIG_fail;
42452 }
42453 Py_INCREF(Py_None); resultobj = Py_None;
42454 return resultobj;
42455 fail:
42456 return NULL;
42457 }
42458
42459
42460 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42461 PyObject *resultobj = NULL;
42462 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42463 wxButton *arg2 = (wxButton *) 0 ;
42464 PyObject * obj0 = 0 ;
42465 PyObject * obj1 = 0 ;
42466 char *kwnames[] = {
42467 (char *) "self",(char *) "button", NULL
42468 };
42469
42470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42472 if (SWIG_arg_fail(1)) SWIG_fail;
42473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42474 if (SWIG_arg_fail(2)) SWIG_fail;
42475 {
42476 PyThreadState* __tstate = wxPyBeginAllowThreads();
42477 (arg1)->SetCancelButton(arg2);
42478
42479 wxPyEndAllowThreads(__tstate);
42480 if (PyErr_Occurred()) SWIG_fail;
42481 }
42482 Py_INCREF(Py_None); resultobj = Py_None;
42483 return resultobj;
42484 fail:
42485 return NULL;
42486 }
42487
42488
42489 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42490 PyObject *resultobj = NULL;
42491 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42492 wxButton *result;
42493 PyObject * obj0 = 0 ;
42494 char *kwnames[] = {
42495 (char *) "self", NULL
42496 };
42497
42498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42500 if (SWIG_arg_fail(1)) SWIG_fail;
42501 {
42502 PyThreadState* __tstate = wxPyBeginAllowThreads();
42503 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42504
42505 wxPyEndAllowThreads(__tstate);
42506 if (PyErr_Occurred()) SWIG_fail;
42507 }
42508 {
42509 resultobj = wxPyMake_wxObject(result, 0);
42510 }
42511 return resultobj;
42512 fail:
42513 return NULL;
42514 }
42515
42516
42517 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42518 PyObject *resultobj = NULL;
42519 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42520 wxButton *result;
42521 PyObject * obj0 = 0 ;
42522 char *kwnames[] = {
42523 (char *) "self", NULL
42524 };
42525
42526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42528 if (SWIG_arg_fail(1)) SWIG_fail;
42529 {
42530 PyThreadState* __tstate = wxPyBeginAllowThreads();
42531 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42532
42533 wxPyEndAllowThreads(__tstate);
42534 if (PyErr_Occurred()) SWIG_fail;
42535 }
42536 {
42537 resultobj = wxPyMake_wxObject(result, 0);
42538 }
42539 return resultobj;
42540 fail:
42541 return NULL;
42542 }
42543
42544
42545 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42546 PyObject *resultobj = NULL;
42547 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42548 wxButton *result;
42549 PyObject * obj0 = 0 ;
42550 char *kwnames[] = {
42551 (char *) "self", NULL
42552 };
42553
42554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42556 if (SWIG_arg_fail(1)) SWIG_fail;
42557 {
42558 PyThreadState* __tstate = wxPyBeginAllowThreads();
42559 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42560
42561 wxPyEndAllowThreads(__tstate);
42562 if (PyErr_Occurred()) SWIG_fail;
42563 }
42564 {
42565 resultobj = wxPyMake_wxObject(result, 0);
42566 }
42567 return resultobj;
42568 fail:
42569 return NULL;
42570 }
42571
42572
42573 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42574 PyObject *resultobj = NULL;
42575 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42576 wxButton *result;
42577 PyObject * obj0 = 0 ;
42578 char *kwnames[] = {
42579 (char *) "self", NULL
42580 };
42581
42582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) 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 {
42586 PyThreadState* __tstate = wxPyBeginAllowThreads();
42587 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42588
42589 wxPyEndAllowThreads(__tstate);
42590 if (PyErr_Occurred()) SWIG_fail;
42591 }
42592 {
42593 resultobj = wxPyMake_wxObject(result, 0);
42594 }
42595 return resultobj;
42596 fail:
42597 return NULL;
42598 }
42599
42600
42601 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42602 PyObject *resultobj = NULL;
42603 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42604 wxButton *result;
42605 PyObject * obj0 = 0 ;
42606 char *kwnames[] = {
42607 (char *) "self", NULL
42608 };
42609
42610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42612 if (SWIG_arg_fail(1)) SWIG_fail;
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42616
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 resultobj = wxPyMake_wxObject(result, 0);
42622 }
42623 return resultobj;
42624 fail:
42625 return NULL;
42626 }
42627
42628
42629 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42630 PyObject *obj;
42631 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42632 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42633 Py_INCREF(obj);
42634 return Py_BuildValue((char *)"");
42635 }
42636 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42637 PyObject *resultobj = NULL;
42638 int arg1 = (int) 0 ;
42639 int arg2 = (int) 0 ;
42640 wxGBPosition *result;
42641 PyObject * obj0 = 0 ;
42642 PyObject * obj1 = 0 ;
42643 char *kwnames[] = {
42644 (char *) "row",(char *) "col", NULL
42645 };
42646
42647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42648 if (obj0) {
42649 {
42650 arg1 = static_cast<int >(SWIG_As_int(obj0));
42651 if (SWIG_arg_fail(1)) SWIG_fail;
42652 }
42653 }
42654 if (obj1) {
42655 {
42656 arg2 = static_cast<int >(SWIG_As_int(obj1));
42657 if (SWIG_arg_fail(2)) SWIG_fail;
42658 }
42659 }
42660 {
42661 PyThreadState* __tstate = wxPyBeginAllowThreads();
42662 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42663
42664 wxPyEndAllowThreads(__tstate);
42665 if (PyErr_Occurred()) SWIG_fail;
42666 }
42667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42668 return resultobj;
42669 fail:
42670 return NULL;
42671 }
42672
42673
42674 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42675 PyObject *resultobj = NULL;
42676 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42677 int result;
42678 PyObject * obj0 = 0 ;
42679 char *kwnames[] = {
42680 (char *) "self", NULL
42681 };
42682
42683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42685 if (SWIG_arg_fail(1)) SWIG_fail;
42686 {
42687 PyThreadState* __tstate = wxPyBeginAllowThreads();
42688 result = (int)((wxGBPosition const *)arg1)->GetRow();
42689
42690 wxPyEndAllowThreads(__tstate);
42691 if (PyErr_Occurred()) SWIG_fail;
42692 }
42693 {
42694 resultobj = SWIG_From_int(static_cast<int >(result));
42695 }
42696 return resultobj;
42697 fail:
42698 return NULL;
42699 }
42700
42701
42702 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42703 PyObject *resultobj = NULL;
42704 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42705 int result;
42706 PyObject * obj0 = 0 ;
42707 char *kwnames[] = {
42708 (char *) "self", NULL
42709 };
42710
42711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42713 if (SWIG_arg_fail(1)) SWIG_fail;
42714 {
42715 PyThreadState* __tstate = wxPyBeginAllowThreads();
42716 result = (int)((wxGBPosition const *)arg1)->GetCol();
42717
42718 wxPyEndAllowThreads(__tstate);
42719 if (PyErr_Occurred()) SWIG_fail;
42720 }
42721 {
42722 resultobj = SWIG_From_int(static_cast<int >(result));
42723 }
42724 return resultobj;
42725 fail:
42726 return NULL;
42727 }
42728
42729
42730 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42731 PyObject *resultobj = NULL;
42732 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42733 int arg2 ;
42734 PyObject * obj0 = 0 ;
42735 PyObject * obj1 = 0 ;
42736 char *kwnames[] = {
42737 (char *) "self",(char *) "row", NULL
42738 };
42739
42740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42742 if (SWIG_arg_fail(1)) SWIG_fail;
42743 {
42744 arg2 = static_cast<int >(SWIG_As_int(obj1));
42745 if (SWIG_arg_fail(2)) SWIG_fail;
42746 }
42747 {
42748 PyThreadState* __tstate = wxPyBeginAllowThreads();
42749 (arg1)->SetRow(arg2);
42750
42751 wxPyEndAllowThreads(__tstate);
42752 if (PyErr_Occurred()) SWIG_fail;
42753 }
42754 Py_INCREF(Py_None); resultobj = Py_None;
42755 return resultobj;
42756 fail:
42757 return NULL;
42758 }
42759
42760
42761 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42762 PyObject *resultobj = NULL;
42763 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42764 int arg2 ;
42765 PyObject * obj0 = 0 ;
42766 PyObject * obj1 = 0 ;
42767 char *kwnames[] = {
42768 (char *) "self",(char *) "col", NULL
42769 };
42770
42771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42773 if (SWIG_arg_fail(1)) SWIG_fail;
42774 {
42775 arg2 = static_cast<int >(SWIG_As_int(obj1));
42776 if (SWIG_arg_fail(2)) SWIG_fail;
42777 }
42778 {
42779 PyThreadState* __tstate = wxPyBeginAllowThreads();
42780 (arg1)->SetCol(arg2);
42781
42782 wxPyEndAllowThreads(__tstate);
42783 if (PyErr_Occurred()) SWIG_fail;
42784 }
42785 Py_INCREF(Py_None); resultobj = Py_None;
42786 return resultobj;
42787 fail:
42788 return NULL;
42789 }
42790
42791
42792 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42793 PyObject *resultobj = NULL;
42794 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42795 wxGBPosition *arg2 = 0 ;
42796 bool result;
42797 wxGBPosition temp2 ;
42798 PyObject * obj0 = 0 ;
42799 PyObject * obj1 = 0 ;
42800 char *kwnames[] = {
42801 (char *) "self",(char *) "other", NULL
42802 };
42803
42804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42806 if (SWIG_arg_fail(1)) SWIG_fail;
42807 {
42808 arg2 = &temp2;
42809 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42810 }
42811 {
42812 PyThreadState* __tstate = wxPyBeginAllowThreads();
42813 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42814
42815 wxPyEndAllowThreads(__tstate);
42816 if (PyErr_Occurred()) SWIG_fail;
42817 }
42818 {
42819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42820 }
42821 return resultobj;
42822 fail:
42823 return NULL;
42824 }
42825
42826
42827 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42828 PyObject *resultobj = NULL;
42829 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42830 wxGBPosition *arg2 = 0 ;
42831 bool result;
42832 wxGBPosition temp2 ;
42833 PyObject * obj0 = 0 ;
42834 PyObject * obj1 = 0 ;
42835 char *kwnames[] = {
42836 (char *) "self",(char *) "other", NULL
42837 };
42838
42839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42841 if (SWIG_arg_fail(1)) SWIG_fail;
42842 {
42843 arg2 = &temp2;
42844 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42845 }
42846 {
42847 PyThreadState* __tstate = wxPyBeginAllowThreads();
42848 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42849
42850 wxPyEndAllowThreads(__tstate);
42851 if (PyErr_Occurred()) SWIG_fail;
42852 }
42853 {
42854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42855 }
42856 return resultobj;
42857 fail:
42858 return NULL;
42859 }
42860
42861
42862 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42863 PyObject *resultobj = NULL;
42864 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42865 int arg2 = (int) 0 ;
42866 int arg3 = (int) 0 ;
42867 PyObject * obj0 = 0 ;
42868 PyObject * obj1 = 0 ;
42869 PyObject * obj2 = 0 ;
42870 char *kwnames[] = {
42871 (char *) "self",(char *) "row",(char *) "col", NULL
42872 };
42873
42874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42876 if (SWIG_arg_fail(1)) SWIG_fail;
42877 if (obj1) {
42878 {
42879 arg2 = static_cast<int >(SWIG_As_int(obj1));
42880 if (SWIG_arg_fail(2)) SWIG_fail;
42881 }
42882 }
42883 if (obj2) {
42884 {
42885 arg3 = static_cast<int >(SWIG_As_int(obj2));
42886 if (SWIG_arg_fail(3)) SWIG_fail;
42887 }
42888 }
42889 {
42890 PyThreadState* __tstate = wxPyBeginAllowThreads();
42891 wxGBPosition_Set(arg1,arg2,arg3);
42892
42893 wxPyEndAllowThreads(__tstate);
42894 if (PyErr_Occurred()) SWIG_fail;
42895 }
42896 Py_INCREF(Py_None); resultobj = Py_None;
42897 return resultobj;
42898 fail:
42899 return NULL;
42900 }
42901
42902
42903 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42904 PyObject *resultobj = NULL;
42905 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42906 PyObject *result;
42907 PyObject * obj0 = 0 ;
42908 char *kwnames[] = {
42909 (char *) "self", NULL
42910 };
42911
42912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42914 if (SWIG_arg_fail(1)) SWIG_fail;
42915 {
42916 PyThreadState* __tstate = wxPyBeginAllowThreads();
42917 result = (PyObject *)wxGBPosition_Get(arg1);
42918
42919 wxPyEndAllowThreads(__tstate);
42920 if (PyErr_Occurred()) SWIG_fail;
42921 }
42922 resultobj = result;
42923 return resultobj;
42924 fail:
42925 return NULL;
42926 }
42927
42928
42929 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42930 PyObject *obj;
42931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42932 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42933 Py_INCREF(obj);
42934 return Py_BuildValue((char *)"");
42935 }
42936 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42937 PyObject *resultobj = NULL;
42938 int arg1 = (int) 1 ;
42939 int arg2 = (int) 1 ;
42940 wxGBSpan *result;
42941 PyObject * obj0 = 0 ;
42942 PyObject * obj1 = 0 ;
42943 char *kwnames[] = {
42944 (char *) "rowspan",(char *) "colspan", NULL
42945 };
42946
42947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42948 if (obj0) {
42949 {
42950 arg1 = static_cast<int >(SWIG_As_int(obj0));
42951 if (SWIG_arg_fail(1)) SWIG_fail;
42952 }
42953 }
42954 if (obj1) {
42955 {
42956 arg2 = static_cast<int >(SWIG_As_int(obj1));
42957 if (SWIG_arg_fail(2)) SWIG_fail;
42958 }
42959 }
42960 {
42961 PyThreadState* __tstate = wxPyBeginAllowThreads();
42962 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42963
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42968 return resultobj;
42969 fail:
42970 return NULL;
42971 }
42972
42973
42974 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42975 PyObject *resultobj = NULL;
42976 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42977 int result;
42978 PyObject * obj0 = 0 ;
42979 char *kwnames[] = {
42980 (char *) "self", NULL
42981 };
42982
42983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42985 if (SWIG_arg_fail(1)) SWIG_fail;
42986 {
42987 PyThreadState* __tstate = wxPyBeginAllowThreads();
42988 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42989
42990 wxPyEndAllowThreads(__tstate);
42991 if (PyErr_Occurred()) SWIG_fail;
42992 }
42993 {
42994 resultobj = SWIG_From_int(static_cast<int >(result));
42995 }
42996 return resultobj;
42997 fail:
42998 return NULL;
42999 }
43000
43001
43002 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43003 PyObject *resultobj = NULL;
43004 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43005 int result;
43006 PyObject * obj0 = 0 ;
43007 char *kwnames[] = {
43008 (char *) "self", NULL
43009 };
43010
43011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43013 if (SWIG_arg_fail(1)) SWIG_fail;
43014 {
43015 PyThreadState* __tstate = wxPyBeginAllowThreads();
43016 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43017
43018 wxPyEndAllowThreads(__tstate);
43019 if (PyErr_Occurred()) SWIG_fail;
43020 }
43021 {
43022 resultobj = SWIG_From_int(static_cast<int >(result));
43023 }
43024 return resultobj;
43025 fail:
43026 return NULL;
43027 }
43028
43029
43030 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43031 PyObject *resultobj = NULL;
43032 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43033 int arg2 ;
43034 PyObject * obj0 = 0 ;
43035 PyObject * obj1 = 0 ;
43036 char *kwnames[] = {
43037 (char *) "self",(char *) "rowspan", NULL
43038 };
43039
43040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43042 if (SWIG_arg_fail(1)) SWIG_fail;
43043 {
43044 arg2 = static_cast<int >(SWIG_As_int(obj1));
43045 if (SWIG_arg_fail(2)) SWIG_fail;
43046 }
43047 {
43048 PyThreadState* __tstate = wxPyBeginAllowThreads();
43049 (arg1)->SetRowspan(arg2);
43050
43051 wxPyEndAllowThreads(__tstate);
43052 if (PyErr_Occurred()) SWIG_fail;
43053 }
43054 Py_INCREF(Py_None); resultobj = Py_None;
43055 return resultobj;
43056 fail:
43057 return NULL;
43058 }
43059
43060
43061 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43062 PyObject *resultobj = NULL;
43063 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43064 int arg2 ;
43065 PyObject * obj0 = 0 ;
43066 PyObject * obj1 = 0 ;
43067 char *kwnames[] = {
43068 (char *) "self",(char *) "colspan", NULL
43069 };
43070
43071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43073 if (SWIG_arg_fail(1)) SWIG_fail;
43074 {
43075 arg2 = static_cast<int >(SWIG_As_int(obj1));
43076 if (SWIG_arg_fail(2)) SWIG_fail;
43077 }
43078 {
43079 PyThreadState* __tstate = wxPyBeginAllowThreads();
43080 (arg1)->SetColspan(arg2);
43081
43082 wxPyEndAllowThreads(__tstate);
43083 if (PyErr_Occurred()) SWIG_fail;
43084 }
43085 Py_INCREF(Py_None); resultobj = Py_None;
43086 return resultobj;
43087 fail:
43088 return NULL;
43089 }
43090
43091
43092 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43093 PyObject *resultobj = NULL;
43094 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43095 wxGBSpan *arg2 = 0 ;
43096 bool result;
43097 wxGBSpan temp2 ;
43098 PyObject * obj0 = 0 ;
43099 PyObject * obj1 = 0 ;
43100 char *kwnames[] = {
43101 (char *) "self",(char *) "other", NULL
43102 };
43103
43104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43106 if (SWIG_arg_fail(1)) SWIG_fail;
43107 {
43108 arg2 = &temp2;
43109 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43110 }
43111 {
43112 PyThreadState* __tstate = wxPyBeginAllowThreads();
43113 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43114
43115 wxPyEndAllowThreads(__tstate);
43116 if (PyErr_Occurred()) SWIG_fail;
43117 }
43118 {
43119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43120 }
43121 return resultobj;
43122 fail:
43123 return NULL;
43124 }
43125
43126
43127 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43128 PyObject *resultobj = NULL;
43129 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43130 wxGBSpan *arg2 = 0 ;
43131 bool result;
43132 wxGBSpan temp2 ;
43133 PyObject * obj0 = 0 ;
43134 PyObject * obj1 = 0 ;
43135 char *kwnames[] = {
43136 (char *) "self",(char *) "other", NULL
43137 };
43138
43139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43141 if (SWIG_arg_fail(1)) SWIG_fail;
43142 {
43143 arg2 = &temp2;
43144 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43145 }
43146 {
43147 PyThreadState* __tstate = wxPyBeginAllowThreads();
43148 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43149
43150 wxPyEndAllowThreads(__tstate);
43151 if (PyErr_Occurred()) SWIG_fail;
43152 }
43153 {
43154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43155 }
43156 return resultobj;
43157 fail:
43158 return NULL;
43159 }
43160
43161
43162 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43163 PyObject *resultobj = NULL;
43164 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43165 int arg2 = (int) 1 ;
43166 int arg3 = (int) 1 ;
43167 PyObject * obj0 = 0 ;
43168 PyObject * obj1 = 0 ;
43169 PyObject * obj2 = 0 ;
43170 char *kwnames[] = {
43171 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43172 };
43173
43174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43176 if (SWIG_arg_fail(1)) SWIG_fail;
43177 if (obj1) {
43178 {
43179 arg2 = static_cast<int >(SWIG_As_int(obj1));
43180 if (SWIG_arg_fail(2)) SWIG_fail;
43181 }
43182 }
43183 if (obj2) {
43184 {
43185 arg3 = static_cast<int >(SWIG_As_int(obj2));
43186 if (SWIG_arg_fail(3)) SWIG_fail;
43187 }
43188 }
43189 {
43190 PyThreadState* __tstate = wxPyBeginAllowThreads();
43191 wxGBSpan_Set(arg1,arg2,arg3);
43192
43193 wxPyEndAllowThreads(__tstate);
43194 if (PyErr_Occurred()) SWIG_fail;
43195 }
43196 Py_INCREF(Py_None); resultobj = Py_None;
43197 return resultobj;
43198 fail:
43199 return NULL;
43200 }
43201
43202
43203 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43204 PyObject *resultobj = NULL;
43205 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43206 PyObject *result;
43207 PyObject * obj0 = 0 ;
43208 char *kwnames[] = {
43209 (char *) "self", NULL
43210 };
43211
43212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43214 if (SWIG_arg_fail(1)) SWIG_fail;
43215 {
43216 PyThreadState* __tstate = wxPyBeginAllowThreads();
43217 result = (PyObject *)wxGBSpan_Get(arg1);
43218
43219 wxPyEndAllowThreads(__tstate);
43220 if (PyErr_Occurred()) SWIG_fail;
43221 }
43222 resultobj = result;
43223 return resultobj;
43224 fail:
43225 return NULL;
43226 }
43227
43228
43229 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43230 PyObject *obj;
43231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43232 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43233 Py_INCREF(obj);
43234 return Py_BuildValue((char *)"");
43235 }
43236 static int _wrap_DefaultSpan_set(PyObject *) {
43237 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43238 return 1;
43239 }
43240
43241
43242 static PyObject *_wrap_DefaultSpan_get(void) {
43243 PyObject *pyobj = NULL;
43244
43245 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43246 return pyobj;
43247 }
43248
43249
43250 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43251 PyObject *resultobj = NULL;
43252 wxGBSizerItem *result;
43253 char *kwnames[] = {
43254 NULL
43255 };
43256
43257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43258 {
43259 PyThreadState* __tstate = wxPyBeginAllowThreads();
43260 result = (wxGBSizerItem *)new wxGBSizerItem();
43261
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43266 return resultobj;
43267 fail:
43268 return NULL;
43269 }
43270
43271
43272 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43273 PyObject *resultobj = NULL;
43274 wxWindow *arg1 = (wxWindow *) 0 ;
43275 wxGBPosition *arg2 = 0 ;
43276 wxGBSpan *arg3 = 0 ;
43277 int arg4 ;
43278 int arg5 ;
43279 PyObject *arg6 = (PyObject *) NULL ;
43280 wxGBSizerItem *result;
43281 wxGBPosition temp2 ;
43282 wxGBSpan temp3 ;
43283 PyObject * obj0 = 0 ;
43284 PyObject * obj1 = 0 ;
43285 PyObject * obj2 = 0 ;
43286 PyObject * obj3 = 0 ;
43287 PyObject * obj4 = 0 ;
43288 PyObject * obj5 = 0 ;
43289 char *kwnames[] = {
43290 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43291 };
43292
43293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43295 if (SWIG_arg_fail(1)) SWIG_fail;
43296 {
43297 arg2 = &temp2;
43298 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43299 }
43300 {
43301 arg3 = &temp3;
43302 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43303 }
43304 {
43305 arg4 = static_cast<int >(SWIG_As_int(obj3));
43306 if (SWIG_arg_fail(4)) SWIG_fail;
43307 }
43308 {
43309 arg5 = static_cast<int >(SWIG_As_int(obj4));
43310 if (SWIG_arg_fail(5)) SWIG_fail;
43311 }
43312 if (obj5) {
43313 arg6 = obj5;
43314 }
43315 {
43316 PyThreadState* __tstate = wxPyBeginAllowThreads();
43317 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43318
43319 wxPyEndAllowThreads(__tstate);
43320 if (PyErr_Occurred()) SWIG_fail;
43321 }
43322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43323 return resultobj;
43324 fail:
43325 return NULL;
43326 }
43327
43328
43329 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43330 PyObject *resultobj = NULL;
43331 wxSizer *arg1 = (wxSizer *) 0 ;
43332 wxGBPosition *arg2 = 0 ;
43333 wxGBSpan *arg3 = 0 ;
43334 int arg4 ;
43335 int arg5 ;
43336 PyObject *arg6 = (PyObject *) NULL ;
43337 wxGBSizerItem *result;
43338 wxGBPosition temp2 ;
43339 wxGBSpan temp3 ;
43340 PyObject * obj0 = 0 ;
43341 PyObject * obj1 = 0 ;
43342 PyObject * obj2 = 0 ;
43343 PyObject * obj3 = 0 ;
43344 PyObject * obj4 = 0 ;
43345 PyObject * obj5 = 0 ;
43346 char *kwnames[] = {
43347 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43348 };
43349
43350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43352 if (SWIG_arg_fail(1)) SWIG_fail;
43353 {
43354 arg2 = &temp2;
43355 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43356 }
43357 {
43358 arg3 = &temp3;
43359 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43360 }
43361 {
43362 arg4 = static_cast<int >(SWIG_As_int(obj3));
43363 if (SWIG_arg_fail(4)) SWIG_fail;
43364 }
43365 {
43366 arg5 = static_cast<int >(SWIG_As_int(obj4));
43367 if (SWIG_arg_fail(5)) SWIG_fail;
43368 }
43369 if (obj5) {
43370 arg6 = obj5;
43371 }
43372 {
43373 PyThreadState* __tstate = wxPyBeginAllowThreads();
43374 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43375
43376 wxPyEndAllowThreads(__tstate);
43377 if (PyErr_Occurred()) SWIG_fail;
43378 }
43379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43380 return resultobj;
43381 fail:
43382 return NULL;
43383 }
43384
43385
43386 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43387 PyObject *resultobj = NULL;
43388 int arg1 ;
43389 int arg2 ;
43390 wxGBPosition *arg3 = 0 ;
43391 wxGBSpan *arg4 = 0 ;
43392 int arg5 ;
43393 int arg6 ;
43394 PyObject *arg7 = (PyObject *) NULL ;
43395 wxGBSizerItem *result;
43396 wxGBPosition temp3 ;
43397 wxGBSpan temp4 ;
43398 PyObject * obj0 = 0 ;
43399 PyObject * obj1 = 0 ;
43400 PyObject * obj2 = 0 ;
43401 PyObject * obj3 = 0 ;
43402 PyObject * obj4 = 0 ;
43403 PyObject * obj5 = 0 ;
43404 PyObject * obj6 = 0 ;
43405 char *kwnames[] = {
43406 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43407 };
43408
43409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43410 {
43411 arg1 = static_cast<int >(SWIG_As_int(obj0));
43412 if (SWIG_arg_fail(1)) SWIG_fail;
43413 }
43414 {
43415 arg2 = static_cast<int >(SWIG_As_int(obj1));
43416 if (SWIG_arg_fail(2)) SWIG_fail;
43417 }
43418 {
43419 arg3 = &temp3;
43420 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43421 }
43422 {
43423 arg4 = &temp4;
43424 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43425 }
43426 {
43427 arg5 = static_cast<int >(SWIG_As_int(obj4));
43428 if (SWIG_arg_fail(5)) SWIG_fail;
43429 }
43430 {
43431 arg6 = static_cast<int >(SWIG_As_int(obj5));
43432 if (SWIG_arg_fail(6)) SWIG_fail;
43433 }
43434 if (obj6) {
43435 arg7 = obj6;
43436 }
43437 {
43438 PyThreadState* __tstate = wxPyBeginAllowThreads();
43439 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43440
43441 wxPyEndAllowThreads(__tstate);
43442 if (PyErr_Occurred()) SWIG_fail;
43443 }
43444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43452 PyObject *resultobj = NULL;
43453 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43454 wxGBPosition result;
43455 PyObject * obj0 = 0 ;
43456 char *kwnames[] = {
43457 (char *) "self", NULL
43458 };
43459
43460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43462 if (SWIG_arg_fail(1)) SWIG_fail;
43463 {
43464 PyThreadState* __tstate = wxPyBeginAllowThreads();
43465 result = ((wxGBSizerItem const *)arg1)->GetPos();
43466
43467 wxPyEndAllowThreads(__tstate);
43468 if (PyErr_Occurred()) SWIG_fail;
43469 }
43470 {
43471 wxGBPosition * resultptr;
43472 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43474 }
43475 return resultobj;
43476 fail:
43477 return NULL;
43478 }
43479
43480
43481 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43482 PyObject *resultobj = NULL;
43483 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43484 wxGBSpan result;
43485 PyObject * obj0 = 0 ;
43486 char *kwnames[] = {
43487 (char *) "self", NULL
43488 };
43489
43490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43492 if (SWIG_arg_fail(1)) SWIG_fail;
43493 {
43494 PyThreadState* __tstate = wxPyBeginAllowThreads();
43495 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43496
43497 wxPyEndAllowThreads(__tstate);
43498 if (PyErr_Occurred()) SWIG_fail;
43499 }
43500 {
43501 wxGBSpan * resultptr;
43502 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43504 }
43505 return resultobj;
43506 fail:
43507 return NULL;
43508 }
43509
43510
43511 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43512 PyObject *resultobj = NULL;
43513 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43514 wxGBPosition *arg2 = 0 ;
43515 bool result;
43516 wxGBPosition temp2 ;
43517 PyObject * obj0 = 0 ;
43518 PyObject * obj1 = 0 ;
43519 char *kwnames[] = {
43520 (char *) "self",(char *) "pos", NULL
43521 };
43522
43523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43525 if (SWIG_arg_fail(1)) SWIG_fail;
43526 {
43527 arg2 = &temp2;
43528 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43529 }
43530 {
43531 PyThreadState* __tstate = wxPyBeginAllowThreads();
43532 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43533
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 {
43538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43539 }
43540 return resultobj;
43541 fail:
43542 return NULL;
43543 }
43544
43545
43546 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43547 PyObject *resultobj = NULL;
43548 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43549 wxGBSpan *arg2 = 0 ;
43550 bool result;
43551 wxGBSpan temp2 ;
43552 PyObject * obj0 = 0 ;
43553 PyObject * obj1 = 0 ;
43554 char *kwnames[] = {
43555 (char *) "self",(char *) "span", NULL
43556 };
43557
43558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43560 if (SWIG_arg_fail(1)) SWIG_fail;
43561 {
43562 arg2 = &temp2;
43563 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43564 }
43565 {
43566 PyThreadState* __tstate = wxPyBeginAllowThreads();
43567 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43568
43569 wxPyEndAllowThreads(__tstate);
43570 if (PyErr_Occurred()) SWIG_fail;
43571 }
43572 {
43573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43574 }
43575 return resultobj;
43576 fail:
43577 return NULL;
43578 }
43579
43580
43581 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43582 PyObject *resultobj = NULL;
43583 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43584 wxGBSizerItem *arg2 = 0 ;
43585 bool result;
43586 PyObject * obj0 = 0 ;
43587 PyObject * obj1 = 0 ;
43588 char *kwnames[] = {
43589 (char *) "self",(char *) "other", NULL
43590 };
43591
43592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43594 if (SWIG_arg_fail(1)) SWIG_fail;
43595 {
43596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43597 if (SWIG_arg_fail(2)) SWIG_fail;
43598 if (arg2 == NULL) {
43599 SWIG_null_ref("wxGBSizerItem");
43600 }
43601 if (SWIG_arg_fail(2)) SWIG_fail;
43602 }
43603 {
43604 PyThreadState* __tstate = wxPyBeginAllowThreads();
43605 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43606
43607 wxPyEndAllowThreads(__tstate);
43608 if (PyErr_Occurred()) SWIG_fail;
43609 }
43610 {
43611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43612 }
43613 return resultobj;
43614 fail:
43615 return NULL;
43616 }
43617
43618
43619 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43620 PyObject *resultobj = NULL;
43621 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43622 wxGBPosition *arg2 = 0 ;
43623 wxGBSpan *arg3 = 0 ;
43624 bool result;
43625 wxGBPosition temp2 ;
43626 wxGBSpan temp3 ;
43627 PyObject * obj0 = 0 ;
43628 PyObject * obj1 = 0 ;
43629 PyObject * obj2 = 0 ;
43630 char *kwnames[] = {
43631 (char *) "self",(char *) "pos",(char *) "span", NULL
43632 };
43633
43634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43636 if (SWIG_arg_fail(1)) SWIG_fail;
43637 {
43638 arg2 = &temp2;
43639 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43640 }
43641 {
43642 arg3 = &temp3;
43643 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43644 }
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43648
43649 wxPyEndAllowThreads(__tstate);
43650 if (PyErr_Occurred()) SWIG_fail;
43651 }
43652 {
43653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43654 }
43655 return resultobj;
43656 fail:
43657 return NULL;
43658 }
43659
43660
43661 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43662 PyObject *resultobj = NULL;
43663 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43664 wxGBPosition result;
43665 PyObject * obj0 = 0 ;
43666 char *kwnames[] = {
43667 (char *) "self", NULL
43668 };
43669
43670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43672 if (SWIG_arg_fail(1)) SWIG_fail;
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 result = wxGBSizerItem_GetEndPos(arg1);
43676
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 {
43681 wxGBPosition * resultptr;
43682 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43683 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43684 }
43685 return resultobj;
43686 fail:
43687 return NULL;
43688 }
43689
43690
43691 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43692 PyObject *resultobj = NULL;
43693 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43694 wxGridBagSizer *result;
43695 PyObject * obj0 = 0 ;
43696 char *kwnames[] = {
43697 (char *) "self", NULL
43698 };
43699
43700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43702 if (SWIG_arg_fail(1)) SWIG_fail;
43703 {
43704 PyThreadState* __tstate = wxPyBeginAllowThreads();
43705 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43706
43707 wxPyEndAllowThreads(__tstate);
43708 if (PyErr_Occurred()) SWIG_fail;
43709 }
43710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43711 return resultobj;
43712 fail:
43713 return NULL;
43714 }
43715
43716
43717 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43718 PyObject *resultobj = NULL;
43719 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43720 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43721 PyObject * obj0 = 0 ;
43722 PyObject * obj1 = 0 ;
43723 char *kwnames[] = {
43724 (char *) "self",(char *) "sizer", NULL
43725 };
43726
43727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43729 if (SWIG_arg_fail(1)) SWIG_fail;
43730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43731 if (SWIG_arg_fail(2)) SWIG_fail;
43732 {
43733 PyThreadState* __tstate = wxPyBeginAllowThreads();
43734 (arg1)->SetGBSizer(arg2);
43735
43736 wxPyEndAllowThreads(__tstate);
43737 if (PyErr_Occurred()) SWIG_fail;
43738 }
43739 Py_INCREF(Py_None); resultobj = Py_None;
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43747 PyObject *obj;
43748 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43749 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43750 Py_INCREF(obj);
43751 return Py_BuildValue((char *)"");
43752 }
43753 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43754 PyObject *resultobj = NULL;
43755 int arg1 = (int) 0 ;
43756 int arg2 = (int) 0 ;
43757 wxGridBagSizer *result;
43758 PyObject * obj0 = 0 ;
43759 PyObject * obj1 = 0 ;
43760 char *kwnames[] = {
43761 (char *) "vgap",(char *) "hgap", NULL
43762 };
43763
43764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43765 if (obj0) {
43766 {
43767 arg1 = static_cast<int >(SWIG_As_int(obj0));
43768 if (SWIG_arg_fail(1)) SWIG_fail;
43769 }
43770 }
43771 if (obj1) {
43772 {
43773 arg2 = static_cast<int >(SWIG_As_int(obj1));
43774 if (SWIG_arg_fail(2)) SWIG_fail;
43775 }
43776 }
43777 {
43778 PyThreadState* __tstate = wxPyBeginAllowThreads();
43779 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43780
43781 wxPyEndAllowThreads(__tstate);
43782 if (PyErr_Occurred()) SWIG_fail;
43783 }
43784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43785 return resultobj;
43786 fail:
43787 return NULL;
43788 }
43789
43790
43791 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43792 PyObject *resultobj = NULL;
43793 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43794 PyObject *arg2 = (PyObject *) 0 ;
43795 wxGBPosition *arg3 = 0 ;
43796 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43797 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43798 int arg5 = (int) 0 ;
43799 int arg6 = (int) 0 ;
43800 PyObject *arg7 = (PyObject *) NULL ;
43801 wxGBSizerItem *result;
43802 wxGBPosition temp3 ;
43803 wxGBSpan temp4 ;
43804 PyObject * obj0 = 0 ;
43805 PyObject * obj1 = 0 ;
43806 PyObject * obj2 = 0 ;
43807 PyObject * obj3 = 0 ;
43808 PyObject * obj4 = 0 ;
43809 PyObject * obj5 = 0 ;
43810 PyObject * obj6 = 0 ;
43811 char *kwnames[] = {
43812 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43813 };
43814
43815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43817 if (SWIG_arg_fail(1)) SWIG_fail;
43818 arg2 = obj1;
43819 {
43820 arg3 = &temp3;
43821 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43822 }
43823 if (obj3) {
43824 {
43825 arg4 = &temp4;
43826 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43827 }
43828 }
43829 if (obj4) {
43830 {
43831 arg5 = static_cast<int >(SWIG_As_int(obj4));
43832 if (SWIG_arg_fail(5)) SWIG_fail;
43833 }
43834 }
43835 if (obj5) {
43836 {
43837 arg6 = static_cast<int >(SWIG_As_int(obj5));
43838 if (SWIG_arg_fail(6)) SWIG_fail;
43839 }
43840 }
43841 if (obj6) {
43842 arg7 = obj6;
43843 }
43844 {
43845 PyThreadState* __tstate = wxPyBeginAllowThreads();
43846 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43847
43848 wxPyEndAllowThreads(__tstate);
43849 if (PyErr_Occurred()) SWIG_fail;
43850 }
43851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43852 return resultobj;
43853 fail:
43854 return NULL;
43855 }
43856
43857
43858 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43859 PyObject *resultobj = NULL;
43860 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43861 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43862 wxGBSizerItem *result;
43863 PyObject * obj0 = 0 ;
43864 PyObject * obj1 = 0 ;
43865 char *kwnames[] = {
43866 (char *) "self",(char *) "item", NULL
43867 };
43868
43869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43871 if (SWIG_arg_fail(1)) SWIG_fail;
43872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43873 if (SWIG_arg_fail(2)) SWIG_fail;
43874 {
43875 PyThreadState* __tstate = wxPyBeginAllowThreads();
43876 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43877
43878 wxPyEndAllowThreads(__tstate);
43879 if (PyErr_Occurred()) SWIG_fail;
43880 }
43881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43882 return resultobj;
43883 fail:
43884 return NULL;
43885 }
43886
43887
43888 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43889 PyObject *resultobj = NULL;
43890 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43891 int arg2 ;
43892 int arg3 ;
43893 wxSize result;
43894 PyObject * obj0 = 0 ;
43895 PyObject * obj1 = 0 ;
43896 PyObject * obj2 = 0 ;
43897 char *kwnames[] = {
43898 (char *) "self",(char *) "row",(char *) "col", NULL
43899 };
43900
43901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43903 if (SWIG_arg_fail(1)) SWIG_fail;
43904 {
43905 arg2 = static_cast<int >(SWIG_As_int(obj1));
43906 if (SWIG_arg_fail(2)) SWIG_fail;
43907 }
43908 {
43909 arg3 = static_cast<int >(SWIG_As_int(obj2));
43910 if (SWIG_arg_fail(3)) SWIG_fail;
43911 }
43912 {
43913 PyThreadState* __tstate = wxPyBeginAllowThreads();
43914 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43915
43916 wxPyEndAllowThreads(__tstate);
43917 if (PyErr_Occurred()) SWIG_fail;
43918 }
43919 {
43920 wxSize * resultptr;
43921 resultptr = new wxSize(static_cast<wxSize & >(result));
43922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43923 }
43924 return resultobj;
43925 fail:
43926 return NULL;
43927 }
43928
43929
43930 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43931 PyObject *resultobj = NULL;
43932 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43933 wxSize result;
43934 PyObject * obj0 = 0 ;
43935 char *kwnames[] = {
43936 (char *) "self", NULL
43937 };
43938
43939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43941 if (SWIG_arg_fail(1)) SWIG_fail;
43942 {
43943 PyThreadState* __tstate = wxPyBeginAllowThreads();
43944 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43945
43946 wxPyEndAllowThreads(__tstate);
43947 if (PyErr_Occurred()) SWIG_fail;
43948 }
43949 {
43950 wxSize * resultptr;
43951 resultptr = new wxSize(static_cast<wxSize & >(result));
43952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43953 }
43954 return resultobj;
43955 fail:
43956 return NULL;
43957 }
43958
43959
43960 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43961 PyObject *resultobj = NULL;
43962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43963 wxSize *arg2 = 0 ;
43964 wxSize temp2 ;
43965 PyObject * obj0 = 0 ;
43966 PyObject * obj1 = 0 ;
43967 char *kwnames[] = {
43968 (char *) "self",(char *) "sz", NULL
43969 };
43970
43971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43973 if (SWIG_arg_fail(1)) SWIG_fail;
43974 {
43975 arg2 = &temp2;
43976 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43977 }
43978 {
43979 PyThreadState* __tstate = wxPyBeginAllowThreads();
43980 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43981
43982 wxPyEndAllowThreads(__tstate);
43983 if (PyErr_Occurred()) SWIG_fail;
43984 }
43985 Py_INCREF(Py_None); resultobj = Py_None;
43986 return resultobj;
43987 fail:
43988 return NULL;
43989 }
43990
43991
43992 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43993 PyObject *resultobj = NULL;
43994 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43995 wxWindow *arg2 = (wxWindow *) 0 ;
43996 wxGBPosition result;
43997 PyObject * obj0 = 0 ;
43998 PyObject * obj1 = 0 ;
43999
44000 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44002 if (SWIG_arg_fail(1)) SWIG_fail;
44003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44004 if (SWIG_arg_fail(2)) SWIG_fail;
44005 {
44006 PyThreadState* __tstate = wxPyBeginAllowThreads();
44007 result = (arg1)->GetItemPosition(arg2);
44008
44009 wxPyEndAllowThreads(__tstate);
44010 if (PyErr_Occurred()) SWIG_fail;
44011 }
44012 {
44013 wxGBPosition * resultptr;
44014 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44016 }
44017 return resultobj;
44018 fail:
44019 return NULL;
44020 }
44021
44022
44023 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44024 PyObject *resultobj = NULL;
44025 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44026 wxSizer *arg2 = (wxSizer *) 0 ;
44027 wxGBPosition result;
44028 PyObject * obj0 = 0 ;
44029 PyObject * obj1 = 0 ;
44030
44031 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44033 if (SWIG_arg_fail(1)) SWIG_fail;
44034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44035 if (SWIG_arg_fail(2)) SWIG_fail;
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 result = (arg1)->GetItemPosition(arg2);
44039
44040 wxPyEndAllowThreads(__tstate);
44041 if (PyErr_Occurred()) SWIG_fail;
44042 }
44043 {
44044 wxGBPosition * resultptr;
44045 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44046 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44047 }
44048 return resultobj;
44049 fail:
44050 return NULL;
44051 }
44052
44053
44054 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44055 PyObject *resultobj = NULL;
44056 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44057 size_t arg2 ;
44058 wxGBPosition result;
44059 PyObject * obj0 = 0 ;
44060 PyObject * obj1 = 0 ;
44061
44062 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44064 if (SWIG_arg_fail(1)) SWIG_fail;
44065 {
44066 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44067 if (SWIG_arg_fail(2)) SWIG_fail;
44068 }
44069 {
44070 PyThreadState* __tstate = wxPyBeginAllowThreads();
44071 result = (arg1)->GetItemPosition(arg2);
44072
44073 wxPyEndAllowThreads(__tstate);
44074 if (PyErr_Occurred()) SWIG_fail;
44075 }
44076 {
44077 wxGBPosition * resultptr;
44078 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44080 }
44081 return resultobj;
44082 fail:
44083 return NULL;
44084 }
44085
44086
44087 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44088 int argc;
44089 PyObject *argv[3];
44090 int ii;
44091
44092 argc = PyObject_Length(args);
44093 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44094 argv[ii] = PyTuple_GetItem(args,ii);
44095 }
44096 if (argc == 2) {
44097 int _v;
44098 {
44099 void *ptr;
44100 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44101 _v = 0;
44102 PyErr_Clear();
44103 } else {
44104 _v = 1;
44105 }
44106 }
44107 if (_v) {
44108 {
44109 void *ptr;
44110 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44111 _v = 0;
44112 PyErr_Clear();
44113 } else {
44114 _v = 1;
44115 }
44116 }
44117 if (_v) {
44118 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44119 }
44120 }
44121 }
44122 if (argc == 2) {
44123 int _v;
44124 {
44125 void *ptr;
44126 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44127 _v = 0;
44128 PyErr_Clear();
44129 } else {
44130 _v = 1;
44131 }
44132 }
44133 if (_v) {
44134 {
44135 void *ptr;
44136 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44137 _v = 0;
44138 PyErr_Clear();
44139 } else {
44140 _v = 1;
44141 }
44142 }
44143 if (_v) {
44144 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44145 }
44146 }
44147 }
44148 if (argc == 2) {
44149 int _v;
44150 {
44151 void *ptr;
44152 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44153 _v = 0;
44154 PyErr_Clear();
44155 } else {
44156 _v = 1;
44157 }
44158 }
44159 if (_v) {
44160 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44161 if (_v) {
44162 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44163 }
44164 }
44165 }
44166
44167 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44168 return NULL;
44169 }
44170
44171
44172 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44173 PyObject *resultobj = NULL;
44174 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44175 wxWindow *arg2 = (wxWindow *) 0 ;
44176 wxGBPosition *arg3 = 0 ;
44177 bool result;
44178 wxGBPosition temp3 ;
44179 PyObject * obj0 = 0 ;
44180 PyObject * obj1 = 0 ;
44181 PyObject * obj2 = 0 ;
44182
44183 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44185 if (SWIG_arg_fail(1)) SWIG_fail;
44186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44187 if (SWIG_arg_fail(2)) SWIG_fail;
44188 {
44189 arg3 = &temp3;
44190 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44191 }
44192 {
44193 PyThreadState* __tstate = wxPyBeginAllowThreads();
44194 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44195
44196 wxPyEndAllowThreads(__tstate);
44197 if (PyErr_Occurred()) SWIG_fail;
44198 }
44199 {
44200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44201 }
44202 return resultobj;
44203 fail:
44204 return NULL;
44205 }
44206
44207
44208 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44209 PyObject *resultobj = NULL;
44210 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44211 wxSizer *arg2 = (wxSizer *) 0 ;
44212 wxGBPosition *arg3 = 0 ;
44213 bool result;
44214 wxGBPosition temp3 ;
44215 PyObject * obj0 = 0 ;
44216 PyObject * obj1 = 0 ;
44217 PyObject * obj2 = 0 ;
44218
44219 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44221 if (SWIG_arg_fail(1)) SWIG_fail;
44222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44223 if (SWIG_arg_fail(2)) SWIG_fail;
44224 {
44225 arg3 = &temp3;
44226 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44227 }
44228 {
44229 PyThreadState* __tstate = wxPyBeginAllowThreads();
44230 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44231
44232 wxPyEndAllowThreads(__tstate);
44233 if (PyErr_Occurred()) SWIG_fail;
44234 }
44235 {
44236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44237 }
44238 return resultobj;
44239 fail:
44240 return NULL;
44241 }
44242
44243
44244 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44245 PyObject *resultobj = NULL;
44246 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44247 size_t arg2 ;
44248 wxGBPosition *arg3 = 0 ;
44249 bool result;
44250 wxGBPosition temp3 ;
44251 PyObject * obj0 = 0 ;
44252 PyObject * obj1 = 0 ;
44253 PyObject * obj2 = 0 ;
44254
44255 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44257 if (SWIG_arg_fail(1)) SWIG_fail;
44258 {
44259 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44260 if (SWIG_arg_fail(2)) SWIG_fail;
44261 }
44262 {
44263 arg3 = &temp3;
44264 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44265 }
44266 {
44267 PyThreadState* __tstate = wxPyBeginAllowThreads();
44268 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44269
44270 wxPyEndAllowThreads(__tstate);
44271 if (PyErr_Occurred()) SWIG_fail;
44272 }
44273 {
44274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44275 }
44276 return resultobj;
44277 fail:
44278 return NULL;
44279 }
44280
44281
44282 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44283 int argc;
44284 PyObject *argv[4];
44285 int ii;
44286
44287 argc = PyObject_Length(args);
44288 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44289 argv[ii] = PyTuple_GetItem(args,ii);
44290 }
44291 if (argc == 3) {
44292 int _v;
44293 {
44294 void *ptr;
44295 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44296 _v = 0;
44297 PyErr_Clear();
44298 } else {
44299 _v = 1;
44300 }
44301 }
44302 if (_v) {
44303 {
44304 void *ptr;
44305 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44306 _v = 0;
44307 PyErr_Clear();
44308 } else {
44309 _v = 1;
44310 }
44311 }
44312 if (_v) {
44313 {
44314 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44315 }
44316 if (_v) {
44317 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44318 }
44319 }
44320 }
44321 }
44322 if (argc == 3) {
44323 int _v;
44324 {
44325 void *ptr;
44326 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44327 _v = 0;
44328 PyErr_Clear();
44329 } else {
44330 _v = 1;
44331 }
44332 }
44333 if (_v) {
44334 {
44335 void *ptr;
44336 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44337 _v = 0;
44338 PyErr_Clear();
44339 } else {
44340 _v = 1;
44341 }
44342 }
44343 if (_v) {
44344 {
44345 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44346 }
44347 if (_v) {
44348 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44349 }
44350 }
44351 }
44352 }
44353 if (argc == 3) {
44354 int _v;
44355 {
44356 void *ptr;
44357 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44358 _v = 0;
44359 PyErr_Clear();
44360 } else {
44361 _v = 1;
44362 }
44363 }
44364 if (_v) {
44365 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44366 if (_v) {
44367 {
44368 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44369 }
44370 if (_v) {
44371 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44372 }
44373 }
44374 }
44375 }
44376
44377 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44378 return NULL;
44379 }
44380
44381
44382 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44383 PyObject *resultobj = NULL;
44384 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44385 wxWindow *arg2 = (wxWindow *) 0 ;
44386 wxGBSpan result;
44387 PyObject * obj0 = 0 ;
44388 PyObject * obj1 = 0 ;
44389
44390 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44392 if (SWIG_arg_fail(1)) SWIG_fail;
44393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44394 if (SWIG_arg_fail(2)) SWIG_fail;
44395 {
44396 PyThreadState* __tstate = wxPyBeginAllowThreads();
44397 result = (arg1)->GetItemSpan(arg2);
44398
44399 wxPyEndAllowThreads(__tstate);
44400 if (PyErr_Occurred()) SWIG_fail;
44401 }
44402 {
44403 wxGBSpan * resultptr;
44404 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44406 }
44407 return resultobj;
44408 fail:
44409 return NULL;
44410 }
44411
44412
44413 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44414 PyObject *resultobj = NULL;
44415 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44416 wxSizer *arg2 = (wxSizer *) 0 ;
44417 wxGBSpan result;
44418 PyObject * obj0 = 0 ;
44419 PyObject * obj1 = 0 ;
44420
44421 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44423 if (SWIG_arg_fail(1)) SWIG_fail;
44424 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44425 if (SWIG_arg_fail(2)) SWIG_fail;
44426 {
44427 PyThreadState* __tstate = wxPyBeginAllowThreads();
44428 result = (arg1)->GetItemSpan(arg2);
44429
44430 wxPyEndAllowThreads(__tstate);
44431 if (PyErr_Occurred()) SWIG_fail;
44432 }
44433 {
44434 wxGBSpan * resultptr;
44435 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44437 }
44438 return resultobj;
44439 fail:
44440 return NULL;
44441 }
44442
44443
44444 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44445 PyObject *resultobj = NULL;
44446 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44447 size_t arg2 ;
44448 wxGBSpan result;
44449 PyObject * obj0 = 0 ;
44450 PyObject * obj1 = 0 ;
44451
44452 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44454 if (SWIG_arg_fail(1)) SWIG_fail;
44455 {
44456 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44457 if (SWIG_arg_fail(2)) SWIG_fail;
44458 }
44459 {
44460 PyThreadState* __tstate = wxPyBeginAllowThreads();
44461 result = (arg1)->GetItemSpan(arg2);
44462
44463 wxPyEndAllowThreads(__tstate);
44464 if (PyErr_Occurred()) SWIG_fail;
44465 }
44466 {
44467 wxGBSpan * resultptr;
44468 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44470 }
44471 return resultobj;
44472 fail:
44473 return NULL;
44474 }
44475
44476
44477 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44478 int argc;
44479 PyObject *argv[3];
44480 int ii;
44481
44482 argc = PyObject_Length(args);
44483 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44484 argv[ii] = PyTuple_GetItem(args,ii);
44485 }
44486 if (argc == 2) {
44487 int _v;
44488 {
44489 void *ptr;
44490 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44491 _v = 0;
44492 PyErr_Clear();
44493 } else {
44494 _v = 1;
44495 }
44496 }
44497 if (_v) {
44498 {
44499 void *ptr;
44500 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44501 _v = 0;
44502 PyErr_Clear();
44503 } else {
44504 _v = 1;
44505 }
44506 }
44507 if (_v) {
44508 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44509 }
44510 }
44511 }
44512 if (argc == 2) {
44513 int _v;
44514 {
44515 void *ptr;
44516 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44517 _v = 0;
44518 PyErr_Clear();
44519 } else {
44520 _v = 1;
44521 }
44522 }
44523 if (_v) {
44524 {
44525 void *ptr;
44526 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44527 _v = 0;
44528 PyErr_Clear();
44529 } else {
44530 _v = 1;
44531 }
44532 }
44533 if (_v) {
44534 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44535 }
44536 }
44537 }
44538 if (argc == 2) {
44539 int _v;
44540 {
44541 void *ptr;
44542 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44543 _v = 0;
44544 PyErr_Clear();
44545 } else {
44546 _v = 1;
44547 }
44548 }
44549 if (_v) {
44550 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44551 if (_v) {
44552 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44553 }
44554 }
44555 }
44556
44557 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44558 return NULL;
44559 }
44560
44561
44562 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44563 PyObject *resultobj = NULL;
44564 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44565 wxWindow *arg2 = (wxWindow *) 0 ;
44566 wxGBSpan *arg3 = 0 ;
44567 bool result;
44568 wxGBSpan temp3 ;
44569 PyObject * obj0 = 0 ;
44570 PyObject * obj1 = 0 ;
44571 PyObject * obj2 = 0 ;
44572
44573 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44575 if (SWIG_arg_fail(1)) SWIG_fail;
44576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44577 if (SWIG_arg_fail(2)) SWIG_fail;
44578 {
44579 arg3 = &temp3;
44580 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44581 }
44582 {
44583 PyThreadState* __tstate = wxPyBeginAllowThreads();
44584 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44585
44586 wxPyEndAllowThreads(__tstate);
44587 if (PyErr_Occurred()) SWIG_fail;
44588 }
44589 {
44590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44591 }
44592 return resultobj;
44593 fail:
44594 return NULL;
44595 }
44596
44597
44598 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44599 PyObject *resultobj = NULL;
44600 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44601 wxSizer *arg2 = (wxSizer *) 0 ;
44602 wxGBSpan *arg3 = 0 ;
44603 bool result;
44604 wxGBSpan temp3 ;
44605 PyObject * obj0 = 0 ;
44606 PyObject * obj1 = 0 ;
44607 PyObject * obj2 = 0 ;
44608
44609 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44611 if (SWIG_arg_fail(1)) SWIG_fail;
44612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44613 if (SWIG_arg_fail(2)) SWIG_fail;
44614 {
44615 arg3 = &temp3;
44616 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44617 }
44618 {
44619 PyThreadState* __tstate = wxPyBeginAllowThreads();
44620 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44621
44622 wxPyEndAllowThreads(__tstate);
44623 if (PyErr_Occurred()) SWIG_fail;
44624 }
44625 {
44626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44627 }
44628 return resultobj;
44629 fail:
44630 return NULL;
44631 }
44632
44633
44634 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44635 PyObject *resultobj = NULL;
44636 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44637 size_t arg2 ;
44638 wxGBSpan *arg3 = 0 ;
44639 bool result;
44640 wxGBSpan temp3 ;
44641 PyObject * obj0 = 0 ;
44642 PyObject * obj1 = 0 ;
44643 PyObject * obj2 = 0 ;
44644
44645 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44647 if (SWIG_arg_fail(1)) SWIG_fail;
44648 {
44649 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44650 if (SWIG_arg_fail(2)) SWIG_fail;
44651 }
44652 {
44653 arg3 = &temp3;
44654 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44655 }
44656 {
44657 PyThreadState* __tstate = wxPyBeginAllowThreads();
44658 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44659
44660 wxPyEndAllowThreads(__tstate);
44661 if (PyErr_Occurred()) SWIG_fail;
44662 }
44663 {
44664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44665 }
44666 return resultobj;
44667 fail:
44668 return NULL;
44669 }
44670
44671
44672 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44673 int argc;
44674 PyObject *argv[4];
44675 int ii;
44676
44677 argc = PyObject_Length(args);
44678 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44679 argv[ii] = PyTuple_GetItem(args,ii);
44680 }
44681 if (argc == 3) {
44682 int _v;
44683 {
44684 void *ptr;
44685 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44686 _v = 0;
44687 PyErr_Clear();
44688 } else {
44689 _v = 1;
44690 }
44691 }
44692 if (_v) {
44693 {
44694 void *ptr;
44695 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44696 _v = 0;
44697 PyErr_Clear();
44698 } else {
44699 _v = 1;
44700 }
44701 }
44702 if (_v) {
44703 {
44704 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44705 }
44706 if (_v) {
44707 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44708 }
44709 }
44710 }
44711 }
44712 if (argc == 3) {
44713 int _v;
44714 {
44715 void *ptr;
44716 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44717 _v = 0;
44718 PyErr_Clear();
44719 } else {
44720 _v = 1;
44721 }
44722 }
44723 if (_v) {
44724 {
44725 void *ptr;
44726 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44727 _v = 0;
44728 PyErr_Clear();
44729 } else {
44730 _v = 1;
44731 }
44732 }
44733 if (_v) {
44734 {
44735 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44736 }
44737 if (_v) {
44738 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44739 }
44740 }
44741 }
44742 }
44743 if (argc == 3) {
44744 int _v;
44745 {
44746 void *ptr;
44747 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44748 _v = 0;
44749 PyErr_Clear();
44750 } else {
44751 _v = 1;
44752 }
44753 }
44754 if (_v) {
44755 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44756 if (_v) {
44757 {
44758 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44759 }
44760 if (_v) {
44761 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44762 }
44763 }
44764 }
44765 }
44766
44767 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44768 return NULL;
44769 }
44770
44771
44772 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44773 PyObject *resultobj = NULL;
44774 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44775 wxWindow *arg2 = (wxWindow *) 0 ;
44776 wxGBSizerItem *result;
44777 PyObject * obj0 = 0 ;
44778 PyObject * obj1 = 0 ;
44779
44780 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44782 if (SWIG_arg_fail(1)) SWIG_fail;
44783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44784 if (SWIG_arg_fail(2)) SWIG_fail;
44785 {
44786 PyThreadState* __tstate = wxPyBeginAllowThreads();
44787 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44788
44789 wxPyEndAllowThreads(__tstate);
44790 if (PyErr_Occurred()) SWIG_fail;
44791 }
44792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44793 return resultobj;
44794 fail:
44795 return NULL;
44796 }
44797
44798
44799 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44800 PyObject *resultobj = NULL;
44801 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44802 wxSizer *arg2 = (wxSizer *) 0 ;
44803 wxGBSizerItem *result;
44804 PyObject * obj0 = 0 ;
44805 PyObject * obj1 = 0 ;
44806
44807 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44809 if (SWIG_arg_fail(1)) SWIG_fail;
44810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44811 if (SWIG_arg_fail(2)) SWIG_fail;
44812 {
44813 PyThreadState* __tstate = wxPyBeginAllowThreads();
44814 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44815
44816 wxPyEndAllowThreads(__tstate);
44817 if (PyErr_Occurred()) SWIG_fail;
44818 }
44819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44820 return resultobj;
44821 fail:
44822 return NULL;
44823 }
44824
44825
44826 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44827 int argc;
44828 PyObject *argv[3];
44829 int ii;
44830
44831 argc = PyObject_Length(args);
44832 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44833 argv[ii] = PyTuple_GetItem(args,ii);
44834 }
44835 if (argc == 2) {
44836 int _v;
44837 {
44838 void *ptr;
44839 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44840 _v = 0;
44841 PyErr_Clear();
44842 } else {
44843 _v = 1;
44844 }
44845 }
44846 if (_v) {
44847 {
44848 void *ptr;
44849 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44850 _v = 0;
44851 PyErr_Clear();
44852 } else {
44853 _v = 1;
44854 }
44855 }
44856 if (_v) {
44857 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44858 }
44859 }
44860 }
44861 if (argc == 2) {
44862 int _v;
44863 {
44864 void *ptr;
44865 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44866 _v = 0;
44867 PyErr_Clear();
44868 } else {
44869 _v = 1;
44870 }
44871 }
44872 if (_v) {
44873 {
44874 void *ptr;
44875 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44876 _v = 0;
44877 PyErr_Clear();
44878 } else {
44879 _v = 1;
44880 }
44881 }
44882 if (_v) {
44883 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44884 }
44885 }
44886 }
44887
44888 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44889 return NULL;
44890 }
44891
44892
44893 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44894 PyObject *resultobj = NULL;
44895 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44896 wxGBPosition *arg2 = 0 ;
44897 wxGBSizerItem *result;
44898 wxGBPosition temp2 ;
44899 PyObject * obj0 = 0 ;
44900 PyObject * obj1 = 0 ;
44901 char *kwnames[] = {
44902 (char *) "self",(char *) "pos", NULL
44903 };
44904
44905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44907 if (SWIG_arg_fail(1)) SWIG_fail;
44908 {
44909 arg2 = &temp2;
44910 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44911 }
44912 {
44913 PyThreadState* __tstate = wxPyBeginAllowThreads();
44914 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44915
44916 wxPyEndAllowThreads(__tstate);
44917 if (PyErr_Occurred()) SWIG_fail;
44918 }
44919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44920 return resultobj;
44921 fail:
44922 return NULL;
44923 }
44924
44925
44926 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44927 PyObject *resultobj = NULL;
44928 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44929 wxPoint *arg2 = 0 ;
44930 wxGBSizerItem *result;
44931 wxPoint temp2 ;
44932 PyObject * obj0 = 0 ;
44933 PyObject * obj1 = 0 ;
44934 char *kwnames[] = {
44935 (char *) "self",(char *) "pt", NULL
44936 };
44937
44938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44940 if (SWIG_arg_fail(1)) SWIG_fail;
44941 {
44942 arg2 = &temp2;
44943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44944 }
44945 {
44946 PyThreadState* __tstate = wxPyBeginAllowThreads();
44947 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44948
44949 wxPyEndAllowThreads(__tstate);
44950 if (PyErr_Occurred()) SWIG_fail;
44951 }
44952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44953 return resultobj;
44954 fail:
44955 return NULL;
44956 }
44957
44958
44959 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44960 PyObject *resultobj = NULL;
44961 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44962 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44963 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44964 bool result;
44965 PyObject * obj0 = 0 ;
44966 PyObject * obj1 = 0 ;
44967 PyObject * obj2 = 0 ;
44968 char *kwnames[] = {
44969 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44970 };
44971
44972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44974 if (SWIG_arg_fail(1)) SWIG_fail;
44975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44976 if (SWIG_arg_fail(2)) SWIG_fail;
44977 if (obj2) {
44978 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44979 if (SWIG_arg_fail(3)) SWIG_fail;
44980 }
44981 {
44982 PyThreadState* __tstate = wxPyBeginAllowThreads();
44983 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44984
44985 wxPyEndAllowThreads(__tstate);
44986 if (PyErr_Occurred()) SWIG_fail;
44987 }
44988 {
44989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44990 }
44991 return resultobj;
44992 fail:
44993 return NULL;
44994 }
44995
44996
44997 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44998 PyObject *resultobj = NULL;
44999 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45000 wxGBPosition *arg2 = 0 ;
45001 wxGBSpan *arg3 = 0 ;
45002 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45003 bool result;
45004 wxGBPosition temp2 ;
45005 wxGBSpan temp3 ;
45006 PyObject * obj0 = 0 ;
45007 PyObject * obj1 = 0 ;
45008 PyObject * obj2 = 0 ;
45009 PyObject * obj3 = 0 ;
45010 char *kwnames[] = {
45011 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45012 };
45013
45014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45016 if (SWIG_arg_fail(1)) SWIG_fail;
45017 {
45018 arg2 = &temp2;
45019 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45020 }
45021 {
45022 arg3 = &temp3;
45023 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45024 }
45025 if (obj3) {
45026 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45027 if (SWIG_arg_fail(4)) SWIG_fail;
45028 }
45029 {
45030 PyThreadState* __tstate = wxPyBeginAllowThreads();
45031 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45032
45033 wxPyEndAllowThreads(__tstate);
45034 if (PyErr_Occurred()) SWIG_fail;
45035 }
45036 {
45037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45038 }
45039 return resultobj;
45040 fail:
45041 return NULL;
45042 }
45043
45044
45045 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45046 PyObject *obj;
45047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45048 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45049 Py_INCREF(obj);
45050 return Py_BuildValue((char *)"");
45051 }
45052 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj = NULL;
45054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45055 wxRelationship arg2 ;
45056 wxWindow *arg3 = (wxWindow *) 0 ;
45057 wxEdge arg4 ;
45058 int arg5 = (int) 0 ;
45059 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45060 PyObject * obj0 = 0 ;
45061 PyObject * obj1 = 0 ;
45062 PyObject * obj2 = 0 ;
45063 PyObject * obj3 = 0 ;
45064 PyObject * obj4 = 0 ;
45065 PyObject * obj5 = 0 ;
45066 char *kwnames[] = {
45067 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45068 };
45069
45070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45072 if (SWIG_arg_fail(1)) SWIG_fail;
45073 {
45074 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45075 if (SWIG_arg_fail(2)) SWIG_fail;
45076 }
45077 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45078 if (SWIG_arg_fail(3)) SWIG_fail;
45079 {
45080 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45081 if (SWIG_arg_fail(4)) SWIG_fail;
45082 }
45083 if (obj4) {
45084 {
45085 arg5 = static_cast<int >(SWIG_As_int(obj4));
45086 if (SWIG_arg_fail(5)) SWIG_fail;
45087 }
45088 }
45089 if (obj5) {
45090 {
45091 arg6 = static_cast<int >(SWIG_As_int(obj5));
45092 if (SWIG_arg_fail(6)) SWIG_fail;
45093 }
45094 }
45095 {
45096 PyThreadState* __tstate = wxPyBeginAllowThreads();
45097 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45098
45099 wxPyEndAllowThreads(__tstate);
45100 if (PyErr_Occurred()) SWIG_fail;
45101 }
45102 Py_INCREF(Py_None); resultobj = Py_None;
45103 return resultobj;
45104 fail:
45105 return NULL;
45106 }
45107
45108
45109 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45110 PyObject *resultobj = NULL;
45111 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45112 wxWindow *arg2 = (wxWindow *) 0 ;
45113 int arg3 = (int) 0 ;
45114 PyObject * obj0 = 0 ;
45115 PyObject * obj1 = 0 ;
45116 PyObject * obj2 = 0 ;
45117 char *kwnames[] = {
45118 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45119 };
45120
45121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45123 if (SWIG_arg_fail(1)) SWIG_fail;
45124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45125 if (SWIG_arg_fail(2)) SWIG_fail;
45126 if (obj2) {
45127 {
45128 arg3 = static_cast<int >(SWIG_As_int(obj2));
45129 if (SWIG_arg_fail(3)) SWIG_fail;
45130 }
45131 }
45132 {
45133 PyThreadState* __tstate = wxPyBeginAllowThreads();
45134 (arg1)->LeftOf(arg2,arg3);
45135
45136 wxPyEndAllowThreads(__tstate);
45137 if (PyErr_Occurred()) SWIG_fail;
45138 }
45139 Py_INCREF(Py_None); resultobj = Py_None;
45140 return resultobj;
45141 fail:
45142 return NULL;
45143 }
45144
45145
45146 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45147 PyObject *resultobj = NULL;
45148 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45149 wxWindow *arg2 = (wxWindow *) 0 ;
45150 int arg3 = (int) 0 ;
45151 PyObject * obj0 = 0 ;
45152 PyObject * obj1 = 0 ;
45153 PyObject * obj2 = 0 ;
45154 char *kwnames[] = {
45155 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45156 };
45157
45158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45160 if (SWIG_arg_fail(1)) SWIG_fail;
45161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45162 if (SWIG_arg_fail(2)) SWIG_fail;
45163 if (obj2) {
45164 {
45165 arg3 = static_cast<int >(SWIG_As_int(obj2));
45166 if (SWIG_arg_fail(3)) SWIG_fail;
45167 }
45168 }
45169 {
45170 PyThreadState* __tstate = wxPyBeginAllowThreads();
45171 (arg1)->RightOf(arg2,arg3);
45172
45173 wxPyEndAllowThreads(__tstate);
45174 if (PyErr_Occurred()) SWIG_fail;
45175 }
45176 Py_INCREF(Py_None); resultobj = Py_None;
45177 return resultobj;
45178 fail:
45179 return NULL;
45180 }
45181
45182
45183 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45184 PyObject *resultobj = NULL;
45185 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45186 wxWindow *arg2 = (wxWindow *) 0 ;
45187 int arg3 = (int) 0 ;
45188 PyObject * obj0 = 0 ;
45189 PyObject * obj1 = 0 ;
45190 PyObject * obj2 = 0 ;
45191 char *kwnames[] = {
45192 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45193 };
45194
45195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45197 if (SWIG_arg_fail(1)) SWIG_fail;
45198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45199 if (SWIG_arg_fail(2)) SWIG_fail;
45200 if (obj2) {
45201 {
45202 arg3 = static_cast<int >(SWIG_As_int(obj2));
45203 if (SWIG_arg_fail(3)) SWIG_fail;
45204 }
45205 }
45206 {
45207 PyThreadState* __tstate = wxPyBeginAllowThreads();
45208 (arg1)->Above(arg2,arg3);
45209
45210 wxPyEndAllowThreads(__tstate);
45211 if (PyErr_Occurred()) SWIG_fail;
45212 }
45213 Py_INCREF(Py_None); resultobj = Py_None;
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45221 PyObject *resultobj = NULL;
45222 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45223 wxWindow *arg2 = (wxWindow *) 0 ;
45224 int arg3 = (int) 0 ;
45225 PyObject * obj0 = 0 ;
45226 PyObject * obj1 = 0 ;
45227 PyObject * obj2 = 0 ;
45228 char *kwnames[] = {
45229 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45230 };
45231
45232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45234 if (SWIG_arg_fail(1)) SWIG_fail;
45235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45236 if (SWIG_arg_fail(2)) SWIG_fail;
45237 if (obj2) {
45238 {
45239 arg3 = static_cast<int >(SWIG_As_int(obj2));
45240 if (SWIG_arg_fail(3)) SWIG_fail;
45241 }
45242 }
45243 {
45244 PyThreadState* __tstate = wxPyBeginAllowThreads();
45245 (arg1)->Below(arg2,arg3);
45246
45247 wxPyEndAllowThreads(__tstate);
45248 if (PyErr_Occurred()) SWIG_fail;
45249 }
45250 Py_INCREF(Py_None); resultobj = Py_None;
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45258 PyObject *resultobj = NULL;
45259 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45260 wxWindow *arg2 = (wxWindow *) 0 ;
45261 wxEdge arg3 ;
45262 int arg4 = (int) 0 ;
45263 PyObject * obj0 = 0 ;
45264 PyObject * obj1 = 0 ;
45265 PyObject * obj2 = 0 ;
45266 PyObject * obj3 = 0 ;
45267 char *kwnames[] = {
45268 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45269 };
45270
45271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45273 if (SWIG_arg_fail(1)) SWIG_fail;
45274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45275 if (SWIG_arg_fail(2)) SWIG_fail;
45276 {
45277 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45278 if (SWIG_arg_fail(3)) SWIG_fail;
45279 }
45280 if (obj3) {
45281 {
45282 arg4 = static_cast<int >(SWIG_As_int(obj3));
45283 if (SWIG_arg_fail(4)) SWIG_fail;
45284 }
45285 }
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 (arg1)->SameAs(arg2,arg3,arg4);
45289
45290 wxPyEndAllowThreads(__tstate);
45291 if (PyErr_Occurred()) SWIG_fail;
45292 }
45293 Py_INCREF(Py_None); resultobj = Py_None;
45294 return resultobj;
45295 fail:
45296 return NULL;
45297 }
45298
45299
45300 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45301 PyObject *resultobj = NULL;
45302 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45303 wxWindow *arg2 = (wxWindow *) 0 ;
45304 wxEdge arg3 ;
45305 int arg4 ;
45306 PyObject * obj0 = 0 ;
45307 PyObject * obj1 = 0 ;
45308 PyObject * obj2 = 0 ;
45309 PyObject * obj3 = 0 ;
45310 char *kwnames[] = {
45311 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45312 };
45313
45314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45316 if (SWIG_arg_fail(1)) SWIG_fail;
45317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45318 if (SWIG_arg_fail(2)) SWIG_fail;
45319 {
45320 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45321 if (SWIG_arg_fail(3)) SWIG_fail;
45322 }
45323 {
45324 arg4 = static_cast<int >(SWIG_As_int(obj3));
45325 if (SWIG_arg_fail(4)) SWIG_fail;
45326 }
45327 {
45328 PyThreadState* __tstate = wxPyBeginAllowThreads();
45329 (arg1)->PercentOf(arg2,arg3,arg4);
45330
45331 wxPyEndAllowThreads(__tstate);
45332 if (PyErr_Occurred()) SWIG_fail;
45333 }
45334 Py_INCREF(Py_None); resultobj = Py_None;
45335 return resultobj;
45336 fail:
45337 return NULL;
45338 }
45339
45340
45341 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45342 PyObject *resultobj = NULL;
45343 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45344 int arg2 ;
45345 PyObject * obj0 = 0 ;
45346 PyObject * obj1 = 0 ;
45347 char *kwnames[] = {
45348 (char *) "self",(char *) "val", NULL
45349 };
45350
45351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45353 if (SWIG_arg_fail(1)) SWIG_fail;
45354 {
45355 arg2 = static_cast<int >(SWIG_As_int(obj1));
45356 if (SWIG_arg_fail(2)) SWIG_fail;
45357 }
45358 {
45359 PyThreadState* __tstate = wxPyBeginAllowThreads();
45360 (arg1)->Absolute(arg2);
45361
45362 wxPyEndAllowThreads(__tstate);
45363 if (PyErr_Occurred()) SWIG_fail;
45364 }
45365 Py_INCREF(Py_None); resultobj = Py_None;
45366 return resultobj;
45367 fail:
45368 return NULL;
45369 }
45370
45371
45372 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45373 PyObject *resultobj = NULL;
45374 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45375 PyObject * obj0 = 0 ;
45376 char *kwnames[] = {
45377 (char *) "self", NULL
45378 };
45379
45380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45382 if (SWIG_arg_fail(1)) SWIG_fail;
45383 {
45384 PyThreadState* __tstate = wxPyBeginAllowThreads();
45385 (arg1)->Unconstrained();
45386
45387 wxPyEndAllowThreads(__tstate);
45388 if (PyErr_Occurred()) SWIG_fail;
45389 }
45390 Py_INCREF(Py_None); resultobj = Py_None;
45391 return resultobj;
45392 fail:
45393 return NULL;
45394 }
45395
45396
45397 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45398 PyObject *resultobj = NULL;
45399 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45400 PyObject * obj0 = 0 ;
45401 char *kwnames[] = {
45402 (char *) "self", NULL
45403 };
45404
45405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45407 if (SWIG_arg_fail(1)) SWIG_fail;
45408 {
45409 PyThreadState* __tstate = wxPyBeginAllowThreads();
45410 (arg1)->AsIs();
45411
45412 wxPyEndAllowThreads(__tstate);
45413 if (PyErr_Occurred()) SWIG_fail;
45414 }
45415 Py_INCREF(Py_None); resultobj = Py_None;
45416 return resultobj;
45417 fail:
45418 return NULL;
45419 }
45420
45421
45422 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45423 PyObject *resultobj = NULL;
45424 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45425 wxWindow *result;
45426 PyObject * obj0 = 0 ;
45427 char *kwnames[] = {
45428 (char *) "self", NULL
45429 };
45430
45431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45433 if (SWIG_arg_fail(1)) SWIG_fail;
45434 {
45435 PyThreadState* __tstate = wxPyBeginAllowThreads();
45436 result = (wxWindow *)(arg1)->GetOtherWindow();
45437
45438 wxPyEndAllowThreads(__tstate);
45439 if (PyErr_Occurred()) SWIG_fail;
45440 }
45441 {
45442 resultobj = wxPyMake_wxObject(result, 0);
45443 }
45444 return resultobj;
45445 fail:
45446 return NULL;
45447 }
45448
45449
45450 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45451 PyObject *resultobj = NULL;
45452 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45453 wxEdge result;
45454 PyObject * obj0 = 0 ;
45455 char *kwnames[] = {
45456 (char *) "self", NULL
45457 };
45458
45459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45461 if (SWIG_arg_fail(1)) SWIG_fail;
45462 {
45463 PyThreadState* __tstate = wxPyBeginAllowThreads();
45464 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45465
45466 wxPyEndAllowThreads(__tstate);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 }
45469 resultobj = SWIG_From_int((result));
45470 return resultobj;
45471 fail:
45472 return NULL;
45473 }
45474
45475
45476 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45477 PyObject *resultobj = NULL;
45478 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45479 wxEdge arg2 ;
45480 PyObject * obj0 = 0 ;
45481 PyObject * obj1 = 0 ;
45482 char *kwnames[] = {
45483 (char *) "self",(char *) "which", NULL
45484 };
45485
45486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45488 if (SWIG_arg_fail(1)) SWIG_fail;
45489 {
45490 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45491 if (SWIG_arg_fail(2)) SWIG_fail;
45492 }
45493 {
45494 PyThreadState* __tstate = wxPyBeginAllowThreads();
45495 (arg1)->SetEdge(arg2);
45496
45497 wxPyEndAllowThreads(__tstate);
45498 if (PyErr_Occurred()) SWIG_fail;
45499 }
45500 Py_INCREF(Py_None); resultobj = Py_None;
45501 return resultobj;
45502 fail:
45503 return NULL;
45504 }
45505
45506
45507 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45508 PyObject *resultobj = NULL;
45509 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45510 int arg2 ;
45511 PyObject * obj0 = 0 ;
45512 PyObject * obj1 = 0 ;
45513 char *kwnames[] = {
45514 (char *) "self",(char *) "v", NULL
45515 };
45516
45517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45519 if (SWIG_arg_fail(1)) SWIG_fail;
45520 {
45521 arg2 = static_cast<int >(SWIG_As_int(obj1));
45522 if (SWIG_arg_fail(2)) SWIG_fail;
45523 }
45524 {
45525 PyThreadState* __tstate = wxPyBeginAllowThreads();
45526 (arg1)->SetValue(arg2);
45527
45528 wxPyEndAllowThreads(__tstate);
45529 if (PyErr_Occurred()) SWIG_fail;
45530 }
45531 Py_INCREF(Py_None); resultobj = Py_None;
45532 return resultobj;
45533 fail:
45534 return NULL;
45535 }
45536
45537
45538 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45539 PyObject *resultobj = NULL;
45540 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45541 int result;
45542 PyObject * obj0 = 0 ;
45543 char *kwnames[] = {
45544 (char *) "self", NULL
45545 };
45546
45547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45549 if (SWIG_arg_fail(1)) SWIG_fail;
45550 {
45551 PyThreadState* __tstate = wxPyBeginAllowThreads();
45552 result = (int)(arg1)->GetMargin();
45553
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 {
45558 resultobj = SWIG_From_int(static_cast<int >(result));
45559 }
45560 return resultobj;
45561 fail:
45562 return NULL;
45563 }
45564
45565
45566 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45567 PyObject *resultobj = NULL;
45568 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45569 int arg2 ;
45570 PyObject * obj0 = 0 ;
45571 PyObject * obj1 = 0 ;
45572 char *kwnames[] = {
45573 (char *) "self",(char *) "m", NULL
45574 };
45575
45576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45578 if (SWIG_arg_fail(1)) SWIG_fail;
45579 {
45580 arg2 = static_cast<int >(SWIG_As_int(obj1));
45581 if (SWIG_arg_fail(2)) SWIG_fail;
45582 }
45583 {
45584 PyThreadState* __tstate = wxPyBeginAllowThreads();
45585 (arg1)->SetMargin(arg2);
45586
45587 wxPyEndAllowThreads(__tstate);
45588 if (PyErr_Occurred()) SWIG_fail;
45589 }
45590 Py_INCREF(Py_None); resultobj = Py_None;
45591 return resultobj;
45592 fail:
45593 return NULL;
45594 }
45595
45596
45597 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45598 PyObject *resultobj = NULL;
45599 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45600 int result;
45601 PyObject * obj0 = 0 ;
45602 char *kwnames[] = {
45603 (char *) "self", NULL
45604 };
45605
45606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45608 if (SWIG_arg_fail(1)) SWIG_fail;
45609 {
45610 PyThreadState* __tstate = wxPyBeginAllowThreads();
45611 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45612
45613 wxPyEndAllowThreads(__tstate);
45614 if (PyErr_Occurred()) SWIG_fail;
45615 }
45616 {
45617 resultobj = SWIG_From_int(static_cast<int >(result));
45618 }
45619 return resultobj;
45620 fail:
45621 return NULL;
45622 }
45623
45624
45625 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45626 PyObject *resultobj = NULL;
45627 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45628 int result;
45629 PyObject * obj0 = 0 ;
45630 char *kwnames[] = {
45631 (char *) "self", NULL
45632 };
45633
45634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45636 if (SWIG_arg_fail(1)) SWIG_fail;
45637 {
45638 PyThreadState* __tstate = wxPyBeginAllowThreads();
45639 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45640
45641 wxPyEndAllowThreads(__tstate);
45642 if (PyErr_Occurred()) SWIG_fail;
45643 }
45644 {
45645 resultobj = SWIG_From_int(static_cast<int >(result));
45646 }
45647 return resultobj;
45648 fail:
45649 return NULL;
45650 }
45651
45652
45653 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45654 PyObject *resultobj = NULL;
45655 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45656 int result;
45657 PyObject * obj0 = 0 ;
45658 char *kwnames[] = {
45659 (char *) "self", NULL
45660 };
45661
45662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45664 if (SWIG_arg_fail(1)) SWIG_fail;
45665 {
45666 PyThreadState* __tstate = wxPyBeginAllowThreads();
45667 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45668
45669 wxPyEndAllowThreads(__tstate);
45670 if (PyErr_Occurred()) SWIG_fail;
45671 }
45672 {
45673 resultobj = SWIG_From_int(static_cast<int >(result));
45674 }
45675 return resultobj;
45676 fail:
45677 return NULL;
45678 }
45679
45680
45681 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45682 PyObject *resultobj = NULL;
45683 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45684 bool result;
45685 PyObject * obj0 = 0 ;
45686 char *kwnames[] = {
45687 (char *) "self", NULL
45688 };
45689
45690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45692 if (SWIG_arg_fail(1)) SWIG_fail;
45693 {
45694 PyThreadState* __tstate = wxPyBeginAllowThreads();
45695 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45696
45697 wxPyEndAllowThreads(__tstate);
45698 if (PyErr_Occurred()) SWIG_fail;
45699 }
45700 {
45701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45702 }
45703 return resultobj;
45704 fail:
45705 return NULL;
45706 }
45707
45708
45709 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45710 PyObject *resultobj = NULL;
45711 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45712 bool arg2 ;
45713 PyObject * obj0 = 0 ;
45714 PyObject * obj1 = 0 ;
45715 char *kwnames[] = {
45716 (char *) "self",(char *) "d", NULL
45717 };
45718
45719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45721 if (SWIG_arg_fail(1)) SWIG_fail;
45722 {
45723 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45724 if (SWIG_arg_fail(2)) SWIG_fail;
45725 }
45726 {
45727 PyThreadState* __tstate = wxPyBeginAllowThreads();
45728 (arg1)->SetDone(arg2);
45729
45730 wxPyEndAllowThreads(__tstate);
45731 if (PyErr_Occurred()) SWIG_fail;
45732 }
45733 Py_INCREF(Py_None); resultobj = Py_None;
45734 return resultobj;
45735 fail:
45736 return NULL;
45737 }
45738
45739
45740 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45741 PyObject *resultobj = NULL;
45742 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45743 wxRelationship result;
45744 PyObject * obj0 = 0 ;
45745 char *kwnames[] = {
45746 (char *) "self", NULL
45747 };
45748
45749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45751 if (SWIG_arg_fail(1)) SWIG_fail;
45752 {
45753 PyThreadState* __tstate = wxPyBeginAllowThreads();
45754 result = (wxRelationship)(arg1)->GetRelationship();
45755
45756 wxPyEndAllowThreads(__tstate);
45757 if (PyErr_Occurred()) SWIG_fail;
45758 }
45759 resultobj = SWIG_From_int((result));
45760 return resultobj;
45761 fail:
45762 return NULL;
45763 }
45764
45765
45766 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45767 PyObject *resultobj = NULL;
45768 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45769 wxRelationship arg2 ;
45770 PyObject * obj0 = 0 ;
45771 PyObject * obj1 = 0 ;
45772 char *kwnames[] = {
45773 (char *) "self",(char *) "r", NULL
45774 };
45775
45776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45778 if (SWIG_arg_fail(1)) SWIG_fail;
45779 {
45780 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45781 if (SWIG_arg_fail(2)) SWIG_fail;
45782 }
45783 {
45784 PyThreadState* __tstate = wxPyBeginAllowThreads();
45785 (arg1)->SetRelationship(arg2);
45786
45787 wxPyEndAllowThreads(__tstate);
45788 if (PyErr_Occurred()) SWIG_fail;
45789 }
45790 Py_INCREF(Py_None); resultobj = Py_None;
45791 return resultobj;
45792 fail:
45793 return NULL;
45794 }
45795
45796
45797 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45798 PyObject *resultobj = NULL;
45799 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45800 wxWindow *arg2 = (wxWindow *) 0 ;
45801 bool result;
45802 PyObject * obj0 = 0 ;
45803 PyObject * obj1 = 0 ;
45804 char *kwnames[] = {
45805 (char *) "self",(char *) "otherW", NULL
45806 };
45807
45808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45810 if (SWIG_arg_fail(1)) SWIG_fail;
45811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45812 if (SWIG_arg_fail(2)) SWIG_fail;
45813 {
45814 PyThreadState* __tstate = wxPyBeginAllowThreads();
45815 result = (bool)(arg1)->ResetIfWin(arg2);
45816
45817 wxPyEndAllowThreads(__tstate);
45818 if (PyErr_Occurred()) SWIG_fail;
45819 }
45820 {
45821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45822 }
45823 return resultobj;
45824 fail:
45825 return NULL;
45826 }
45827
45828
45829 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45830 PyObject *resultobj = NULL;
45831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45832 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45833 wxWindow *arg3 = (wxWindow *) 0 ;
45834 bool result;
45835 PyObject * obj0 = 0 ;
45836 PyObject * obj1 = 0 ;
45837 PyObject * obj2 = 0 ;
45838 char *kwnames[] = {
45839 (char *) "self",(char *) "constraints",(char *) "win", NULL
45840 };
45841
45842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45844 if (SWIG_arg_fail(1)) SWIG_fail;
45845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45846 if (SWIG_arg_fail(2)) SWIG_fail;
45847 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45848 if (SWIG_arg_fail(3)) SWIG_fail;
45849 {
45850 PyThreadState* __tstate = wxPyBeginAllowThreads();
45851 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45852
45853 wxPyEndAllowThreads(__tstate);
45854 if (PyErr_Occurred()) SWIG_fail;
45855 }
45856 {
45857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45858 }
45859 return resultobj;
45860 fail:
45861 return NULL;
45862 }
45863
45864
45865 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45866 PyObject *resultobj = NULL;
45867 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45868 wxEdge arg2 ;
45869 wxWindow *arg3 = (wxWindow *) 0 ;
45870 wxWindow *arg4 = (wxWindow *) 0 ;
45871 int result;
45872 PyObject * obj0 = 0 ;
45873 PyObject * obj1 = 0 ;
45874 PyObject * obj2 = 0 ;
45875 PyObject * obj3 = 0 ;
45876 char *kwnames[] = {
45877 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45878 };
45879
45880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45882 if (SWIG_arg_fail(1)) SWIG_fail;
45883 {
45884 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45885 if (SWIG_arg_fail(2)) SWIG_fail;
45886 }
45887 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45888 if (SWIG_arg_fail(3)) SWIG_fail;
45889 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45890 if (SWIG_arg_fail(4)) SWIG_fail;
45891 {
45892 PyThreadState* __tstate = wxPyBeginAllowThreads();
45893 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
45894
45895 wxPyEndAllowThreads(__tstate);
45896 if (PyErr_Occurred()) SWIG_fail;
45897 }
45898 {
45899 resultobj = SWIG_From_int(static_cast<int >(result));
45900 }
45901 return resultobj;
45902 fail:
45903 return NULL;
45904 }
45905
45906
45907 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45908 PyObject *obj;
45909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45910 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45911 Py_INCREF(obj);
45912 return Py_BuildValue((char *)"");
45913 }
45914 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45915 PyObject *resultobj = NULL;
45916 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45917 wxIndividualLayoutConstraint *result;
45918 PyObject * obj0 = 0 ;
45919 char *kwnames[] = {
45920 (char *) "self", NULL
45921 };
45922
45923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45925 if (SWIG_arg_fail(1)) SWIG_fail;
45926 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45927
45928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45929 return resultobj;
45930 fail:
45931 return NULL;
45932 }
45933
45934
45935 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45936 PyObject *resultobj = NULL;
45937 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45938 wxIndividualLayoutConstraint *result;
45939 PyObject * obj0 = 0 ;
45940 char *kwnames[] = {
45941 (char *) "self", NULL
45942 };
45943
45944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45946 if (SWIG_arg_fail(1)) SWIG_fail;
45947 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45948
45949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45950 return resultobj;
45951 fail:
45952 return NULL;
45953 }
45954
45955
45956 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45957 PyObject *resultobj = NULL;
45958 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45959 wxIndividualLayoutConstraint *result;
45960 PyObject * obj0 = 0 ;
45961 char *kwnames[] = {
45962 (char *) "self", NULL
45963 };
45964
45965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45967 if (SWIG_arg_fail(1)) SWIG_fail;
45968 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45969
45970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45971 return resultobj;
45972 fail:
45973 return NULL;
45974 }
45975
45976
45977 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45978 PyObject *resultobj = NULL;
45979 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45980 wxIndividualLayoutConstraint *result;
45981 PyObject * obj0 = 0 ;
45982 char *kwnames[] = {
45983 (char *) "self", NULL
45984 };
45985
45986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45988 if (SWIG_arg_fail(1)) SWIG_fail;
45989 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45990
45991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45992 return resultobj;
45993 fail:
45994 return NULL;
45995 }
45996
45997
45998 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45999 PyObject *resultobj = NULL;
46000 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46001 wxIndividualLayoutConstraint *result;
46002 PyObject * obj0 = 0 ;
46003 char *kwnames[] = {
46004 (char *) "self", NULL
46005 };
46006
46007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46009 if (SWIG_arg_fail(1)) SWIG_fail;
46010 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46011
46012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46013 return resultobj;
46014 fail:
46015 return NULL;
46016 }
46017
46018
46019 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46020 PyObject *resultobj = NULL;
46021 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46022 wxIndividualLayoutConstraint *result;
46023 PyObject * obj0 = 0 ;
46024 char *kwnames[] = {
46025 (char *) "self", NULL
46026 };
46027
46028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46030 if (SWIG_arg_fail(1)) SWIG_fail;
46031 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46032
46033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46034 return resultobj;
46035 fail:
46036 return NULL;
46037 }
46038
46039
46040 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
46041 PyObject *resultobj = NULL;
46042 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46043 wxIndividualLayoutConstraint *result;
46044 PyObject * obj0 = 0 ;
46045 char *kwnames[] = {
46046 (char *) "self", NULL
46047 };
46048
46049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
46050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46051 if (SWIG_arg_fail(1)) SWIG_fail;
46052 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
46053
46054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46055 return resultobj;
46056 fail:
46057 return NULL;
46058 }
46059
46060
46061 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
46062 PyObject *resultobj = NULL;
46063 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46064 wxIndividualLayoutConstraint *result;
46065 PyObject * obj0 = 0 ;
46066 char *kwnames[] = {
46067 (char *) "self", NULL
46068 };
46069
46070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
46071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46072 if (SWIG_arg_fail(1)) SWIG_fail;
46073 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
46074
46075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46076 return resultobj;
46077 fail:
46078 return NULL;
46079 }
46080
46081
46082 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46083 PyObject *resultobj = NULL;
46084 wxLayoutConstraints *result;
46085 char *kwnames[] = {
46086 NULL
46087 };
46088
46089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46093
46094 wxPyEndAllowThreads(__tstate);
46095 if (PyErr_Occurred()) SWIG_fail;
46096 }
46097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46098 return resultobj;
46099 fail:
46100 return NULL;
46101 }
46102
46103
46104 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46105 PyObject *resultobj = NULL;
46106 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46107 wxWindow *arg2 = (wxWindow *) 0 ;
46108 int *arg3 = (int *) 0 ;
46109 bool result;
46110 int temp3 ;
46111 int res3 = 0 ;
46112 PyObject * obj0 = 0 ;
46113 PyObject * obj1 = 0 ;
46114 char *kwnames[] = {
46115 (char *) "self",(char *) "win", NULL
46116 };
46117
46118 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46121 if (SWIG_arg_fail(1)) SWIG_fail;
46122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46123 if (SWIG_arg_fail(2)) SWIG_fail;
46124 {
46125 PyThreadState* __tstate = wxPyBeginAllowThreads();
46126 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46127
46128 wxPyEndAllowThreads(__tstate);
46129 if (PyErr_Occurred()) SWIG_fail;
46130 }
46131 {
46132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46133 }
46134 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46135 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46136 return resultobj;
46137 fail:
46138 return NULL;
46139 }
46140
46141
46142 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46143 PyObject *resultobj = NULL;
46144 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46145 bool result;
46146 PyObject * obj0 = 0 ;
46147 char *kwnames[] = {
46148 (char *) "self", NULL
46149 };
46150
46151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46153 if (SWIG_arg_fail(1)) SWIG_fail;
46154 {
46155 PyThreadState* __tstate = wxPyBeginAllowThreads();
46156 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46157
46158 wxPyEndAllowThreads(__tstate);
46159 if (PyErr_Occurred()) SWIG_fail;
46160 }
46161 {
46162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46163 }
46164 return resultobj;
46165 fail:
46166 return NULL;
46167 }
46168
46169
46170 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46171 PyObject *obj;
46172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46173 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46174 Py_INCREF(obj);
46175 return Py_BuildValue((char *)"");
46176 }
46177 static PyMethodDef SwigMethods[] = {
46178 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46179 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46180 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46183 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46204 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46217 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46232 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46286 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46314 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46333 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46335 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46343 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46344 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46356 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46368 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46372 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46378 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46388 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46398 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46401 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46408 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46416 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46424 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46508 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46510 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46512 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46514 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46516 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46518 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46520 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46522 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46524 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46526 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46528 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46530 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46532 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46546 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46564 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46567 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46570 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46582 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46587 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46593 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46599 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46662 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46669 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46705 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46715 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46721 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46723 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46725 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46728 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46732 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46735 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46738 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46740 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46745 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46753 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46757 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46760 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46762 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46766 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46783 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46785 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46788 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46790 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46794 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46798 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46809 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46812 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46815 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46819 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46826 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46831 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46836 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46840 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46885 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46905 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
46908 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46915 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46919 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46929 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47100 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47141 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47156 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47159 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47214 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47243 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47287 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47295 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47314 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47315 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47353 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47383 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47386 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47388 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47390 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47393 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47402 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47403 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47405 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47413 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47415 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47427 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47437 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47440 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47447 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47459 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47461 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47466 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47468 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47469 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47470 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47471 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47472 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47475 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47477 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47480 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47502 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47504 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47514 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47516 { NULL, NULL, 0, NULL }
47517 };
47518
47519
47520 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47521
47522 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47523 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47524 }
47525 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47526 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47527 }
47528 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47529 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47530 }
47531 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47532 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47533 }
47534 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47535 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47536 }
47537 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47538 return (void *)((wxSizer *) ((wxGridSizer *) x));
47539 }
47540 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47541 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47542 }
47543 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47544 return (void *)((wxSizer *) ((wxPySizer *) x));
47545 }
47546 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47547 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47548 }
47549 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47550 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47551 }
47552 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47553 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47554 }
47555 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47556 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47557 }
47558 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47559 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47560 }
47561 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47562 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47563 }
47564 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47565 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47566 }
47567 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47568 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47569 }
47570 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47571 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47572 }
47573 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47574 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47575 }
47576 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47577 return (void *)((wxEvent *) ((wxPyEvent *) x));
47578 }
47579 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47580 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47581 }
47582 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47583 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47584 }
47585 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47586 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47587 }
47588 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47589 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47590 }
47591 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47592 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47593 }
47594 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47595 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47596 }
47597 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47598 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47599 }
47600 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47601 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47602 }
47603 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47604 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47605 }
47606 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47607 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47608 }
47609 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47610 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47611 }
47612 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47613 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47614 }
47615 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47616 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47617 }
47618 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47619 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47620 }
47621 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47622 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47623 }
47624 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47625 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47626 }
47627 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47628 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47629 }
47630 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47631 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47632 }
47633 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47634 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47635 }
47636 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47637 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47638 }
47639 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47640 return (void *)((wxEvent *) ((wxShowEvent *) x));
47641 }
47642 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47643 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47644 }
47645 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47646 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47647 }
47648 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47649 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47650 }
47651 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47652 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47653 }
47654 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47655 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47656 }
47657 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47658 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47659 }
47660 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47661 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47662 }
47663 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47664 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47665 }
47666 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47667 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47668 }
47669 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47670 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47671 }
47672 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47673 return (void *)((wxControl *) ((wxControlWithItems *) x));
47674 }
47675 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47676 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47677 }
47678 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47679 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47680 }
47681 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47682 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47683 }
47684 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47685 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47686 }
47687 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47688 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47689 }
47690 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47691 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47692 }
47693 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47694 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47695 }
47696 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47697 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47698 }
47699 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47700 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47701 }
47702 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47703 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47704 }
47705 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47706 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47707 }
47708 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47709 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47710 }
47711 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47712 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47713 }
47714 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47715 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47716 }
47717 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47718 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47719 }
47720 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47721 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47722 }
47723 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47724 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47725 }
47726 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47727 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47728 }
47729 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47730 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47731 }
47732 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47733 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47734 }
47735 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47736 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47737 }
47738 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47739 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47740 }
47741 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47742 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47743 }
47744 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47745 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47746 }
47747 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47748 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47749 }
47750 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47751 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47752 }
47753 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47754 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47755 }
47756 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47757 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47758 }
47759 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47760 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47761 }
47762 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47763 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47764 }
47765 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47766 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47767 }
47768 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47769 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47770 }
47771 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47772 return (void *)((wxObject *) ((wxSizerItem *) x));
47773 }
47774 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47775 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47776 }
47777 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47778 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47779 }
47780 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47781 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47782 }
47783 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47784 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47785 }
47786 static void *_p_wxSizerTo_p_wxObject(void *x) {
47787 return (void *)((wxObject *) ((wxSizer *) x));
47788 }
47789 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47790 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47791 }
47792 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47793 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47794 }
47795 static void *_p_wxEventTo_p_wxObject(void *x) {
47796 return (void *)((wxObject *) ((wxEvent *) x));
47797 }
47798 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47799 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47800 }
47801 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47802 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47803 }
47804 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47805 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47806 }
47807 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47808 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47809 }
47810 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47811 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47812 }
47813 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47814 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47815 }
47816 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47817 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47818 }
47819 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47820 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47821 }
47822 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47823 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47824 }
47825 static void *_p_wxControlTo_p_wxObject(void *x) {
47826 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47827 }
47828 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47829 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47830 }
47831 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47832 return (void *)((wxObject *) ((wxFSFile *) x));
47833 }
47834 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47835 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47836 }
47837 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47838 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47839 }
47840 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47841 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47842 }
47843 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47844 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47845 }
47846 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47847 return (void *)((wxObject *) ((wxMenuItem *) x));
47848 }
47849 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47850 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47851 }
47852 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47853 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47854 }
47855 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47856 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47857 }
47858 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47859 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47860 }
47861 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47862 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47863 }
47864 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47865 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47866 }
47867 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47868 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47869 }
47870 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47871 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47872 }
47873 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47874 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47875 }
47876 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47877 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47878 }
47879 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47880 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47881 }
47882 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47883 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47884 }
47885 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47886 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47887 }
47888 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47889 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47890 }
47891 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47892 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47893 }
47894 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47895 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47896 }
47897 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47898 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47899 }
47900 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47901 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47902 }
47903 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
47904 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
47905 }
47906 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47907 return (void *)((wxObject *) ((wxImageHandler *) x));
47908 }
47909 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47910 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47911 }
47912 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47913 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47914 }
47915 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47916 return (void *)((wxObject *) ((wxEvtHandler *) x));
47917 }
47918 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47919 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47920 }
47921 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47922 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47923 }
47924 static void *_p_wxImageTo_p_wxObject(void *x) {
47925 return (void *)((wxObject *) ((wxImage *) x));
47926 }
47927 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47928 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47929 }
47930 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47931 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47932 }
47933 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47934 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47935 }
47936 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47937 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47938 }
47939 static void *_p_wxWindowTo_p_wxObject(void *x) {
47940 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47941 }
47942 static void *_p_wxMenuTo_p_wxObject(void *x) {
47943 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47944 }
47945 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47946 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47947 }
47948 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47949 return (void *)((wxObject *) ((wxFileSystem *) x));
47950 }
47951 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47952 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47953 }
47954 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47955 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47956 }
47957 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47958 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47959 }
47960 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47961 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47962 }
47963 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47964 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47965 }
47966 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47967 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47968 }
47969 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47970 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47971 }
47972 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47973 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47974 }
47975 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47976 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47977 }
47978 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47979 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47980 }
47981 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47982 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47983 }
47984 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47985 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47986 }
47987 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47988 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47989 }
47990 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47991 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47992 }
47993 static void *_p_wxControlTo_p_wxWindow(void *x) {
47994 return (void *)((wxWindow *) ((wxControl *) x));
47995 }
47996 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47997 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47998 }
47999 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48000 return (void *)((wxWindow *) ((wxMenuBar *) x));
48001 }
48002 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48003 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48004 }
48005 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48006 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48007 }
48008 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48009 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48010 }
48011 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48012 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48013 }
48014 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48015 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48016 }
48017 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48018 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48019 }
48020 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48021 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48022 }
48023 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48024 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48025 }
48026 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48027 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48028 }
48029 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48030 return (void *)((wxValidator *) ((wxPyValidator *) x));
48031 }
48032 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48033 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48034 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48035 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48036 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48037 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48038 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48039 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48040 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48041 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48042 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48043 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48044 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48045 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48046 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48047 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48048 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48049 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48050 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48051 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48052 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48053 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48054 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48055 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48056 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48057 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48058 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48059 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48060 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48061 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48062 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48063 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48064 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48065 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48066 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48067 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48068 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48069 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48070 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48071 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48072 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48073 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48074 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48075 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48076 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48077 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48078 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48079 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48080 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48081 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48082 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48083 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48084 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48085 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48086 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48087 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48088 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48089 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48090 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48091 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48092 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48093 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48094 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48095 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48096 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48097 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48098 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48099 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48100 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48101 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48102 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48103 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48104 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48105 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48106 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48107 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48108 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48109 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48110 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48111 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48112 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48113 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48114 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48115 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48116 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48117 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48118 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48119 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48120 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48121 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48122 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48123 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48124 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48125 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48126 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48127 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48128 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48129 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48130 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48131 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48132 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48133 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48134 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48135 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48136 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48137 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48138 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48139 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48140 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48141 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48142 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48143 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48144 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48145 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48146 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48147 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48148 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48149 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48150 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48151 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48152 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48153 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48154 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48155 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48156 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48157 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48158 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48159 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48160 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48161 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48162 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48163 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48164
48165 static swig_type_info *swig_type_initial[] = {
48166 &_swigt__p_buffer,
48167 &_swigt__p_char,
48168 &_swigt__p_form_ops_t,
48169 &_swigt__p_int,
48170 &_swigt__p_long,
48171 &_swigt__p_unsigned_char,
48172 &_swigt__p_unsigned_int,
48173 &_swigt__p_unsigned_long,
48174 &_swigt__p_wxANIHandler,
48175 &_swigt__p_wxAcceleratorEntry,
48176 &_swigt__p_wxAcceleratorTable,
48177 &_swigt__p_wxActivateEvent,
48178 &_swigt__p_wxAppTraits,
48179 &_swigt__p_wxArrayString,
48180 &_swigt__p_wxBMPHandler,
48181 &_swigt__p_wxBitmap,
48182 &_swigt__p_wxBoxSizer,
48183 &_swigt__p_wxButton,
48184 &_swigt__p_wxCURHandler,
48185 &_swigt__p_wxCaret,
48186 &_swigt__p_wxChildFocusEvent,
48187 &_swigt__p_wxCloseEvent,
48188 &_swigt__p_wxColour,
48189 &_swigt__p_wxCommandEvent,
48190 &_swigt__p_wxContextMenuEvent,
48191 &_swigt__p_wxControl,
48192 &_swigt__p_wxControlWithItems,
48193 &_swigt__p_wxCursor,
48194 &_swigt__p_wxDC,
48195 &_swigt__p_wxDateEvent,
48196 &_swigt__p_wxDateTime,
48197 &_swigt__p_wxDisplayChangedEvent,
48198 &_swigt__p_wxDropFilesEvent,
48199 &_swigt__p_wxDuplexMode,
48200 &_swigt__p_wxEraseEvent,
48201 &_swigt__p_wxEvent,
48202 &_swigt__p_wxEventLoop,
48203 &_swigt__p_wxEventLoopActivator,
48204 &_swigt__p_wxEvtHandler,
48205 &_swigt__p_wxFSFile,
48206 &_swigt__p_wxFileSystem,
48207 &_swigt__p_wxFileSystemHandler,
48208 &_swigt__p_wxFlexGridSizer,
48209 &_swigt__p_wxFocusEvent,
48210 &_swigt__p_wxFont,
48211 &_swigt__p_wxFrame,
48212 &_swigt__p_wxGBPosition,
48213 &_swigt__p_wxGBSizerItem,
48214 &_swigt__p_wxGBSpan,
48215 &_swigt__p_wxGIFHandler,
48216 &_swigt__p_wxGridBagSizer,
48217 &_swigt__p_wxGridSizer,
48218 &_swigt__p_wxICOHandler,
48219 &_swigt__p_wxIconizeEvent,
48220 &_swigt__p_wxIdleEvent,
48221 &_swigt__p_wxImage,
48222 &_swigt__p_wxImageHandler,
48223 &_swigt__p_wxImageHistogram,
48224 &_swigt__p_wxImage_HSVValue,
48225 &_swigt__p_wxImage_RGBValue,
48226 &_swigt__p_wxIndividualLayoutConstraint,
48227 &_swigt__p_wxInitDialogEvent,
48228 &_swigt__p_wxInputStream,
48229 &_swigt__p_wxInternetFSHandler,
48230 &_swigt__p_wxItemContainer,
48231 &_swigt__p_wxJPEGHandler,
48232 &_swigt__p_wxKeyEvent,
48233 &_swigt__p_wxLayoutConstraints,
48234 &_swigt__p_wxMaximizeEvent,
48235 &_swigt__p_wxMemoryFSHandler,
48236 &_swigt__p_wxMenu,
48237 &_swigt__p_wxMenuBar,
48238 &_swigt__p_wxMenuBarBase,
48239 &_swigt__p_wxMenuEvent,
48240 &_swigt__p_wxMenuItem,
48241 &_swigt__p_wxMouseCaptureChangedEvent,
48242 &_swigt__p_wxMouseEvent,
48243 &_swigt__p_wxMoveEvent,
48244 &_swigt__p_wxNavigationKeyEvent,
48245 &_swigt__p_wxNcPaintEvent,
48246 &_swigt__p_wxNotifyEvent,
48247 &_swigt__p_wxObject,
48248 &_swigt__p_wxOutputStream,
48249 &_swigt__p_wxPCXHandler,
48250 &_swigt__p_wxPNGHandler,
48251 &_swigt__p_wxPNMHandler,
48252 &_swigt__p_wxPaintEvent,
48253 &_swigt__p_wxPaletteChangedEvent,
48254 &_swigt__p_wxPaperSize,
48255 &_swigt__p_wxPoint,
48256 &_swigt__p_wxPoint2D,
48257 &_swigt__p_wxPropagateOnce,
48258 &_swigt__p_wxPropagationDisabler,
48259 &_swigt__p_wxPyApp,
48260 &_swigt__p_wxPyCommandEvent,
48261 &_swigt__p_wxPyDropTarget,
48262 &_swigt__p_wxPyEvent,
48263 &_swigt__p_wxPyFileSystemHandler,
48264 &_swigt__p_wxPyImageHandler,
48265 &_swigt__p_wxPyInputStream,
48266 &_swigt__p_wxPySizer,
48267 &_swigt__p_wxPyValidator,
48268 &_swigt__p_wxQuantize,
48269 &_swigt__p_wxQueryNewPaletteEvent,
48270 &_swigt__p_wxRealPoint,
48271 &_swigt__p_wxRect,
48272 &_swigt__p_wxRegion,
48273 &_swigt__p_wxScrollEvent,
48274 &_swigt__p_wxScrollWinEvent,
48275 &_swigt__p_wxSetCursorEvent,
48276 &_swigt__p_wxShowEvent,
48277 &_swigt__p_wxSize,
48278 &_swigt__p_wxSizeEvent,
48279 &_swigt__p_wxSizer,
48280 &_swigt__p_wxSizerItem,
48281 &_swigt__p_wxStaticBox,
48282 &_swigt__p_wxStaticBoxSizer,
48283 &_swigt__p_wxStdDialogButtonSizer,
48284 &_swigt__p_wxSysColourChangedEvent,
48285 &_swigt__p_wxTIFFHandler,
48286 &_swigt__p_wxToolTip,
48287 &_swigt__p_wxUpdateUIEvent,
48288 &_swigt__p_wxValidator,
48289 &_swigt__p_wxVisualAttributes,
48290 &_swigt__p_wxWindow,
48291 &_swigt__p_wxWindowCreateEvent,
48292 &_swigt__p_wxWindowDestroyEvent,
48293 &_swigt__p_wxXPMHandler,
48294 &_swigt__p_wxZipFSHandler,
48295 &_swigt__ptrdiff_t,
48296 &_swigt__std__ptrdiff_t,
48297 &_swigt__unsigned_int,
48298 };
48299
48300 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48301 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48302 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48303 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48304 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48305 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48306 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48307 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48308 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48309 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48310 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48311 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48312 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48313 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48314 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}};
48315 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48316 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}};
48317 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48318 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}};
48319 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48320 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48321 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48322 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48323 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}};
48324 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48325 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}};
48326 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48327 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48328 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48329 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48330 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48331 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48332 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48333 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48334 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48335 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}};
48336 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48337 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48338 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}};
48339 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48340 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48341 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}};
48342 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}};
48343 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48344 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48345 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48346 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48347 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48348 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48349 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48350 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48351 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}};
48352 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}};
48353 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48354 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48355 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48356 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}};
48357 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48358 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48359 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48360 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48361 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48362 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48363 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48364 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}};
48365 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48366 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48367 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48368 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48369 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48370 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48371 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48372 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48373 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48374 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48375 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48376 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48377 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48378 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48379 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48380 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48381 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}};
48382 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48383 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48384 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48385 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48386 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48387 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48388 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48389 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48390 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48391 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48392 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48393 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48394 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48395 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48396 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48397 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48398 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48399 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48400 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48401 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48402 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48403 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48404 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48405 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48406 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48407 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48408 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48409 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48410 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48411 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48412 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48413 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}};
48414 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}};
48415 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48416 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48417 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48418 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48419 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48420 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48421 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48422 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}};
48423 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48424 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}};
48425 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48426 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48427 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48428 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48429 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48430 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48431 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48432
48433 static swig_cast_info *swig_cast_initial[] = {
48434 _swigc__p_buffer,
48435 _swigc__p_char,
48436 _swigc__p_form_ops_t,
48437 _swigc__p_int,
48438 _swigc__p_long,
48439 _swigc__p_unsigned_char,
48440 _swigc__p_unsigned_int,
48441 _swigc__p_unsigned_long,
48442 _swigc__p_wxANIHandler,
48443 _swigc__p_wxAcceleratorEntry,
48444 _swigc__p_wxAcceleratorTable,
48445 _swigc__p_wxActivateEvent,
48446 _swigc__p_wxAppTraits,
48447 _swigc__p_wxArrayString,
48448 _swigc__p_wxBMPHandler,
48449 _swigc__p_wxBitmap,
48450 _swigc__p_wxBoxSizer,
48451 _swigc__p_wxButton,
48452 _swigc__p_wxCURHandler,
48453 _swigc__p_wxCaret,
48454 _swigc__p_wxChildFocusEvent,
48455 _swigc__p_wxCloseEvent,
48456 _swigc__p_wxColour,
48457 _swigc__p_wxCommandEvent,
48458 _swigc__p_wxContextMenuEvent,
48459 _swigc__p_wxControl,
48460 _swigc__p_wxControlWithItems,
48461 _swigc__p_wxCursor,
48462 _swigc__p_wxDC,
48463 _swigc__p_wxDateEvent,
48464 _swigc__p_wxDateTime,
48465 _swigc__p_wxDisplayChangedEvent,
48466 _swigc__p_wxDropFilesEvent,
48467 _swigc__p_wxDuplexMode,
48468 _swigc__p_wxEraseEvent,
48469 _swigc__p_wxEvent,
48470 _swigc__p_wxEventLoop,
48471 _swigc__p_wxEventLoopActivator,
48472 _swigc__p_wxEvtHandler,
48473 _swigc__p_wxFSFile,
48474 _swigc__p_wxFileSystem,
48475 _swigc__p_wxFileSystemHandler,
48476 _swigc__p_wxFlexGridSizer,
48477 _swigc__p_wxFocusEvent,
48478 _swigc__p_wxFont,
48479 _swigc__p_wxFrame,
48480 _swigc__p_wxGBPosition,
48481 _swigc__p_wxGBSizerItem,
48482 _swigc__p_wxGBSpan,
48483 _swigc__p_wxGIFHandler,
48484 _swigc__p_wxGridBagSizer,
48485 _swigc__p_wxGridSizer,
48486 _swigc__p_wxICOHandler,
48487 _swigc__p_wxIconizeEvent,
48488 _swigc__p_wxIdleEvent,
48489 _swigc__p_wxImage,
48490 _swigc__p_wxImageHandler,
48491 _swigc__p_wxImageHistogram,
48492 _swigc__p_wxImage_HSVValue,
48493 _swigc__p_wxImage_RGBValue,
48494 _swigc__p_wxIndividualLayoutConstraint,
48495 _swigc__p_wxInitDialogEvent,
48496 _swigc__p_wxInputStream,
48497 _swigc__p_wxInternetFSHandler,
48498 _swigc__p_wxItemContainer,
48499 _swigc__p_wxJPEGHandler,
48500 _swigc__p_wxKeyEvent,
48501 _swigc__p_wxLayoutConstraints,
48502 _swigc__p_wxMaximizeEvent,
48503 _swigc__p_wxMemoryFSHandler,
48504 _swigc__p_wxMenu,
48505 _swigc__p_wxMenuBar,
48506 _swigc__p_wxMenuBarBase,
48507 _swigc__p_wxMenuEvent,
48508 _swigc__p_wxMenuItem,
48509 _swigc__p_wxMouseCaptureChangedEvent,
48510 _swigc__p_wxMouseEvent,
48511 _swigc__p_wxMoveEvent,
48512 _swigc__p_wxNavigationKeyEvent,
48513 _swigc__p_wxNcPaintEvent,
48514 _swigc__p_wxNotifyEvent,
48515 _swigc__p_wxObject,
48516 _swigc__p_wxOutputStream,
48517 _swigc__p_wxPCXHandler,
48518 _swigc__p_wxPNGHandler,
48519 _swigc__p_wxPNMHandler,
48520 _swigc__p_wxPaintEvent,
48521 _swigc__p_wxPaletteChangedEvent,
48522 _swigc__p_wxPaperSize,
48523 _swigc__p_wxPoint,
48524 _swigc__p_wxPoint2D,
48525 _swigc__p_wxPropagateOnce,
48526 _swigc__p_wxPropagationDisabler,
48527 _swigc__p_wxPyApp,
48528 _swigc__p_wxPyCommandEvent,
48529 _swigc__p_wxPyDropTarget,
48530 _swigc__p_wxPyEvent,
48531 _swigc__p_wxPyFileSystemHandler,
48532 _swigc__p_wxPyImageHandler,
48533 _swigc__p_wxPyInputStream,
48534 _swigc__p_wxPySizer,
48535 _swigc__p_wxPyValidator,
48536 _swigc__p_wxQuantize,
48537 _swigc__p_wxQueryNewPaletteEvent,
48538 _swigc__p_wxRealPoint,
48539 _swigc__p_wxRect,
48540 _swigc__p_wxRegion,
48541 _swigc__p_wxScrollEvent,
48542 _swigc__p_wxScrollWinEvent,
48543 _swigc__p_wxSetCursorEvent,
48544 _swigc__p_wxShowEvent,
48545 _swigc__p_wxSize,
48546 _swigc__p_wxSizeEvent,
48547 _swigc__p_wxSizer,
48548 _swigc__p_wxSizerItem,
48549 _swigc__p_wxStaticBox,
48550 _swigc__p_wxStaticBoxSizer,
48551 _swigc__p_wxStdDialogButtonSizer,
48552 _swigc__p_wxSysColourChangedEvent,
48553 _swigc__p_wxTIFFHandler,
48554 _swigc__p_wxToolTip,
48555 _swigc__p_wxUpdateUIEvent,
48556 _swigc__p_wxValidator,
48557 _swigc__p_wxVisualAttributes,
48558 _swigc__p_wxWindow,
48559 _swigc__p_wxWindowCreateEvent,
48560 _swigc__p_wxWindowDestroyEvent,
48561 _swigc__p_wxXPMHandler,
48562 _swigc__p_wxZipFSHandler,
48563 _swigc__ptrdiff_t,
48564 _swigc__std__ptrdiff_t,
48565 _swigc__unsigned_int,
48566 };
48567
48568
48569 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48570
48571 static swig_const_info swig_const_table[] = {
48572 {0, 0, 0, 0.0, 0, 0}};
48573
48574 #ifdef __cplusplus
48575 }
48576 #endif
48577 /*************************************************************************
48578 * Type initialization:
48579 * This problem is tough by the requirement that no dynamic
48580 * memory is used. Also, since swig_type_info structures store pointers to
48581 * swig_cast_info structures and swig_cast_info structures store pointers back
48582 * to swig_type_info structures, we need some lookup code at initialization.
48583 * The idea is that swig generates all the structures that are needed.
48584 * The runtime then collects these partially filled structures.
48585 * The SWIG_InitializeModule function takes these initial arrays out of
48586 * swig_module, and does all the lookup, filling in the swig_module.types
48587 * array with the correct data and linking the correct swig_cast_info
48588 * structures together.
48589
48590 * The generated swig_type_info structures are assigned staticly to an initial
48591 * array. We just loop though that array, and handle each type individually.
48592 * First we lookup if this type has been already loaded, and if so, use the
48593 * loaded structure instead of the generated one. Then we have to fill in the
48594 * cast linked list. The cast data is initially stored in something like a
48595 * two-dimensional array. Each row corresponds to a type (there are the same
48596 * number of rows as there are in the swig_type_initial array). Each entry in
48597 * a column is one of the swig_cast_info structures for that type.
48598 * The cast_initial array is actually an array of arrays, because each row has
48599 * a variable number of columns. So to actually build the cast linked list,
48600 * we find the array of casts associated with the type, and loop through it
48601 * adding the casts to the list. The one last trick we need to do is making
48602 * sure the type pointer in the swig_cast_info struct is correct.
48603
48604 * First off, we lookup the cast->type name to see if it is already loaded.
48605 * There are three cases to handle:
48606 * 1) If the cast->type has already been loaded AND the type we are adding
48607 * casting info to has not been loaded (it is in this module), THEN we
48608 * replace the cast->type pointer with the type pointer that has already
48609 * been loaded.
48610 * 2) If BOTH types (the one we are adding casting info to, and the
48611 * cast->type) are loaded, THEN the cast info has already been loaded by
48612 * the previous module so we just ignore it.
48613 * 3) Finally, if cast->type has not already been loaded, then we add that
48614 * swig_cast_info to the linked list (because the cast->type) pointer will
48615 * be correct.
48616 **/
48617
48618 #ifdef __cplusplus
48619 extern "C" {
48620 #if 0
48621 } /* c-mode */
48622 #endif
48623 #endif
48624
48625 #if 0
48626 #define SWIGRUNTIME_DEBUG
48627 #endif
48628
48629 SWIGRUNTIME void
48630 SWIG_InitializeModule(void *clientdata) {
48631 size_t i;
48632 swig_module_info *module_head;
48633 static int init_run = 0;
48634
48635 clientdata = clientdata;
48636
48637 if (init_run) return;
48638 init_run = 1;
48639
48640 /* Initialize the swig_module */
48641 swig_module.type_initial = swig_type_initial;
48642 swig_module.cast_initial = swig_cast_initial;
48643
48644 /* Try and load any already created modules */
48645 module_head = SWIG_GetModule(clientdata);
48646 if (module_head) {
48647 swig_module.next = module_head->next;
48648 module_head->next = &swig_module;
48649 } else {
48650 /* This is the first module loaded */
48651 swig_module.next = &swig_module;
48652 SWIG_SetModule(clientdata, &swig_module);
48653 }
48654
48655 /* Now work on filling in swig_module.types */
48656 #ifdef SWIGRUNTIME_DEBUG
48657 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48658 #endif
48659 for (i = 0; i < swig_module.size; ++i) {
48660 swig_type_info *type = 0;
48661 swig_type_info *ret;
48662 swig_cast_info *cast;
48663
48664 #ifdef SWIGRUNTIME_DEBUG
48665 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48666 #endif
48667
48668 /* if there is another module already loaded */
48669 if (swig_module.next != &swig_module) {
48670 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48671 }
48672 if (type) {
48673 /* Overwrite clientdata field */
48674 #ifdef SWIGRUNTIME_DEBUG
48675 printf("SWIG_InitializeModule: found type %s\n", type->name);
48676 #endif
48677 if (swig_module.type_initial[i]->clientdata) {
48678 type->clientdata = swig_module.type_initial[i]->clientdata;
48679 #ifdef SWIGRUNTIME_DEBUG
48680 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48681 #endif
48682 }
48683 } else {
48684 type = swig_module.type_initial[i];
48685 }
48686
48687 /* Insert casting types */
48688 cast = swig_module.cast_initial[i];
48689 while (cast->type) {
48690 /* Don't need to add information already in the list */
48691 ret = 0;
48692 #ifdef SWIGRUNTIME_DEBUG
48693 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48694 #endif
48695 if (swig_module.next != &swig_module) {
48696 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48697 #ifdef SWIGRUNTIME_DEBUG
48698 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48699 #endif
48700 }
48701 if (ret) {
48702 if (type == swig_module.type_initial[i]) {
48703 #ifdef SWIGRUNTIME_DEBUG
48704 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48705 #endif
48706 cast->type = ret;
48707 ret = 0;
48708 } else {
48709 /* Check for casting already in the list */
48710 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48711 #ifdef SWIGRUNTIME_DEBUG
48712 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48713 #endif
48714 if (!ocast) ret = 0;
48715 }
48716 }
48717
48718 if (!ret) {
48719 #ifdef SWIGRUNTIME_DEBUG
48720 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48721 #endif
48722 if (type->cast) {
48723 type->cast->prev = cast;
48724 cast->next = type->cast;
48725 }
48726 type->cast = cast;
48727 }
48728 cast++;
48729 }
48730 /* Set entry in modules->types array equal to the type */
48731 swig_module.types[i] = type;
48732 }
48733 swig_module.types[i] = 0;
48734
48735 #ifdef SWIGRUNTIME_DEBUG
48736 printf("**** SWIG_InitializeModule: Cast List ******\n");
48737 for (i = 0; i < swig_module.size; ++i) {
48738 int j = 0;
48739 swig_cast_info *cast = swig_module.cast_initial[i];
48740 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48741 while (cast->type) {
48742 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48743 cast++;
48744 ++j;
48745 }
48746 printf("---- Total casts: %d\n",j);
48747 }
48748 printf("**** SWIG_InitializeModule: Cast List ******\n");
48749 #endif
48750 }
48751
48752 /* This function will propagate the clientdata field of type to
48753 * any new swig_type_info structures that have been added into the list
48754 * of equivalent types. It is like calling
48755 * SWIG_TypeClientData(type, clientdata) a second time.
48756 */
48757 SWIGRUNTIME void
48758 SWIG_PropagateClientData(void) {
48759 size_t i;
48760 swig_cast_info *equiv;
48761 static int init_run = 0;
48762
48763 if (init_run) return;
48764 init_run = 1;
48765
48766 for (i = 0; i < swig_module.size; i++) {
48767 if (swig_module.types[i]->clientdata) {
48768 equiv = swig_module.types[i]->cast;
48769 while (equiv) {
48770 if (!equiv->converter) {
48771 if (equiv->type && !equiv->type->clientdata)
48772 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
48773 }
48774 equiv = equiv->next;
48775 }
48776 }
48777 }
48778 }
48779
48780 #ifdef __cplusplus
48781 #if 0
48782 {
48783 /* c-mode */
48784 #endif
48785 }
48786 #endif
48787
48788
48789
48790 #ifdef __cplusplus
48791 extern "C" {
48792 #endif
48793
48794 /* Python-specific SWIG API */
48795 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48796 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48797 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48798
48799 /* -----------------------------------------------------------------------------
48800 * global variable support code.
48801 * ----------------------------------------------------------------------------- */
48802
48803 typedef struct swig_globalvar {
48804 char *name; /* Name of global variable */
48805 PyObject *(*get_attr)(void); /* Return the current value */
48806 int (*set_attr)(PyObject *); /* Set the value */
48807 struct swig_globalvar *next;
48808 } swig_globalvar;
48809
48810 typedef struct swig_varlinkobject {
48811 PyObject_HEAD
48812 swig_globalvar *vars;
48813 } swig_varlinkobject;
48814
48815 SWIGINTERN PyObject *
48816 swig_varlink_repr(swig_varlinkobject *v) {
48817 v = v;
48818 return PyString_FromString("<Swig global variables>");
48819 }
48820
48821 SWIGINTERN int
48822 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48823 swig_globalvar *var;
48824 flags = flags;
48825 fprintf(fp,"Swig global variables { ");
48826 for (var = v->vars; var; var=var->next) {
48827 fprintf(fp,"%s", var->name);
48828 if (var->next) fprintf(fp,", ");
48829 }
48830 fprintf(fp," }\n");
48831 return 0;
48832 }
48833
48834 SWIGINTERN PyObject *
48835 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48836 swig_globalvar *var = v->vars;
48837 while (var) {
48838 if (strcmp(var->name,n) == 0) {
48839 return (*var->get_attr)();
48840 }
48841 var = var->next;
48842 }
48843 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48844 return NULL;
48845 }
48846
48847 SWIGINTERN int
48848 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48849 swig_globalvar *var = v->vars;
48850 while (var) {
48851 if (strcmp(var->name,n) == 0) {
48852 return (*var->set_attr)(p);
48853 }
48854 var = var->next;
48855 }
48856 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48857 return 1;
48858 }
48859
48860 SWIGINTERN PyTypeObject*
48861 swig_varlink_type(void) {
48862 static char varlink__doc__[] = "Swig var link object";
48863 static PyTypeObject varlink_type
48864 #if !defined(__cplusplus)
48865 ;
48866 static int type_init = 0;
48867 if (!type_init) {
48868 PyTypeObject tmp
48869 #endif
48870 = {
48871 PyObject_HEAD_INIT(&PyType_Type)
48872 0, /* Number of items in variable part (ob_size) */
48873 (char *)"swigvarlink", /* Type name (tp_name) */
48874 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48875 0, /* Itemsize (tp_itemsize) */
48876 0, /* Deallocator (tp_dealloc) */
48877 (printfunc) swig_varlink_print, /* Print (tp_print) */
48878 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48879 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48880 0, /* tp_compare */
48881 (reprfunc) swig_varlink_repr, /* tp_repr */
48882 0, /* tp_as_number */
48883 0, /* tp_as_sequence */
48884 0, /* tp_as_mapping */
48885 0, /* tp_hash */
48886 0, /* tp_call */
48887 0, /* tp_str */
48888 0, /* tp_getattro */
48889 0, /* tp_setattro */
48890 0, /* tp_as_buffer */
48891 0, /* tp_flags */
48892 varlink__doc__, /* tp_doc */
48893 #if PY_VERSION_HEX >= 0x02000000
48894 0, /* tp_traverse */
48895 0, /* tp_clear */
48896 #endif
48897 #if PY_VERSION_HEX >= 0x02010000
48898 0, /* tp_richcompare */
48899 0, /* tp_weaklistoffset */
48900 #endif
48901 #if PY_VERSION_HEX >= 0x02020000
48902 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48903 #endif
48904 #if PY_VERSION_HEX >= 0x02030000
48905 0, /* tp_del */
48906 #endif
48907 #ifdef COUNT_ALLOCS
48908 0,0,0,0 /* tp_alloc -> tp_next */
48909 #endif
48910 };
48911 #if !defined(__cplusplus)
48912 varlink_type = tmp;
48913 type_init = 1;
48914 }
48915 #endif
48916 return &varlink_type;
48917 }
48918
48919 /* Create a variable linking object for use later */
48920 SWIGINTERN PyObject *
48921 SWIG_Python_newvarlink(void) {
48922 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
48923 if (result) {
48924 result->vars = 0;
48925 }
48926 return ((PyObject*) result);
48927 }
48928
48929 SWIGINTERN void
48930 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48931 swig_varlinkobject *v = (swig_varlinkobject *) p;
48932 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48933 if (gv) {
48934 size_t size = strlen(name)+1;
48935 gv->name = (char *)malloc(size);
48936 if (gv->name) {
48937 strncpy(gv->name,name,size);
48938 gv->get_attr = get_attr;
48939 gv->set_attr = set_attr;
48940 gv->next = v->vars;
48941 }
48942 }
48943 v->vars = gv;
48944 }
48945
48946 /* -----------------------------------------------------------------------------
48947 * constants/methods manipulation
48948 * ----------------------------------------------------------------------------- */
48949
48950 /* Install Constants */
48951 SWIGINTERN void
48952 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48953 PyObject *obj = 0;
48954 size_t i;
48955 for (i = 0; constants[i].type; ++i) {
48956 switch(constants[i].type) {
48957 case SWIG_PY_INT:
48958 obj = PyInt_FromLong(constants[i].lvalue);
48959 break;
48960 case SWIG_PY_FLOAT:
48961 obj = PyFloat_FromDouble(constants[i].dvalue);
48962 break;
48963 case SWIG_PY_STRING:
48964 if (constants[i].pvalue) {
48965 obj = PyString_FromString((char *) constants[i].pvalue);
48966 } else {
48967 Py_INCREF(Py_None);
48968 obj = Py_None;
48969 }
48970 break;
48971 case SWIG_PY_POINTER:
48972 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48973 break;
48974 case SWIG_PY_BINARY:
48975 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48976 break;
48977 default:
48978 obj = 0;
48979 break;
48980 }
48981 if (obj) {
48982 PyDict_SetItemString(d,constants[i].name,obj);
48983 Py_DECREF(obj);
48984 }
48985 }
48986 }
48987
48988 /* -----------------------------------------------------------------------------*/
48989 /* Fix SwigMethods to carry the callback ptrs when needed */
48990 /* -----------------------------------------------------------------------------*/
48991
48992 SWIGINTERN void
48993 SWIG_Python_FixMethods(PyMethodDef *methods,
48994 swig_const_info *const_table,
48995 swig_type_info **types,
48996 swig_type_info **types_initial) {
48997 size_t i;
48998 for (i = 0; methods[i].ml_name; ++i) {
48999 char *c = methods[i].ml_doc;
49000 if (c && (c = strstr(c, "swig_ptr: "))) {
49001 int j;
49002 swig_const_info *ci = 0;
49003 char *name = c + 10;
49004 for (j = 0; const_table[j].type; ++j) {
49005 if (strncmp(const_table[j].name, name,
49006 strlen(const_table[j].name)) == 0) {
49007 ci = &(const_table[j]);
49008 break;
49009 }
49010 }
49011 if (ci) {
49012 size_t shift = (ci->ptype) - types;
49013 swig_type_info *ty = types_initial[shift];
49014 size_t ldoc = (c - methods[i].ml_doc);
49015 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49016 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49017 if (ndoc) {
49018 char *buff = ndoc;
49019 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49020 if (ptr) {
49021 strncpy(buff, methods[i].ml_doc, ldoc);
49022 buff += ldoc;
49023 strncpy(buff, "swig_ptr: ", 10);
49024 buff += 10;
49025 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49026 methods[i].ml_doc = ndoc;
49027 }
49028 }
49029 }
49030 }
49031 }
49032 }
49033
49034 /* -----------------------------------------------------------------------------*
49035 * Initialize type list
49036 * -----------------------------------------------------------------------------*/
49037
49038 #ifdef __cplusplus
49039 }
49040 #endif
49041
49042 /* -----------------------------------------------------------------------------*
49043 * Partial Init method
49044 * -----------------------------------------------------------------------------*/
49045
49046 #ifdef __cplusplus
49047 extern "C"
49048 #endif
49049 SWIGEXPORT void SWIG_init(void) {
49050 static PyObject *SWIG_globals = 0;
49051 PyObject *m, *d;
49052 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49053
49054 /* Fix SwigMethods to carry the callback ptrs when needed */
49055 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49056
49057 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49058 d = PyModule_GetDict(m);
49059
49060 SWIG_InitializeModule(0);
49061 SWIG_InstallConstants(d,swig_const_table);
49062
49063
49064 #ifndef wxPyUSE_EXPORT
49065 // Make our API structure a CObject so other modules can import it
49066 // from this module.
49067 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49068 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49069 Py_XDECREF(cobj);
49070 #endif
49071
49072 {
49073 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49572 }
49573 {
49574 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49575 }
49576 {
49577 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49581 }
49582 {
49583 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49584 }
49585 {
49586 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49587 }
49588 {
49589 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49644 }
49645 {
49646 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49647 }
49648 {
49649 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49650 }
49651 {
49652 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49653 }
49654 {
49655 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49656 }
49657 {
49658 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49659 }
49660 {
49661 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49662 }
49663 {
49664 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49665 }
49666 {
49667 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49668 }
49669 {
49670 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49671 }
49672 {
49673 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49680 }
49681 {
49682 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49683 }
49684 {
49685 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49689 }
49690 {
49691 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49692 }
49693 {
49694 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49695 }
49696 {
49697 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49698 }
49699 {
49700 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49701 }
49702 {
49703 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49704 }
49705 {
49706 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49707 }
49708 {
49709 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49710 }
49711 {
49712 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49713 }
49714 {
49715 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49716 }
49717 {
49718 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49719 }
49720 {
49721 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49722 }
49723 {
49724 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49725 }
49726 {
49727 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49728 }
49729 {
49730 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49731 }
49732 {
49733 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49734 }
49735 {
49736 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49737 }
49738 {
49739 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49740 }
49741 {
49742 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49743 }
49744 {
49745 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
49923 }
49924 {
49925 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
49926 }
49927 {
49928 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
49929 }
49930 {
49931 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
49932 }
49933 {
49934 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
49935 }
49936 {
49937 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
49944 }
49945 {
49946 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
49947 }
49948 {
49949 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
49950 }
49951 {
49952 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
49953 }
49954 {
49955 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
49956 }
49957 {
49958 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
49959 }
49960 {
49961 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
49962 }
49963 {
49964 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
49965 }
49966 {
49967 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
49968 }
49969 {
49970 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
49971 }
49972 {
49973 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
49974 }
49975 {
49976 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
49977 }
49978 {
49979 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
49980 }
49981 {
49982 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
49983 }
49984 {
49985 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
49986 }
49987 {
49988 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
49989 }
49990 {
49991 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
49992 }
49993 {
49994 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
49995 }
49996 {
49997 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
49998 }
49999 {
50000 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50001 }
50002 {
50003 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50004 }
50005 {
50006 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50007 }
50008 {
50009 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50010 }
50011 {
50012 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50013 }
50014 {
50015 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50016 }
50017 {
50018 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50019 }
50020 {
50021 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50022 }
50023 {
50024 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50025 }
50026 {
50027 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50028 }
50029 {
50030 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50031 }
50032 {
50033 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50034 }
50035 {
50036 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50037 }
50038 {
50039 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50040 }
50041 {
50042 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50043 }
50044 {
50045 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50046 }
50047 {
50048 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50049 }
50050 {
50051 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50052 }
50053 {
50054 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50055 }
50056 {
50057 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50058 }
50059 {
50060 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50061 }
50062 {
50063 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50064 }
50065 {
50066 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50067 }
50068 {
50069 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50070 }
50071 {
50072 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50073 }
50074 {
50075 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50076 }
50077 {
50078 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50079 }
50080 {
50081 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50082 }
50083 {
50084 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50085 }
50086 {
50087 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50088 }
50089 {
50090 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50091 }
50092 {
50093 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50094 }
50095 {
50096 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50097 }
50098 {
50099 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50100 }
50101 {
50102 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50103 }
50104 {
50105 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50106 }
50107 {
50108 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50109 }
50110 {
50111 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50112 }
50113 {
50114 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50115 }
50116 {
50117 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50118 }
50119 {
50120 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50121 }
50122 {
50123 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50124 }
50125 {
50126 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50127 }
50128 {
50129 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50130 }
50131 {
50132 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50133 }
50134 {
50135 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50136 }
50137 {
50138 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50139 }
50140 {
50141 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50142 }
50143 {
50144 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50145 }
50146 {
50147 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50148 }
50149 {
50150 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50151 }
50152 {
50153 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50154 }
50155 {
50156 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50157 }
50158 {
50159 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50160 }
50161 {
50162 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50163 }
50164 {
50165 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50166 }
50167 {
50168 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50169 }
50170 {
50171 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50172 }
50173 {
50174 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50175 }
50176 {
50177 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50178 }
50179 {
50180 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50181 }
50182 {
50183 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50184 }
50185 {
50186 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50187 }
50188 {
50189 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50190 }
50191 {
50192 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50193 }
50194 {
50195 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50196 }
50197 {
50198 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50199 }
50200 {
50201 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50202 }
50203 {
50204 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50205 }
50206 {
50207 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50208 }
50209 {
50210 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50211 }
50212 {
50213 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50214 }
50215 {
50216 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50217 }
50218 {
50219 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50220 }
50221 {
50222 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50223 }
50224 {
50225 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50226 }
50227 {
50228 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50229 }
50230 {
50231 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50232 }
50233 {
50234 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50235 }
50236 {
50237 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50238 }
50239 {
50240 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50241 }
50242 {
50243 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50244 }
50245 {
50246 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50247 }
50248 {
50249 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50250 }
50251 {
50252 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50253 }
50254 {
50255 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50256 }
50257 {
50258 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50259 }
50260 {
50261 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50262 }
50263 {
50264 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50265 }
50266 {
50267 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50268 }
50269 {
50270 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50271 }
50272 {
50273 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50274 }
50275 {
50276 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50277 }
50278 {
50279 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50280 }
50281 {
50282 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50283 }
50284 {
50285 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50286 }
50287 {
50288 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50289 }
50290 {
50291 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50292 }
50293 {
50294 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50295 }
50296 {
50297 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50298 }
50299 {
50300 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50301 }
50302 {
50303 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50304 }
50305 {
50306 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50307 }
50308 {
50309 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50310 }
50311 {
50312 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50313 }
50314 {
50315 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50316 }
50317 {
50318 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50319 }
50320 {
50321 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50322 }
50323 {
50324 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50325 }
50326 {
50327 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50328 }
50329 {
50330 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50331 }
50332 {
50333 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50334 }
50335 {
50336 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50337 }
50338 {
50339 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50340 }
50341 {
50342 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50343 }
50344 {
50345 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50346 }
50347 {
50348 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50349 }
50350 {
50351 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50352 }
50353 {
50354 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50355 }
50356 {
50357 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50358 }
50359 {
50360 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50361 }
50362 {
50363 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50364 }
50365 {
50366 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50367 }
50368 {
50369 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50370 }
50371 {
50372 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50373 }
50374 {
50375 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50376 }
50377 {
50378 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50379 }
50380 {
50381 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50382 }
50383 {
50384 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50385 }
50386 {
50387 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50388 }
50389 {
50390 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50391 }
50392 {
50393 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50394 }
50395 {
50396 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50397 }
50398 {
50399 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50400 }
50401 {
50402 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50403 }
50404 {
50405 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50406 }
50407 {
50408 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50409 }
50410 {
50411 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50412 }
50413 {
50414 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50415 }
50416 {
50417 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50418 }
50419 {
50420 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50421 }
50422 {
50423 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50424 }
50425 {
50426 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50427 }
50428 {
50429 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50430 }
50431 {
50432 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50433 }
50434 {
50435 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50436 }
50437 {
50438 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50439 }
50440 {
50441 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50442 }
50443 {
50444 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50445 }
50446 {
50447 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50448 }
50449 {
50450 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50451 }
50452 {
50453 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50454 }
50455 {
50456 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50457 }
50458 {
50459 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50460 }
50461 {
50462 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50463 }
50464 {
50465 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50466 }
50467 {
50468 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50469 }
50470 {
50471 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50472 }
50473 {
50474 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50475 }
50476 {
50477 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50478 }
50479 {
50480 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50481 }
50482 {
50483 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50484 }
50485 {
50486 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50487 }
50488 {
50489 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50490 }
50491 {
50492 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50493 }
50494 {
50495 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50496 }
50497 {
50498 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50499 }
50500 {
50501 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50502 }
50503 {
50504 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50505 }
50506 {
50507 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50508 }
50509 {
50510 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50511 }
50512 {
50513 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50514 }
50515 {
50516 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50517 }
50518 {
50519 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50520 }
50521 {
50522 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50523 }
50524 {
50525 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50526 }
50527 {
50528 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50529 }
50530 {
50531 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50532 }
50533 {
50534 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50535 }
50536 {
50537 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50538 }
50539 {
50540 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50541 }
50542 {
50543 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50544 }
50545 {
50546 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50547 }
50548 {
50549 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50550 }
50551 {
50552 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50553 }
50554 {
50555 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50556 }
50557 {
50558 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50559 }
50560 {
50561 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50562 }
50563 {
50564 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50565 }
50566 {
50567 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50568 }
50569 {
50570 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50571 }
50572 {
50573 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50574 }
50575 {
50576 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50577 }
50578 {
50579 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50580 }
50581 {
50582 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50583 }
50584 {
50585 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50586 }
50587 {
50588 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50589 }
50590 {
50591 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50592 }
50593 {
50594 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50595 }
50596 {
50597 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50598 }
50599 {
50600 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50601 }
50602 {
50603 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50604 }
50605 {
50606 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50607 }
50608 {
50609 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50610 }
50611 {
50612 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50613 }
50614 {
50615 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50616 }
50617 {
50618 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50619 }
50620 {
50621 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50622 }
50623 {
50624 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50625 }
50626 {
50627 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50628 }
50629 {
50630 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50631 }
50632 {
50633 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50634 }
50635 {
50636 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50637 }
50638 {
50639 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50640 }
50641 {
50642 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50643 }
50644 {
50645 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50646 }
50647 {
50648 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50649 }
50650 {
50651 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50652 }
50653 {
50654 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50655 }
50656 {
50657 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50658 }
50659 {
50660 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50661 }
50662 {
50663 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50664 }
50665 {
50666 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50667 }
50668 {
50669 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50670 }
50671 {
50672 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50673 }
50674 {
50675 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50676 }
50677 {
50678 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50679 }
50680 {
50681 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50682 }
50683 {
50684 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50685 }
50686 {
50687 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50688 }
50689 {
50690 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50691 }
50692 {
50693 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50694 }
50695 {
50696 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50697 }
50698 {
50699 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50700 }
50701 {
50702 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50703 }
50704 {
50705 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50706 }
50707 {
50708 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50709 }
50710 {
50711 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50712 }
50713 {
50714 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50715 }
50716 {
50717 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50718 }
50719 {
50720 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50721 }
50722 {
50723 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50724 }
50725 {
50726 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50727 }
50728 {
50729 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50730 }
50731 {
50732 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50733 }
50734 {
50735 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50736 }
50737 {
50738 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50739 }
50740 {
50741 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50742 }
50743 {
50744 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50745 }
50746 {
50747 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
50748 }
50749 {
50750 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
50751 }
50752 {
50753 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
50754 }
50755 {
50756 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
50757 }
50758 {
50759 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
50760 }
50761 {
50762 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
50763 }
50764 {
50765 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
50766 }
50767 {
50768 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
50769 }
50770 {
50771 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
50772 }
50773 {
50774 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
50775 }
50776 {
50777 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
50778 }
50779 {
50780 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
50781 }
50782 {
50783 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
50784 }
50785 {
50786 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
50787 }
50788 {
50789 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
50790 }
50791 {
50792 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
50793 }
50794 {
50795 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
50796 }
50797 {
50798 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
50799 }
50800 {
50801 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
50802 }
50803 {
50804 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
50805 }
50806 {
50807 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
50808 }
50809 {
50810 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
50811 }
50812 {
50813 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
50814 }
50815 {
50816 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
50817 }
50818 {
50819 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
50820 }
50821 {
50822 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
50823 }
50824 {
50825 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
50826 }
50827 {
50828 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
50829 }
50830 {
50831 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
50832 }
50833 {
50834 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50835 }
50836 {
50837 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50838 }
50839 {
50840 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
50841 }
50842 {
50843 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
50844 }
50845 {
50846 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
50847 }
50848 {
50849 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
50850 }
50851 {
50852 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
50853 }
50854 {
50855 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
50856 }
50857 {
50858 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
50859 }
50860 {
50861 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
50862 }
50863 {
50864 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
50865 }
50866 {
50867 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
50868 }
50869 {
50870 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
50871 }
50872 {
50873 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
50874 }
50875 {
50876 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
50877 }
50878 {
50879 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
50880 }
50881 {
50882 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
50883 }
50884 {
50885 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
50886 }
50887 {
50888 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
50889 }
50890 {
50891 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
50892 }
50893 {
50894 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
50895 }
50896 {
50897 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
50898 }
50899 {
50900 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
50901 }
50902 {
50903 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
50904 }
50905 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50906 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50907 {
50908 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
50909 }
50910 {
50911 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
50912 }
50913 {
50914 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
50915 }
50916 {
50917 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
50918 }
50919 {
50920 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
50921 }
50922 {
50923 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
50924 }
50925 {
50926 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
50927 }
50928 {
50929 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
50930 }
50931 {
50932 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
50933 }
50934 {
50935 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
50936 }
50937 {
50938 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
50939 }
50940 {
50941 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
50942 }
50943 {
50944 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
50945 }
50946 {
50947 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
50948 }
50949 {
50950 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
50951 }
50952 {
50953 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
50954 }
50955 {
50956 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
50957 }
50958 {
50959 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
50960 }
50961 {
50962 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
50963 }
50964 {
50965 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
50966 }
50967 {
50968 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
50969 }
50970 {
50971 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
50972 }
50973 {
50974 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
50975 }
50976 {
50977 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
50978 }
50979 {
50980 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
50981 }
50982 {
50983 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
50984 }
50985 {
50986 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
50987 }
50988 {
50989 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
50990 }
50991 {
50992 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
50993 }
50994 {
50995 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
50996 }
50997 {
50998 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
50999 }
51000 {
51001 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51002 }
51003 {
51004 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51005 }
51006 {
51007 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51008 }
51009 {
51010 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51011 }
51012 {
51013 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51014 }
51015 {
51016 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51017 }
51018 {
51019 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51020 }
51021 {
51022 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51023 }
51024 {
51025 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51026 }
51027 {
51028 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51029 }
51030 {
51031 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51032 }
51033 {
51034 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51035 }
51036 {
51037 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51038 }
51039 {
51040 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51041 }
51042 {
51043 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51044 }
51045 {
51046 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51047 }
51048 {
51049 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51050 }
51051 {
51052 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51053 }
51054 {
51055 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51056 }
51057 {
51058 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51059 }
51060 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51061 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51062 {
51063 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51064 }
51065 {
51066 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51067 }
51068 {
51069 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51070 }
51071
51072 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51073
51074
51075 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51076
51077 {
51078 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51079 }
51080 {
51081 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51082 }
51083 {
51084 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51085 }
51086 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51087 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51088 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51089 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51090 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51091 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51092 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51093 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51094 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51095 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51096 {
51097 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51098 }
51099 {
51100 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51101 }
51102 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51103 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51104 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51105 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51106 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51107 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51108 {
51109 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51110 }
51111 {
51112 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51113 }
51114 {
51115 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51116 }
51117 {
51118 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51119 }
51120 {
51121 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51122 }
51123 {
51124 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51125 }
51126 {
51127 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51128 }
51129 {
51130 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51131 }
51132 {
51133 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51134 }
51135 {
51136 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51137 }
51138 {
51139 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51140 }
51141 {
51142 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51143 }
51144 {
51145 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51146 }
51147 {
51148 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51149 }
51150 {
51151 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51152 }
51153 {
51154 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51155 }
51156 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51157 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51158 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51159 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51160 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51161 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51162 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51163 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51164 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51165 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51166 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51167 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51168 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51169 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51170 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51171 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51172 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51173 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51174 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51175 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51176 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51177 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51178 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51179 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51180 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51181 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51182 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51183 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51184 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51185 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51186 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51187 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51188 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51189 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51190 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51191 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51192 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51193 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51194 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51195 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51196 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51197 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51198 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51199 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51200 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51201 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51202 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51203 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51204 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51205 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51206 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51207 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51208 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51209 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51210 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51211 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51212 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51213 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51214 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51215 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51216 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51217 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51218 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51219 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51220 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51221 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51222 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51223 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51224 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51225 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51226 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51227 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51228 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51229 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51230 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51231 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51232 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51233 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51234 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51235 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51236 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51237 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51238 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51239 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51240 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51241 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51242 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51243 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51244 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51245 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51246 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51247 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51248 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51249 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51250 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51251 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51252 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51253 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51254 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51255 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51256 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51257 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51258 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51259 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51260 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51261 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51262 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51263 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51264 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51265 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51266 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51267 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51268 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51269 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51270 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51271 {
51272 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51273 }
51274 {
51275 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51276 }
51277 {
51278 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51279 }
51280 {
51281 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51282 }
51283 {
51284 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51285 }
51286 {
51287 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51288 }
51289 {
51290 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51291 }
51292 {
51293 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51294 }
51295 {
51296 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51297 }
51298 {
51299 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51300 }
51301 {
51302 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51303 }
51304 {
51305 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51306 }
51307 {
51308 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51309 }
51310 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51311 {
51312 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51313 }
51314 {
51315 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51316 }
51317 {
51318 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51319 }
51320 {
51321 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51322 }
51323 {
51324 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51325 }
51326 {
51327 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51328 }
51329 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51330 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51331 {
51332 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51333 }
51334 {
51335 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51336 }
51337 {
51338 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51339 }
51340 {
51341 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51342 }
51343 {
51344 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51345 }
51346 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51347 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51348 {
51349 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51350 }
51351 {
51352 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51353 }
51354 {
51355 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51356 }
51357 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51358 {
51359 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51360 }
51361 {
51362 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51363 }
51364 {
51365 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51366 }
51367 {
51368 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51369 }
51370 {
51371 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51372 }
51373 {
51374 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51375 }
51376 {
51377 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51378 }
51379 {
51380 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51381 }
51382 {
51383 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51384 }
51385 {
51386 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51387 }
51388 {
51389 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51390 }
51391 {
51392 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51393 }
51394 {
51395 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51396 }
51397 {
51398 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51399 }
51400 {
51401 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51402 }
51403 {
51404 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51405 }
51406 {
51407 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51408 }
51409 {
51410 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51411 }
51412 {
51413 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51414 }
51415
51416 // Initialize threading, some globals and such
51417 __wxPyPreStart(d);
51418
51419
51420 // Although these are defined in __version__ they need to be here too so
51421 // that an assert can be done to ensure that the wxPython and the wxWindows
51422 // versions match.
51423 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51424 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51425 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51426
51427 }
51428
wxWidgets (Impactor)