]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29 /***********************************************************************
30 *
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 *
34 ************************************************************************/
35
36 /* template workaround for compilers that cannot correctly implement the C++ standard */
37 #ifndef SWIGTEMPLATEDISAMBIGUATOR
38 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 #endif
44
45 /* inline attribute */
46 #ifndef SWIGINLINE
47 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
48 # define SWIGINLINE inline
49 # else
50 # define SWIGINLINE
51 # endif
52 #endif
53
54 /* attribute recognised by some compilers to avoid 'unused' warnings */
55 #ifndef SWIGUNUSED
56 # if defined(__GNUC__) || defined(__ICC)
57 # define SWIGUNUSED __attribute__ ((unused))
58 # else
59 # define SWIGUNUSED
60 # endif
61 #endif
62
63 /* internal SWIG method */
64 #ifndef SWIGINTERN
65 # define SWIGINTERN static SWIGUNUSED
66 #endif
67
68 /* internal inline SWIG method */
69 #ifndef SWIGINTERNINLINE
70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
71 #endif
72
73 /* exporting methods for Windows DLLs */
74 #ifndef SWIGEXPORT
75 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
76 # if defined(STATIC_LINKED)
77 # define SWIGEXPORT
78 # else
79 # define SWIGEXPORT __declspec(dllexport)
80 # endif
81 # else
82 # define SWIGEXPORT
83 # endif
84 #endif
85
86 /* calling conventions for Windows */
87 #ifndef SWIGSTDCALL
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # define SWIGSTDCALL __stdcall
90 # else
91 # define SWIGSTDCALL
92 # endif
93 #endif
94
95
96
97 #include <Python.h>
98
99 /***********************************************************************
100 * swigrun.swg
101 *
102 * This file contains generic CAPI SWIG runtime support for pointer
103 * type checking.
104 *
105 ************************************************************************/
106
107 /* This should only be incremented when either the layout of swig_type_info changes,
108 or for whatever reason, the runtime changes incompatibly */
109 #define SWIG_RUNTIME_VERSION "2"
110
111 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
112 #ifdef SWIG_TYPE_TABLE
113 # define SWIG_QUOTE_STRING(x) #x
114 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
115 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
116 #else
117 # define SWIG_TYPE_TABLE_NAME
118 #endif
119
120 /*
121 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
122 creating a static or dynamic library from the swig runtime code.
123 In 99.9% of the cases, swig just needs to declare them as 'static'.
124
125 But only do this if is strictly necessary, ie, if you have problems
126 with your compiler or so.
127 */
128
129 #ifndef SWIGRUNTIME
130 # define SWIGRUNTIME SWIGINTERN
131 #endif
132
133 #ifndef SWIGRUNTIMEINLINE
134 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
135 #endif
136
137 #include <string.h>
138
139 #ifdef __cplusplus
140 extern "C" {
141 #endif
142
143 typedef void *(*swig_converter_func)(void *);
144 typedef struct swig_type_info *(*swig_dycast_func)(void **);
145
146 /* Structure to store inforomation on one type */
147 typedef struct swig_type_info {
148 const char *name; /* mangled name of this type */
149 const char *str; /* human readable name of this type */
150 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
151 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
152 void *clientdata; /* language specific type data */
153 } swig_type_info;
154
155 /* Structure to store a type and conversion function used for casting */
156 typedef struct swig_cast_info {
157 swig_type_info *type; /* pointer to type that is equivalent to this type */
158 swig_converter_func converter; /* function to cast the void pointers */
159 struct swig_cast_info *next; /* pointer to next cast in linked list */
160 struct swig_cast_info *prev; /* pointer to the previous cast */
161 } swig_cast_info;
162
163 /* Structure used to store module information
164 * Each module generates one structure like this, and the runtime collects
165 * all of these structures and stores them in a circularly linked list.*/
166 typedef struct swig_module_info {
167 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
168 size_t size; /* Number of types in this module */
169 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
170 swig_type_info **type_initial; /* Array of initially generated type structures */
171 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
172 void *clientdata; /* Language specific module data */
173 } swig_module_info;
174
175
176 /*
177 Compare two type names skipping the space characters, therefore
178 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
179
180 Return 0 when the two name types are equivalent, as in
181 strncmp, but skipping ' '.
182 */
183 SWIGRUNTIME int
184 SWIG_TypeNameComp(const char *f1, const char *l1,
185 const char *f2, const char *l2) {
186 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
187 while ((*f1 == ' ') && (f1 != l1)) ++f1;
188 while ((*f2 == ' ') && (f2 != l2)) ++f2;
189 if (*f1 != *f2) return (int)(*f1 - *f2);
190 }
191 return (l1 - f1) - (l2 - f2);
192 }
193
194 /*
195 Check type equivalence in a name list like <name1>|<name2>|...
196 Return 0 if not equal, 1 if equal
197 */
198 SWIGRUNTIME int
199 SWIG_TypeEquiv(const char *nb, const char *tb) {
200 int equiv = 0;
201 const char* te = tb + strlen(tb);
202 const char* ne = nb;
203 while (!equiv && *ne) {
204 for (nb = ne; *ne; ++ne) {
205 if (*ne == '|') break;
206 }
207 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
208 if (*ne) ++ne;
209 }
210 return equiv;
211 }
212
213 /*
214 Check type equivalence in a name list like <name1>|<name2>|...
215 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
216 */
217 SWIGRUNTIME int
218 SWIG_TypeCompare(const char *nb, const char *tb) {
219 int equiv = 0;
220 const char* te = tb + strlen(tb);
221 const char* ne = nb;
222 while (!equiv && *ne) {
223 for (nb = ne; *ne; ++ne) {
224 if (*ne == '|') break;
225 }
226 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
227 if (*ne) ++ne;
228 }
229 return equiv;
230 }
231
232
233 /* think of this as a c++ template<> or a scheme macro */
234 #define SWIG_TypeCheck_Template(comparison, ty) \
235 if (ty) { \
236 swig_cast_info *iter = ty->cast; \
237 while (iter) { \
238 if (comparison) { \
239 if (iter == ty->cast) return iter; \
240 /* Move iter to the top of the linked list */ \
241 iter->prev->next = iter->next; \
242 if (iter->next) \
243 iter->next->prev = iter->prev; \
244 iter->next = ty->cast; \
245 iter->prev = 0; \
246 if (ty->cast) ty->cast->prev = iter; \
247 ty->cast = iter; \
248 return iter; \
249 } \
250 iter = iter->next; \
251 } \
252 } \
253 return 0
254
255 /*
256 Check the typename
257 */
258 SWIGRUNTIME swig_cast_info *
259 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
260 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
261 }
262
263 /* Same as previous function, except strcmp is replaced with a pointer comparison */
264 SWIGRUNTIME swig_cast_info *
265 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
266 SWIG_TypeCheck_Template(iter->type == from, into);
267 }
268
269 /*
270 Cast a pointer up an inheritance hierarchy
271 */
272 SWIGRUNTIMEINLINE void *
273 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
274 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
275 }
276
277 /*
278 Dynamic pointer casting. Down an inheritance hierarchy
279 */
280 SWIGRUNTIME swig_type_info *
281 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
282 swig_type_info *lastty = ty;
283 if (!ty || !ty->dcast) return ty;
284 while (ty && (ty->dcast)) {
285 ty = (*ty->dcast)(ptr);
286 if (ty) lastty = ty;
287 }
288 return lastty;
289 }
290
291 /*
292 Return the name associated with this type
293 */
294 SWIGRUNTIMEINLINE const char *
295 SWIG_TypeName(const swig_type_info *ty) {
296 return ty->name;
297 }
298
299 /*
300 Return the pretty name associated with this type,
301 that is an unmangled type name in a form presentable to the user.
302 */
303 SWIGRUNTIME const char *
304 SWIG_TypePrettyName(const swig_type_info *type) {
305 /* The "str" field contains the equivalent pretty names of the
306 type, separated by vertical-bar characters. We choose
307 to print the last name, as it is often (?) the most
308 specific. */
309 if (type->str != NULL) {
310 const char *last_name = type->str;
311 const char *s;
312 for (s = type->str; *s; s++)
313 if (*s == '|') last_name = s+1;
314 return last_name;
315 }
316 else
317 return type->name;
318 }
319
320 /*
321 Set the clientdata field for a type
322 */
323 SWIGRUNTIME void
324 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
325 swig_cast_info *cast = ti->cast;
326 /* if (ti->clientdata == clientdata) return; */
327 ti->clientdata = clientdata;
328
329 while (cast) {
330 if (!cast->converter) {
331 swig_type_info *tc = cast->type;
332 if (!tc->clientdata) {
333 SWIG_TypeClientData(tc, clientdata);
334 }
335 }
336 cast = cast->next;
337 }
338 }
339
340 /*
341 Search for a swig_type_info structure only by mangled name
342 Search is a O(log #types)
343
344 We start searching at module start, and finish searching when start == end.
345 Note: if start == end at the beginning of the function, we go all the way around
346 the circular list.
347 */
348 SWIGRUNTIME swig_type_info *
349 SWIG_MangledTypeQueryModule(swig_module_info *start,
350 swig_module_info *end,
351 const char *name) {
352 swig_module_info *iter = start;
353 do {
354 if (iter->size) {
355 register size_t l = 0;
356 register size_t r = iter->size - 1;
357 do {
358 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
359 register size_t i = (l + r) >> 1;
360 const char *iname = iter->types[i]->name;
361 if (iname) {
362 register int compare = strcmp(name, iname);
363 if (compare == 0) {
364 return iter->types[i];
365 } else if (compare < 0) {
366 if (i) {
367 r = i - 1;
368 } else {
369 break;
370 }
371 } else if (compare > 0) {
372 l = i + 1;
373 }
374 } else {
375 break; /* should never happen */
376 }
377 } while (l <= r);
378 }
379 iter = iter->next;
380 } while (iter != end);
381 return 0;
382 }
383
384 /*
385 Search for a swig_type_info structure for either a mangled name or a human readable name.
386 It first searches the mangled names of the types, which is a O(log #types)
387 If a type is not found it then searches the human readable names, which is O(#types).
388
389 We start searching at module start, and finish searching when start == end.
390 Note: if start == end at the beginning of the function, we go all the way around
391 the circular list.
392 */
393 SWIGRUNTIME swig_type_info *
394 SWIG_TypeQueryModule(swig_module_info *start,
395 swig_module_info *end,
396 const char *name) {
397 /* STEP 1: Search the name field using binary search */
398 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
399 if (ret) {
400 return ret;
401 } else {
402 /* STEP 2: If the type hasn't been found, do a complete search
403 of the str field (the human readable name) */
404 swig_module_info *iter = start;
405 do {
406 register size_t i = 0;
407 for (; i < iter->size; ++i) {
408 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
409 return iter->types[i];
410 }
411 iter = iter->next;
412 } while (iter != end);
413 }
414
415 /* neither found a match */
416 return 0;
417 }
418
419
420 /*
421 Pack binary data into a string
422 */
423 SWIGRUNTIME char *
424 SWIG_PackData(char *c, void *ptr, size_t sz) {
425 static const char hex[17] = "0123456789abcdef";
426 register const unsigned char *u = (unsigned char *) ptr;
427 register const unsigned char *eu = u + sz;
428 for (; u != eu; ++u) {
429 register unsigned char uu = *u;
430 *(c++) = hex[(uu & 0xf0) >> 4];
431 *(c++) = hex[uu & 0xf];
432 }
433 return c;
434 }
435
436 /*
437 Unpack binary data from a string
438 */
439 SWIGRUNTIME const char *
440 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
441 register unsigned char *u = (unsigned char *) ptr;
442 register const unsigned char *eu = u + sz;
443 for (; u != eu; ++u) {
444 register char d = *(c++);
445 register unsigned char uu = 0;
446 if ((d >= '0') && (d <= '9'))
447 uu = ((d - '0') << 4);
448 else if ((d >= 'a') && (d <= 'f'))
449 uu = ((d - ('a'-10)) << 4);
450 else
451 return (char *) 0;
452 d = *(c++);
453 if ((d >= '0') && (d <= '9'))
454 uu |= (d - '0');
455 else if ((d >= 'a') && (d <= 'f'))
456 uu |= (d - ('a'-10));
457 else
458 return (char *) 0;
459 *u = uu;
460 }
461 return c;
462 }
463
464 /*
465 Pack 'void *' into a string buffer.
466 */
467 SWIGRUNTIME char *
468 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
469 char *r = buff;
470 if ((2*sizeof(void *) + 2) > bsz) return 0;
471 *(r++) = '_';
472 r = SWIG_PackData(r,&ptr,sizeof(void *));
473 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
474 strcpy(r,name);
475 return buff;
476 }
477
478 SWIGRUNTIME const char *
479 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
480 if (*c != '_') {
481 if (strcmp(c,"NULL") == 0) {
482 *ptr = (void *) 0;
483 return name;
484 } else {
485 return 0;
486 }
487 }
488 return SWIG_UnpackData(++c,ptr,sizeof(void *));
489 }
490
491 SWIGRUNTIME char *
492 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
493 char *r = buff;
494 size_t lname = (name ? strlen(name) : 0);
495 if ((2*sz + 2 + lname) > bsz) return 0;
496 *(r++) = '_';
497 r = SWIG_PackData(r,ptr,sz);
498 if (lname) {
499 strncpy(r,name,lname+1);
500 } else {
501 *r = 0;
502 }
503 return buff;
504 }
505
506 SWIGRUNTIME const char *
507 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
508 if (*c != '_') {
509 if (strcmp(c,"NULL") == 0) {
510 memset(ptr,0,sz);
511 return name;
512 } else {
513 return 0;
514 }
515 }
516 return SWIG_UnpackData(++c,ptr,sz);
517 }
518
519 #ifdef __cplusplus
520 }
521 #endif
522
523 /* -----------------------------------------------------------------------------
524 * SWIG API. Portion that goes into the runtime
525 * ----------------------------------------------------------------------------- */
526
527 #ifdef __cplusplus
528 extern "C" {
529 #endif
530
531 /* -----------------------------------------------------------------------------
532 * for internal method declarations
533 * ----------------------------------------------------------------------------- */
534
535 #ifndef SWIGINTERN
536 # define SWIGINTERN static SWIGUNUSED
537 #endif
538
539 #ifndef SWIGINTERNINLINE
540 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
541 #endif
542
543 /*
544 Exception handling in wrappers
545 */
546 #define SWIG_fail goto fail
547 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
548 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
549 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
550 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
551 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
552
553 /*
554 Contract support
555 */
556 #define SWIG_contract_assert(expr, msg) \
557 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
558
559 /* -----------------------------------------------------------------------------
560 * Constant declarations
561 * ----------------------------------------------------------------------------- */
562
563 /* Constant Types */
564 #define SWIG_PY_INT 1
565 #define SWIG_PY_FLOAT 2
566 #define SWIG_PY_STRING 3
567 #define SWIG_PY_POINTER 4
568 #define SWIG_PY_BINARY 5
569
570 /* Constant information structure */
571 typedef struct swig_const_info {
572 int type;
573 char *name;
574 long lvalue;
575 double dvalue;
576 void *pvalue;
577 swig_type_info **ptype;
578 } swig_const_info;
579
580
581 /* -----------------------------------------------------------------------------
582 * Alloc. memory flags
583 * ----------------------------------------------------------------------------- */
584 #define SWIG_OLDOBJ 1
585 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
586 #define SWIG_PYSTR SWIG_NEWOBJ + 1
587
588 #ifdef __cplusplus
589 }
590 #endif
591
592
593 /***********************************************************************
594 * pyrun.swg
595 *
596 * This file contains the runtime support for Python modules
597 * and includes code for managing global variables and pointer
598 * type checking.
599 *
600 * Author : David Beazley (beazley@cs.uchicago.edu)
601 ************************************************************************/
602
603 /* Common SWIG API */
604 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
605 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
606 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
607
608
609 /* Python-specific SWIG API */
610 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
611 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
612
613 /* Runtime API */
614 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
615 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
616
617 /* -----------------------------------------------------------------------------
618 * Pointer declarations
619 * ----------------------------------------------------------------------------- */
620 /*
621 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
622 C/C++ pointers in the python side. Very useful for debugging, but
623 not always safe.
624 */
625 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
626 # define SWIG_COBJECT_TYPES
627 #endif
628
629 /* Flags for pointer conversion */
630 #define SWIG_POINTER_EXCEPTION 0x1
631 #define SWIG_POINTER_DISOWN 0x2
632
633
634 /* Add PyOS_snprintf for old Pythons */
635 #if PY_VERSION_HEX < 0x02020000
636 #define PyOS_snprintf snprintf
637 #endif
638
639 #ifdef __cplusplus
640 extern "C" {
641 #endif
642
643 /* -----------------------------------------------------------------------------
644 * Create a new pointer string
645 * ----------------------------------------------------------------------------- */
646 #ifndef SWIG_BUFFER_SIZE
647 #define SWIG_BUFFER_SIZE 1024
648 #endif
649
650 /* A crude PyString_FromFormat implementation for old Pythons */
651 #if PY_VERSION_HEX < 0x02020000
652 static PyObject *
653 PyString_FromFormat(const char *fmt, ...) {
654 va_list ap;
655 char buf[SWIG_BUFFER_SIZE * 2];
656 int res;
657 va_start(ap, fmt);
658 res = vsnprintf(buf, sizeof(buf), fmt, ap);
659 va_end(ap);
660 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
661 }
662 #endif
663
664 #if PY_VERSION_HEX < 0x01060000
665 #define PyObject_Del(op) PyMem_DEL((op))
666 #endif
667
668 #if defined(SWIG_COBJECT_TYPES)
669 #if !defined(SWIG_COBJECT_PYTHON)
670 /* -----------------------------------------------------------------------------
671 * Implements a simple Swig Object type, and use it instead of PyCObject
672 * ----------------------------------------------------------------------------- */
673
674 typedef struct {
675 PyObject_HEAD
676 void *ptr;
677 const char *desc;
678 } PySwigObject;
679
680 /* Declarations for objects of type PySwigObject */
681
682 SWIGRUNTIME int
683 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
684 {
685 char result[SWIG_BUFFER_SIZE];
686 flags = flags;
687 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
688 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
689 return 0;
690 } else {
691 return 1;
692 }
693 }
694
695 SWIGRUNTIME PyObject *
696 PySwigObject_repr(PySwigObject *v)
697 {
698 char result[SWIG_BUFFER_SIZE];
699 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
700 PyString_FromFormat("<Swig Object at %s>", result) : 0;
701 }
702
703 SWIGRUNTIME PyObject *
704 PySwigObject_str(PySwigObject *v)
705 {
706 char result[SWIG_BUFFER_SIZE];
707 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
708 PyString_FromString(result) : 0;
709 }
710
711 SWIGRUNTIME PyObject *
712 PySwigObject_long(PySwigObject *v)
713 {
714 return PyLong_FromVoidPtr(v->ptr);
715 }
716
717 SWIGRUNTIME PyObject *
718 PySwigObject_format(const char* fmt, PySwigObject *v)
719 {
720 PyObject *res = NULL;
721 PyObject *args = PyTuple_New(1);
722 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
723 PyObject *ofmt = PyString_FromString(fmt);
724 if (ofmt) {
725 res = PyString_Format(ofmt,args);
726 Py_DECREF(ofmt);
727 }
728 Py_DECREF(args);
729 }
730 return res;
731 }
732
733 SWIGRUNTIME PyObject *
734 PySwigObject_oct(PySwigObject *v)
735 {
736 return PySwigObject_format("%o",v);
737 }
738
739 SWIGRUNTIME PyObject *
740 PySwigObject_hex(PySwigObject *v)
741 {
742 return PySwigObject_format("%x",v);
743 }
744
745 SWIGRUNTIME int
746 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
747 {
748 int c = strcmp(v->desc, w->desc);
749 if (c) {
750 return (c > 0) ? 1 : -1;
751 } else {
752 void *i = v->ptr;
753 void *j = w->ptr;
754 return (i < j) ? -1 : ((i > j) ? 1 : 0);
755 }
756 }
757
758 SWIGRUNTIME void
759 PySwigObject_dealloc(PySwigObject *self)
760 {
761 PyObject_Del(self);
762 }
763
764 SWIGRUNTIME PyTypeObject*
765 PySwigObject_type(void) {
766 static char pyswigobject_type__doc__[] =
767 "Swig object carries a C/C++ instance pointer";
768
769 static PyNumberMethods PySwigObject_as_number = {
770 (binaryfunc)0, /*nb_add*/
771 (binaryfunc)0, /*nb_subtract*/
772 (binaryfunc)0, /*nb_multiply*/
773 (binaryfunc)0, /*nb_divide*/
774 (binaryfunc)0, /*nb_remainder*/
775 (binaryfunc)0, /*nb_divmod*/
776 (ternaryfunc)0,/*nb_power*/
777 (unaryfunc)0, /*nb_negative*/
778 (unaryfunc)0, /*nb_positive*/
779 (unaryfunc)0, /*nb_absolute*/
780 (inquiry)0, /*nb_nonzero*/
781 0, /*nb_invert*/
782 0, /*nb_lshift*/
783 0, /*nb_rshift*/
784 0, /*nb_and*/
785 0, /*nb_xor*/
786 0, /*nb_or*/
787 (coercion)0, /*nb_coerce*/
788 (unaryfunc)PySwigObject_long, /*nb_int*/
789 (unaryfunc)PySwigObject_long, /*nb_long*/
790 (unaryfunc)0, /*nb_float*/
791 (unaryfunc)PySwigObject_oct, /*nb_oct*/
792 (unaryfunc)PySwigObject_hex, /*nb_hex*/
793 #if PY_VERSION_HEX >= 0x02020000
794 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
795 #elif PY_VERSION_HEX >= 0x02000000
796 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
797 #endif
798 };
799
800 static PyTypeObject pyswigobject_type
801 #if !defined(__cplusplus)
802 ;
803 static int type_init = 0;
804 if (!type_init) {
805 PyTypeObject tmp
806 #endif
807 = {
808 PyObject_HEAD_INIT(&PyType_Type)
809 0, /*ob_size*/
810 (char *)"PySwigObject", /*tp_name*/
811 sizeof(PySwigObject), /*tp_basicsize*/
812 0, /*tp_itemsize*/
813 /* methods */
814 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
815 (printfunc)PySwigObject_print, /*tp_print*/
816 (getattrfunc)0, /*tp_getattr*/
817 (setattrfunc)0, /*tp_setattr*/
818 (cmpfunc)PySwigObject_compare, /*tp_compare*/
819 (reprfunc)PySwigObject_repr, /*tp_repr*/
820 &PySwigObject_as_number, /*tp_as_number*/
821 0, /*tp_as_sequence*/
822 0, /*tp_as_mapping*/
823 (hashfunc)0, /*tp_hash*/
824 (ternaryfunc)0, /*tp_call*/
825 (reprfunc)PySwigObject_str, /*tp_str*/
826 /* Space for future expansion */
827 0,0,0,0,
828 pyswigobject_type__doc__, /* Documentation string */
829 #if PY_VERSION_HEX >= 0x02000000
830 0, /* tp_traverse */
831 0, /* tp_clear */
832 #endif
833 #if PY_VERSION_HEX >= 0x02010000
834 0, /* tp_richcompare */
835 0, /* tp_weaklistoffset */
836 #endif
837 #if PY_VERSION_HEX >= 0x02020000
838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
839 #endif
840 #if PY_VERSION_HEX >= 0x02030000
841 0, /* tp_del */
842 #endif
843 #ifdef COUNT_ALLOCS
844 0,0,0,0 /* tp_alloc -> tp_next */
845 #endif
846 };
847 #if !defined(__cplusplus)
848 pyswigobject_type = tmp;
849 type_init = 1;
850 }
851 #endif
852 return &pyswigobject_type;
853 }
854
855 SWIGRUNTIME PyObject *
856 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
857 {
858 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
859 if (self) {
860 self->ptr = ptr;
861 self->desc = desc;
862 }
863 return (PyObject *)self;
864 }
865
866 SWIGRUNTIMEINLINE void *
867 PySwigObject_AsVoidPtr(PyObject *self)
868 {
869 return ((PySwigObject *)self)->ptr;
870 }
871
872 SWIGRUNTIMEINLINE const char *
873 PySwigObject_GetDesc(PyObject *self)
874 {
875 return ((PySwigObject *)self)->desc;
876 }
877
878 SWIGRUNTIMEINLINE int
879 PySwigObject_Check(PyObject *op) {
880 return ((op)->ob_type == PySwigObject_type())
881 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
882 }
883
884 /* -----------------------------------------------------------------------------
885 * Implements a simple Swig Packed type, and use it instead of string
886 * ----------------------------------------------------------------------------- */
887
888 typedef struct {
889 PyObject_HEAD
890 void *pack;
891 const char *desc;
892 size_t size;
893 } PySwigPacked;
894
895 SWIGRUNTIME int
896 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
897 {
898 char result[SWIG_BUFFER_SIZE];
899 flags = flags;
900 fputs("<Swig Packed ", fp);
901 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
902 fputs("at ", fp);
903 fputs(result, fp);
904 }
905 fputs(v->desc,fp);
906 fputs(">", fp);
907 return 0;
908 }
909
910 SWIGRUNTIME PyObject *
911 PySwigPacked_repr(PySwigPacked *v)
912 {
913 char result[SWIG_BUFFER_SIZE];
914 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
915 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
916 } else {
917 return PyString_FromFormat("<Swig Packed %s>", v->desc);
918 }
919 }
920
921 SWIGRUNTIME PyObject *
922 PySwigPacked_str(PySwigPacked *v)
923 {
924 char result[SWIG_BUFFER_SIZE];
925 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
926 return PyString_FromFormat("%s%s", result, v->desc);
927 } else {
928 return PyString_FromString(v->desc);
929 }
930 }
931
932 SWIGRUNTIME int
933 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
934 {
935 int c = strcmp(v->desc, w->desc);
936 if (c) {
937 return (c > 0) ? 1 : -1;
938 } else {
939 size_t i = v->size;
940 size_t j = w->size;
941 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
942 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
943 }
944 }
945
946 SWIGRUNTIME void
947 PySwigPacked_dealloc(PySwigPacked *self)
948 {
949 free(self->pack);
950 PyObject_Del(self);
951 }
952
953 SWIGRUNTIME PyTypeObject*
954 PySwigPacked_type(void) {
955 static char pyswigpacked_type__doc__[] =
956 "Swig object carries a C/C++ instance pointer";
957 static PyTypeObject pyswigpacked_type
958 #if !defined(__cplusplus)
959 ;
960 static int type_init = 0;
961 if (!type_init) {
962 PyTypeObject tmp
963 #endif
964 = {
965 PyObject_HEAD_INIT(&PyType_Type)
966 0, /*ob_size*/
967 (char *)"PySwigPacked", /*tp_name*/
968 sizeof(PySwigPacked), /*tp_basicsize*/
969 0, /*tp_itemsize*/
970 /* methods */
971 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
972 (printfunc)PySwigPacked_print, /*tp_print*/
973 (getattrfunc)0, /*tp_getattr*/
974 (setattrfunc)0, /*tp_setattr*/
975 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
976 (reprfunc)PySwigPacked_repr, /*tp_repr*/
977 0, /*tp_as_number*/
978 0, /*tp_as_sequence*/
979 0, /*tp_as_mapping*/
980 (hashfunc)0, /*tp_hash*/
981 (ternaryfunc)0, /*tp_call*/
982 (reprfunc)PySwigPacked_str, /*tp_str*/
983 /* Space for future expansion */
984 0,0,0,0,
985 pyswigpacked_type__doc__, /* Documentation string */
986 #if PY_VERSION_HEX >= 0x02000000
987 0, /* tp_traverse */
988 0, /* tp_clear */
989 #endif
990 #if PY_VERSION_HEX >= 0x02010000
991 0, /* tp_richcompare */
992 0, /* tp_weaklistoffset */
993 #endif
994 #if PY_VERSION_HEX >= 0x02020000
995 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
996 #endif
997 #if PY_VERSION_HEX >= 0x02030000
998 0, /* tp_del */
999 #endif
1000 #ifdef COUNT_ALLOCS
1001 0,0,0,0 /* tp_alloc -> tp_next */
1002 #endif
1003 };
1004 #if !defined(__cplusplus)
1005 pyswigpacked_type = tmp;
1006 type_init = 1;
1007 }
1008 #endif
1009 return &pyswigpacked_type;
1010 }
1011
1012 SWIGRUNTIME PyObject *
1013 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1014 {
1015 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1016 if (self == NULL) {
1017 return NULL;
1018 } else {
1019 void *pack = malloc(size);
1020 if (pack) {
1021 memcpy(pack, ptr, size);
1022 self->pack = pack;
1023 self->desc = desc;
1024 self->size = size;
1025 return (PyObject *) self;
1026 }
1027 return NULL;
1028 }
1029 }
1030
1031 SWIGRUNTIMEINLINE const char *
1032 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1033 {
1034 PySwigPacked *self = (PySwigPacked *)obj;
1035 if (self->size != size) return 0;
1036 memcpy(ptr, self->pack, size);
1037 return self->desc;
1038 }
1039
1040 SWIGRUNTIMEINLINE const char *
1041 PySwigPacked_GetDesc(PyObject *self)
1042 {
1043 return ((PySwigPacked *)self)->desc;
1044 }
1045
1046 SWIGRUNTIMEINLINE int
1047 PySwigPacked_Check(PyObject *op) {
1048 return ((op)->ob_type == PySwigPacked_type())
1049 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1050 }
1051
1052 #else
1053 /* -----------------------------------------------------------------------------
1054 * Use the old Python PyCObject instead of PySwigObject
1055 * ----------------------------------------------------------------------------- */
1056
1057 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1058 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1059 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1060 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1061
1062 #endif
1063
1064 #endif
1065
1066 /* -----------------------------------------------------------------------------
1067 * errors manipulation
1068 * ----------------------------------------------------------------------------- */
1069
1070 SWIGRUNTIME void
1071 SWIG_Python_TypeError(const char *type, PyObject *obj)
1072 {
1073 if (type) {
1074 #if defined(SWIG_COBJECT_TYPES)
1075 if (obj && PySwigObject_Check(obj)) {
1076 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1077 if (otype) {
1078 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1079 type, otype);
1080 return;
1081 }
1082 } else
1083 #endif
1084 {
1085 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1086 if (otype) {
1087 PyObject *str = PyObject_Str(obj);
1088 const char *cstr = str ? PyString_AsString(str) : 0;
1089 if (cstr) {
1090 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1091 type, otype, cstr);
1092 } else {
1093 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1094 type, otype);
1095 }
1096 Py_XDECREF(str);
1097 return;
1098 }
1099 }
1100 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1101 } else {
1102 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1103 }
1104 }
1105
1106 SWIGRUNTIMEINLINE void
1107 SWIG_Python_NullRef(const char *type)
1108 {
1109 if (type) {
1110 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1111 } else {
1112 PyErr_Format(PyExc_TypeError, "null reference was received");
1113 }
1114 }
1115
1116 SWIGRUNTIME int
1117 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1118 {
1119 if (PyErr_Occurred()) {
1120 PyObject *type = 0;
1121 PyObject *value = 0;
1122 PyObject *traceback = 0;
1123 PyErr_Fetch(&type, &value, &traceback);
1124 if (value) {
1125 PyObject *old_str = PyObject_Str(value);
1126 Py_XINCREF(type);
1127 PyErr_Clear();
1128 if (infront) {
1129 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1130 } else {
1131 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1132 }
1133 Py_DECREF(old_str);
1134 }
1135 return 1;
1136 } else {
1137 return 0;
1138 }
1139 }
1140
1141 SWIGRUNTIME int
1142 SWIG_Python_ArgFail(int argnum)
1143 {
1144 if (PyErr_Occurred()) {
1145 /* add information about failing argument */
1146 char mesg[256];
1147 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1148 return SWIG_Python_AddErrMesg(mesg, 1);
1149 } else {
1150 return 0;
1151 }
1152 }
1153
1154
1155 /* -----------------------------------------------------------------------------
1156 * pointers/data manipulation
1157 * ----------------------------------------------------------------------------- */
1158
1159 /* Convert a pointer value */
1160 SWIGRUNTIME int
1161 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1162 swig_cast_info *tc;
1163 const char *c = 0;
1164 static PyObject *SWIG_this = 0;
1165 int newref = 0;
1166 PyObject *pyobj = 0;
1167 void *vptr;
1168
1169 if (!obj) return 0;
1170 if (obj == Py_None) {
1171 *ptr = 0;
1172 return 0;
1173 }
1174
1175 #ifdef SWIG_COBJECT_TYPES
1176 if (!(PySwigObject_Check(obj))) {
1177 if (!SWIG_this)
1178 SWIG_this = PyString_FromString("this");
1179 pyobj = obj;
1180 obj = PyObject_GetAttr(obj,SWIG_this);
1181 newref = 1;
1182 if (!obj) goto type_error;
1183 if (!PySwigObject_Check(obj)) {
1184 Py_DECREF(obj);
1185 goto type_error;
1186 }
1187 }
1188 vptr = PySwigObject_AsVoidPtr(obj);
1189 c = (const char *) PySwigObject_GetDesc(obj);
1190 if (newref) { Py_DECREF(obj); }
1191 goto type_check;
1192 #else
1193 if (!(PyString_Check(obj))) {
1194 if (!SWIG_this)
1195 SWIG_this = PyString_FromString("this");
1196 pyobj = obj;
1197 obj = PyObject_GetAttr(obj,SWIG_this);
1198 newref = 1;
1199 if (!obj) goto type_error;
1200 if (!PyString_Check(obj)) {
1201 Py_DECREF(obj);
1202 goto type_error;
1203 }
1204 }
1205 c = PyString_AsString(obj);
1206 /* Pointer values must start with leading underscore */
1207 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1208 if (newref) { Py_DECREF(obj); }
1209 if (!c) goto type_error;
1210 #endif
1211
1212 type_check:
1213 if (ty) {
1214 tc = SWIG_TypeCheck(c,ty);
1215 if (!tc) goto type_error;
1216 *ptr = SWIG_TypeCast(tc,vptr);
1217 } else {
1218 *ptr = vptr;
1219 }
1220 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1221 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1222 }
1223 return 0;
1224
1225 type_error:
1226 PyErr_Clear();
1227 if (pyobj && !obj) {
1228 obj = pyobj;
1229 if (PyCFunction_Check(obj)) {
1230 /* here we get the method pointer for callbacks */
1231 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1232 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1233 if (c) {
1234 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1235 if (!c) goto type_error;
1236 goto type_check;
1237 }
1238 }
1239 }
1240 if (flags & SWIG_POINTER_EXCEPTION) {
1241 if (ty) {
1242 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1243 } else {
1244 SWIG_Python_TypeError("C/C++ pointer", obj);
1245 }
1246 }
1247 return -1;
1248 }
1249
1250 /* Convert a pointer value, signal an exception on a type mismatch */
1251 SWIGRUNTIME void *
1252 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1253 void *result;
1254 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1255 PyErr_Clear();
1256 if (flags & SWIG_POINTER_EXCEPTION) {
1257 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1258 SWIG_Python_ArgFail(argnum);
1259 }
1260 }
1261 return result;
1262 }
1263
1264 /* Convert a packed value value */
1265 SWIGRUNTIME int
1266 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1267 swig_cast_info *tc;
1268 const char *c = 0;
1269
1270 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1271 c = PySwigPacked_UnpackData(obj, ptr, sz);
1272 #else
1273 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1274 c = PyString_AsString(obj);
1275 /* Pointer values must start with leading underscore */
1276 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1277 #endif
1278 if (!c) goto type_error;
1279 if (ty) {
1280 tc = SWIG_TypeCheck(c,ty);
1281 if (!tc) goto type_error;
1282 }
1283 return 0;
1284
1285 type_error:
1286 PyErr_Clear();
1287 if (flags & SWIG_POINTER_EXCEPTION) {
1288 if (ty) {
1289 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1290 } else {
1291 SWIG_Python_TypeError("C/C++ packed data", obj);
1292 }
1293 }
1294 return -1;
1295 }
1296
1297 /* Create a new array object */
1298 SWIGRUNTIME PyObject *
1299 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1300 PyObject *robj = 0;
1301 if (!type) {
1302 if (!PyErr_Occurred()) {
1303 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1304 }
1305 return robj;
1306 }
1307 if (!ptr) {
1308 Py_INCREF(Py_None);
1309 return Py_None;
1310 }
1311 #ifdef SWIG_COBJECT_TYPES
1312 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1313 #else
1314 {
1315 char result[SWIG_BUFFER_SIZE];
1316 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1317 PyString_FromString(result) : 0;
1318 }
1319 #endif
1320 if (!robj || (robj == Py_None)) return robj;
1321 if (type->clientdata) {
1322 PyObject *inst;
1323 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1324 Py_DECREF(robj);
1325 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1326 Py_DECREF(args);
1327 if (inst) {
1328 if (own) {
1329 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1330 }
1331 robj = inst;
1332 }
1333 }
1334 return robj;
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1339 PyObject *robj = 0;
1340 if (!ptr) {
1341 Py_INCREF(Py_None);
1342 return Py_None;
1343 }
1344 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1345 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1346 #else
1347 {
1348 char result[SWIG_BUFFER_SIZE];
1349 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1350 PyString_FromString(result) : 0;
1351 }
1352 #endif
1353 return robj;
1354 }
1355
1356 /* -----------------------------------------------------------------------------*
1357 * Get type list
1358 * -----------------------------------------------------------------------------*/
1359
1360 #ifdef SWIG_LINK_RUNTIME
1361 void *SWIG_ReturnGlobalTypeList(void *);
1362 #endif
1363
1364 SWIGRUNTIME swig_module_info *
1365 SWIG_Python_GetModule(void) {
1366 static void *type_pointer = (void *)0;
1367 /* first check if module already created */
1368 if (!type_pointer) {
1369 #ifdef SWIG_LINK_RUNTIME
1370 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1371 #else
1372 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1373 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1374 if (PyErr_Occurred()) {
1375 PyErr_Clear();
1376 type_pointer = (void *)0;
1377 }
1378 #endif
1379 }
1380 return (swig_module_info *) type_pointer;
1381 }
1382
1383 #if PY_MAJOR_VERSION < 2
1384 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1385 is copied out of Python/modsupport.c in python version 2.3.4 */
1386 SWIGINTERN int
1387 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1388 {
1389 PyObject *dict;
1390 if (!PyModule_Check(m)) {
1391 PyErr_SetString(PyExc_TypeError,
1392 "PyModule_AddObject() needs module as first arg");
1393 return -1;
1394 }
1395 if (!o) {
1396 PyErr_SetString(PyExc_TypeError,
1397 "PyModule_AddObject() needs non-NULL value");
1398 return -1;
1399 }
1400
1401 dict = PyModule_GetDict(m);
1402 if (dict == NULL) {
1403 /* Internal error -- modules must have a dict! */
1404 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1405 PyModule_GetName(m));
1406 return -1;
1407 }
1408 if (PyDict_SetItemString(dict, name, o))
1409 return -1;
1410 Py_DECREF(o);
1411 return 0;
1412 }
1413 #endif
1414
1415 SWIGRUNTIME void
1416 SWIG_Python_SetModule(swig_module_info *swig_module) {
1417 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1418
1419 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1420 swig_empty_runtime_method_table);
1421 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1422 if (pointer && module) {
1423 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1424 }
1425 }
1426
1427 #ifdef __cplusplus
1428 }
1429 #endif
1430
1431
1432 /* -------- TYPES TABLE (BEGIN) -------- */
1433
1434 #define SWIGTYPE_p_buffer swig_types[0]
1435 #define SWIGTYPE_p_char swig_types[1]
1436 #define SWIGTYPE_p_form_ops_t swig_types[2]
1437 #define SWIGTYPE_p_int swig_types[3]
1438 #define SWIGTYPE_p_long swig_types[4]
1439 #define SWIGTYPE_p_unsigned_char swig_types[5]
1440 #define SWIGTYPE_p_unsigned_int swig_types[6]
1441 #define SWIGTYPE_p_unsigned_long swig_types[7]
1442 #define SWIGTYPE_p_wxANIHandler swig_types[8]
1443 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
1444 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
1445 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
1446 #define SWIGTYPE_p_wxAppTraits swig_types[12]
1447 #define SWIGTYPE_p_wxArrayString swig_types[13]
1448 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
1449 #define SWIGTYPE_p_wxBitmap swig_types[15]
1450 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
1451 #define SWIGTYPE_p_wxButton swig_types[17]
1452 #define SWIGTYPE_p_wxCURHandler swig_types[18]
1453 #define SWIGTYPE_p_wxCaret swig_types[19]
1454 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
1456 #define SWIGTYPE_p_wxColour swig_types[22]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
1458 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
1459 #define SWIGTYPE_p_wxControl swig_types[25]
1460 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
1461 #define SWIGTYPE_p_wxCursor swig_types[27]
1462 #define SWIGTYPE_p_wxDC swig_types[28]
1463 #define SWIGTYPE_p_wxDateEvent swig_types[29]
1464 #define SWIGTYPE_p_wxDateTime swig_types[30]
1465 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
1466 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
1467 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
1468 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
1469 #define SWIGTYPE_p_wxEvent swig_types[35]
1470 #define SWIGTYPE_p_wxEventLoop swig_types[36]
1471 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
1472 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
1473 #define SWIGTYPE_p_wxFSFile swig_types[39]
1474 #define SWIGTYPE_p_wxFileSystem swig_types[40]
1475 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
1476 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
1477 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
1478 #define SWIGTYPE_p_wxFont swig_types[44]
1479 #define SWIGTYPE_p_wxFrame swig_types[45]
1480 #define SWIGTYPE_p_wxGBPosition swig_types[46]
1481 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
1482 #define SWIGTYPE_p_wxGBSpan swig_types[48]
1483 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
1484 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
1485 #define SWIGTYPE_p_wxGridSizer swig_types[51]
1486 #define SWIGTYPE_p_wxICOHandler swig_types[52]
1487 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
1488 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
1489 #define SWIGTYPE_p_wxImage swig_types[55]
1490 #define SWIGTYPE_p_wxImageHandler swig_types[56]
1491 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
1492 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
1493 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
1494 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
1495 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
1496 #define SWIGTYPE_p_wxInputStream swig_types[62]
1497 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
1498 #define SWIGTYPE_p_wxItemContainer swig_types[64]
1499 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1500 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
1501 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
1502 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
1503 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1504 #define SWIGTYPE_p_wxMenu swig_types[70]
1505 #define SWIGTYPE_p_wxMenuBar swig_types[71]
1506 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
1507 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
1508 #define SWIGTYPE_p_wxMenuItem swig_types[74]
1509 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
1510 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
1511 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
1512 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
1513 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
1514 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
1515 #define SWIGTYPE_p_wxObject swig_types[81]
1516 #define SWIGTYPE_p_wxOutputStream swig_types[82]
1517 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
1518 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
1519 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
1520 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
1521 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
1522 #define SWIGTYPE_p_wxPaperSize swig_types[88]
1523 #define SWIGTYPE_p_wxPoint swig_types[89]
1524 #define SWIGTYPE_p_wxPoint2D swig_types[90]
1525 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
1526 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
1527 #define SWIGTYPE_p_wxPyApp swig_types[93]
1528 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
1529 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
1530 #define SWIGTYPE_p_wxPyEvent swig_types[96]
1531 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
1532 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
1533 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
1534 #define SWIGTYPE_p_wxPySizer swig_types[100]
1535 #define SWIGTYPE_p_wxPyValidator swig_types[101]
1536 #define SWIGTYPE_p_wxQuantize swig_types[102]
1537 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
1538 #define SWIGTYPE_p_wxRealPoint swig_types[104]
1539 #define SWIGTYPE_p_wxRect swig_types[105]
1540 #define SWIGTYPE_p_wxRegion swig_types[106]
1541 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
1542 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
1543 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
1544 #define SWIGTYPE_p_wxShowEvent swig_types[110]
1545 #define SWIGTYPE_p_wxSize swig_types[111]
1546 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
1547 #define SWIGTYPE_p_wxSizer swig_types[113]
1548 #define SWIGTYPE_p_wxSizerItem swig_types[114]
1549 #define SWIGTYPE_p_wxStaticBox swig_types[115]
1550 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
1551 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
1552 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
1553 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
1554 #define SWIGTYPE_p_wxToolTip swig_types[120]
1555 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
1556 #define SWIGTYPE_p_wxValidator swig_types[122]
1557 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
1558 #define SWIGTYPE_p_wxWindow swig_types[124]
1559 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
1560 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
1561 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
1562 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
1563 #define SWIGTYPE_ptrdiff_t swig_types[129]
1564 #define SWIGTYPE_std__ptrdiff_t swig_types[130]
1565 #define SWIGTYPE_unsigned_int swig_types[131]
1566 static swig_type_info *swig_types[133];
1567 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
1568 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1569 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1570
1571 /* -------- TYPES TABLE (END) -------- */
1572
1573
1574 /*-----------------------------------------------
1575 @(target):= _core_.so
1576 ------------------------------------------------*/
1577 #define SWIG_init init_core_
1578
1579 #define SWIG_name "_core_"
1580
1581 #include "wx/wxPython/wxPython_int.h"
1582 #include "wx/wxPython/pyclasses.h"
1583
1584
1585 #ifndef wxPyUSE_EXPORT
1586 // Helper functions for dealing with SWIG objects and such. These are
1587 // located here so they know about the SWIG types and functions declared
1588 // in the wrapper code.
1589
1590 #include <wx/hashmap.h>
1591 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1592
1593
1594 // Maintains a hashmap of className to swig_type_info pointers. Given the
1595 // name of a class either looks up the type info in the cache, or scans the
1596 // SWIG tables for it.
1597 extern PyObject* wxPyPtrTypeMap;
1598 static
1599 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1600
1601 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1602
1603 if (typeInfoCache == NULL)
1604 typeInfoCache = new wxPyTypeInfoHashMap;
1605
1606 wxString name(className);
1607 swig_type_info* swigType = (*typeInfoCache)[name];
1608
1609 if (! swigType) {
1610 // it wasn't in the cache, so look it up from SWIG
1611 name.Append(wxT(" *"));
1612 swigType = SWIG_TypeQuery(name.mb_str());
1613
1614 // if it still wasn't found, try looking for a mapped name
1615 if (!swigType) {
1616 PyObject* item;
1617 name = className;
1618
1619 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1620 (char*)(const char*)name.mbc_str())) != NULL) {
1621 name = wxString(PyString_AsString(item), *wxConvCurrent);
1622 name.Append(wxT(" *"));
1623 swigType = SWIG_TypeQuery(name.mb_str());
1624 }
1625 }
1626 if (swigType) {
1627 // and add it to the map if found
1628 (*typeInfoCache)[className] = swigType;
1629 }
1630 }
1631 return swigType;
1632 }
1633
1634
1635 // Check if a class name is a type known to SWIG
1636 bool wxPyCheckSwigType(const wxChar* className) {
1637
1638 swig_type_info* swigType = wxPyFindSwigType(className);
1639 return swigType != NULL;
1640 }
1641
1642
1643 // Given a pointer to a C++ object and a class name, construct a Python proxy
1644 // object for it.
1645 PyObject* wxPyConstructObject(void* ptr,
1646 const wxChar* className,
1647 int setThisOwn) {
1648
1649 swig_type_info* swigType = wxPyFindSwigType(className);
1650 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1651
1652 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1653 }
1654
1655
1656 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1657 // Ensures that the proxy object is of the specified (or derived) type. If
1658 // not able to perform the conversion then a Python exception is set and the
1659 // error should be handled properly in the caller. Returns True on success.
1660 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1661 const wxChar* className) {
1662
1663 swig_type_info* swigType = wxPyFindSwigType(className);
1664 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1665
1666 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1667 }
1668
1669
1670
1671 // Make a SWIGified pointer object suitable for a .this attribute
1672 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1673
1674 PyObject* robj = NULL;
1675
1676 swig_type_info* swigType = wxPyFindSwigType(className);
1677 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
1678
1679 #ifdef SWIG_COBJECT_TYPES
1680 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1681 #else
1682 {
1683 char result[1024];
1684 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1685 PyString_FromString(result) : 0;
1686 }
1687 #endif
1688 return robj;
1689 }
1690
1691
1692 // Python's PyInstance_Check does not return True for instances of new-style
1693 // classes. This should get close enough for both new and old classes but I
1694 // should re-evaluate the need for doing instance checks...
1695 bool wxPyInstance_Check(PyObject* obj) {
1696 return PyObject_HasAttrString(obj, "__class__") != 0;
1697 }
1698
1699
1700 // This one checks if the object is an instance of a SWIG proxy class (it has
1701 // a .this attribute, and the .this attribute is a PySwigObject.)
1702 bool wxPySwigInstance_Check(PyObject* obj) {
1703 static PyObject* this_str = NULL;
1704 if (this_str == NULL)
1705 this_str = PyString_FromString("this");
1706
1707 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1708 if (this_attr) {
1709 bool retval = (PySwigObject_Check(this_attr) != 0);
1710 Py_DECREF(this_attr);
1711 return retval;
1712 }
1713
1714 PyErr_Clear();
1715 return false;
1716 }
1717
1718
1719 // Export a C API in a struct. Other modules will be able to load this from
1720 // the wx._core_ module and will then have safe access to these functions,
1721 // even if they are located in another shared library.
1722 static wxPyCoreAPI API = {
1723
1724 wxPyCheckSwigType,
1725 wxPyConstructObject,
1726 wxPyConvertSwigPtr,
1727 wxPyMakeSwigPtr,
1728
1729 wxPyBeginAllowThreads,
1730 wxPyEndAllowThreads,
1731 wxPyBeginBlockThreads,
1732 wxPyEndBlockThreads,
1733
1734 wxPy_ConvertList,
1735
1736 wxString_in_helper,
1737 Py2wxString,
1738 wx2PyString,
1739
1740 byte_LIST_helper,
1741 int_LIST_helper,
1742 long_LIST_helper,
1743 string_LIST_helper,
1744 wxPoint_LIST_helper,
1745 wxBitmap_LIST_helper,
1746 wxString_LIST_helper,
1747 wxAcceleratorEntry_LIST_helper,
1748
1749 wxSize_helper,
1750 wxPoint_helper,
1751 wxRealPoint_helper,
1752 wxRect_helper,
1753 wxColour_helper,
1754 wxPoint2D_helper,
1755
1756 wxPySimple_typecheck,
1757 wxColour_typecheck,
1758
1759 wxPyCBH_setCallbackInfo,
1760 wxPyCBH_findCallback,
1761 wxPyCBH_callCallback,
1762 wxPyCBH_callCallbackObj,
1763 wxPyCBH_delete,
1764
1765 wxPyMake_wxObject,
1766 wxPyMake_wxSizer,
1767 wxPyPtrTypeMap_Add,
1768 wxPy2int_seq_helper,
1769 wxPy4int_seq_helper,
1770 wxArrayString2PyList_helper,
1771 wxArrayInt2PyList_helper,
1772
1773 wxPyClientData_dtor,
1774 wxPyUserData_dtor,
1775 wxPyOORClientData_dtor,
1776
1777 wxPyCBInputStream_create,
1778 wxPyCBInputStream_copy,
1779
1780 wxPyInstance_Check,
1781 wxPySwigInstance_Check,
1782
1783 wxPyCheckForApp
1784
1785 };
1786
1787 #endif
1788
1789
1790 #if !WXWIN_COMPATIBILITY_2_4
1791 #define wxHIDE_READONLY 0
1792 #endif
1793
1794
1795 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1796 #define SWIG_From_int PyInt_FromLong
1797 /*@@*/
1798
1799 static const wxString wxPyEmptyString(wxEmptyString);
1800 static wxString wxObject_GetClassName(wxObject *self){
1801 return self->GetClassInfo()->GetClassName();
1802 }
1803 static void wxObject_Destroy(wxObject *self){
1804 delete self;
1805 }
1806
1807 #ifndef __WXMAC__
1808 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1809 #endif
1810
1811
1812 #include <limits.h>
1813
1814
1815 SWIGINTERN int
1816 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1817 const char *errmsg)
1818 {
1819 if (value < min_value) {
1820 if (errmsg) {
1821 PyErr_Format(PyExc_OverflowError,
1822 "value %ld is less than '%s' minimum %ld",
1823 value, errmsg, min_value);
1824 }
1825 return 0;
1826 } else if (value > max_value) {
1827 if (errmsg) {
1828 PyErr_Format(PyExc_OverflowError,
1829 "value %ld is greater than '%s' maximum %ld",
1830 value, errmsg, max_value);
1831 }
1832 return 0;
1833 }
1834 return 1;
1835 }
1836
1837
1838 SWIGINTERN int
1839 SWIG_AsVal_long(PyObject* obj, long* val)
1840 {
1841 if (PyNumber_Check(obj)) {
1842 if (val) *val = PyInt_AsLong(obj);
1843 return 1;
1844 }
1845 else {
1846 SWIG_Python_TypeError("number", obj);
1847 }
1848 return 0;
1849 }
1850
1851
1852 #if INT_MAX != LONG_MAX
1853 SWIGINTERN int
1854 SWIG_AsVal_int(PyObject *obj, int *val)
1855 {
1856 const char* errmsg = val ? "int" : (char*)0;
1857 long v;
1858 if (SWIG_AsVal_long(obj, &v)) {
1859 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1860 if (val) *val = static_cast<int >(v);
1861 return 1;
1862 } else {
1863 return 0;
1864 }
1865 } else {
1866 PyErr_Clear();
1867 }
1868 if (val) {
1869 SWIG_type_error(errmsg, obj);
1870 }
1871 return 0;
1872 }
1873 #else
1874 SWIGINTERNINLINE int
1875 SWIG_AsVal_int(PyObject *obj, int *val)
1876 {
1877 return SWIG_AsVal_long(obj,(long*)val);
1878 }
1879 #endif
1880
1881
1882 SWIGINTERNINLINE int
1883 SWIG_As_int(PyObject* obj)
1884 {
1885 int v;
1886 if (!SWIG_AsVal_int(obj, &v)) {
1887 /*
1888 this is needed to make valgrind/purify happier.
1889 */
1890 memset((void*)&v, 0, sizeof(int));
1891 }
1892 return v;
1893 }
1894
1895
1896 SWIGINTERNINLINE int
1897 SWIG_Check_int(PyObject* obj)
1898 {
1899 return SWIG_AsVal_int(obj, (int*)0);
1900 }
1901
1902 static PyObject *wxSize_Get(wxSize *self){
1903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1904 PyObject* tup = PyTuple_New(2);
1905 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1906 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1907 wxPyEndBlockThreads(blocked);
1908 return tup;
1909 }
1910
1911 SWIGINTERN int
1912 SWIG_AsVal_double(PyObject *obj, double* val)
1913 {
1914 if (PyNumber_Check(obj)) {
1915 if (val) *val = PyFloat_AsDouble(obj);
1916 return 1;
1917 }
1918 else {
1919 SWIG_Python_TypeError("number", obj);
1920 }
1921 return 0;
1922 }
1923
1924
1925 SWIGINTERNINLINE double
1926 SWIG_As_double(PyObject* obj)
1927 {
1928 double v;
1929 if (!SWIG_AsVal_double(obj, &v)) {
1930 /*
1931 this is needed to make valgrind/purify happier.
1932 */
1933 memset((void*)&v, 0, sizeof(double));
1934 }
1935 return v;
1936 }
1937
1938
1939 SWIGINTERNINLINE int
1940 SWIG_Check_double(PyObject* obj)
1941 {
1942 return SWIG_AsVal_double(obj, (double*)0);
1943 }
1944
1945
1946 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1947 #define SWIG_From_double PyFloat_FromDouble
1948 /*@@*/
1949
1950 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1951 self->x = x;
1952 self->y = y;
1953 }
1954 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1955 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1956 PyObject* tup = PyTuple_New(2);
1957 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1958 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1959 wxPyEndBlockThreads(blocked);
1960 return tup;
1961 }
1962
1963 SWIGINTERNINLINE long
1964 SWIG_As_long(PyObject* obj)
1965 {
1966 long v;
1967 if (!SWIG_AsVal_long(obj, &v)) {
1968 /*
1969 this is needed to make valgrind/purify happier.
1970 */
1971 memset((void*)&v, 0, sizeof(long));
1972 }
1973 return v;
1974 }
1975
1976
1977 SWIGINTERNINLINE int
1978 SWIG_Check_long(PyObject* obj)
1979 {
1980 return SWIG_AsVal_long(obj, (long*)0);
1981 }
1982
1983 static void wxPoint_Set(wxPoint *self,long x,long y){
1984 self->x = x;
1985 self->y = y;
1986 }
1987 static PyObject *wxPoint_Get(wxPoint *self){
1988 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1989 PyObject* tup = PyTuple_New(2);
1990 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1991 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1992 wxPyEndBlockThreads(blocked);
1993 return tup;
1994 }
1995 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1996 self->x = x;
1997 self->y = y;
1998 self->width = width;
1999 self->height = height;
2000 }
2001 static PyObject *wxRect_Get(wxRect *self){
2002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2003 PyObject* tup = PyTuple_New(4);
2004 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2005 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2006 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2007 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2008 wxPyEndBlockThreads(blocked);
2009 return tup;
2010 }
2011
2012 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2013 wxRegion reg1(*r1);
2014 wxRegion reg2(*r2);
2015 wxRect dest(0,0,0,0);
2016 PyObject* obj;
2017
2018 reg1.Intersect(reg2);
2019 dest = reg1.GetBox();
2020
2021 if (dest != wxRect(0,0,0,0)) {
2022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2023 wxRect* newRect = new wxRect(dest);
2024 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2025 wxPyEndBlockThreads(blocked);
2026 return obj;
2027 }
2028 Py_INCREF(Py_None);
2029 return Py_None;
2030 }
2031
2032
2033 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
2034 {
2035 PyObject* o2;
2036 PyObject* o3;
2037 if (!result) {
2038 result = obj;
2039 } else if (result == Py_None) {
2040 Py_DECREF(result);
2041 result = obj;
2042 } else {
2043 if (!PyTuple_Check(result)) {
2044 o2 = result;
2045 result = PyTuple_New(1);
2046 PyTuple_SET_ITEM(result, 0, o2);
2047 }
2048 o3 = PyTuple_New(1);
2049 PyTuple_SetItem(o3, 0, obj);
2050 o2 = result;
2051 result = PySequence_Concat(o2, o3);
2052 Py_DECREF(o2);
2053 Py_DECREF(o3);
2054 }
2055 return result;
2056 }
2057
2058
2059 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2060 self->m_x = x;
2061 self->m_y = y;
2062 }
2063 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2065 PyObject* tup = PyTuple_New(2);
2066 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2067 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2068 wxPyEndBlockThreads(blocked);
2069 return tup;
2070 }
2071
2072 #include "wx/wxPython/pyistream.h"
2073
2074 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2075 wxInputStream* wxis = wxPyCBInputStream::create(p);
2076 if (wxis)
2077 return new wxPyInputStream(wxis);
2078 else
2079 return NULL;
2080 }
2081
2082 SWIGINTERNINLINE PyObject*
2083 SWIG_From_char(char c)
2084 {
2085 return PyString_FromStringAndSize(&c,1);
2086 }
2087
2088
2089 SWIGINTERNINLINE PyObject*
2090 SWIG_From_unsigned_SS_long(unsigned long value)
2091 {
2092 return (value > LONG_MAX) ?
2093 PyLong_FromUnsignedLong(value)
2094 : PyInt_FromLong(static_cast<long >(value));
2095 }
2096
2097
2098 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2099 SWIGINTERN int
2100 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2101 {
2102 static swig_type_info* pchar_info = 0;
2103 char* vptr = 0;
2104 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2105 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2106 if (cptr) *cptr = vptr;
2107 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2108 return SWIG_OLDOBJ;
2109 } else {
2110 PyErr_Clear();
2111 if (PyString_Check(obj)) {
2112 if (cptr) {
2113 *cptr = PyString_AS_STRING(obj);
2114 if (psize) {
2115 *psize = PyString_GET_SIZE(obj) + 1;
2116 }
2117 }
2118 return SWIG_PYSTR;
2119 }
2120 }
2121 if (cptr) {
2122 SWIG_type_error("char *", obj);
2123 }
2124 return 0;
2125 }
2126
2127
2128 SWIGINTERN int
2129 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2130 {
2131 char* cptr; size_t csize;
2132 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2133 /* in C you can do:
2134
2135 char x[5] = "hello";
2136
2137 ie, assing the array using an extra '0' char.
2138 */
2139 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2140 if (csize <= size) {
2141 if (val) {
2142 if (csize) memcpy(val, cptr, csize);
2143 if (csize < size) memset(val + csize, 0, size - csize);
2144 }
2145 return 1;
2146 }
2147 }
2148 if (val) {
2149 PyErr_Format(PyExc_TypeError,
2150 "a char array of maximum size %lu is expected",
2151 (unsigned long) size);
2152 }
2153 return 0;
2154 }
2155
2156
2157 SWIGINTERN int
2158 SWIG_AsVal_char(PyObject *obj, char *val)
2159 {
2160 const char* errmsg = val ? "char" : (char*)0;
2161 long v;
2162 if (SWIG_AsVal_long(obj, &v)) {
2163 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2164 if (val) *val = static_cast<char >(v);
2165 return 1;
2166 } else {
2167 return 0;
2168 }
2169 } else {
2170 PyErr_Clear();
2171 return SWIG_AsCharArray(obj, val, 1);
2172 }
2173 }
2174
2175
2176 SWIGINTERNINLINE char
2177 SWIG_As_char(PyObject* obj)
2178 {
2179 char v;
2180 if (!SWIG_AsVal_char(obj, &v)) {
2181 /*
2182 this is needed to make valgrind/purify happier.
2183 */
2184 memset((void*)&v, 0, sizeof(char));
2185 }
2186 return v;
2187 }
2188
2189
2190 SWIGINTERNINLINE int
2191 SWIG_Check_char(PyObject* obj)
2192 {
2193 return SWIG_AsVal_char(obj, (char*)0);
2194 }
2195
2196
2197 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2198 #define SWIG_From_long PyInt_FromLong
2199 /*@@*/
2200
2201 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2202 // We use only strings for the streams, not unicode
2203 PyObject* str = PyObject_Str(obj);
2204 if (! str) {
2205 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2206 return;
2207 }
2208 self->Write(PyString_AS_STRING(str),
2209 PyString_GET_SIZE(str));
2210 Py_DECREF(str);
2211 }
2212
2213 #include "wx/wxPython/pyistream.h"
2214
2215
2216 class wxPyFileSystemHandler : public wxFileSystemHandler
2217 {
2218 public:
2219 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2220
2221 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2222 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2223 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2224 DEC_PYCALLBACK_STRING__pure(FindNext);
2225
2226 wxString GetProtocol(const wxString& location) {
2227 return wxFileSystemHandler::GetProtocol(location);
2228 }
2229
2230 wxString GetLeftLocation(const wxString& location) {
2231 return wxFileSystemHandler::GetLeftLocation(location);
2232 }
2233
2234 wxString GetAnchor(const wxString& location) {
2235 return wxFileSystemHandler::GetAnchor(location);
2236 }
2237
2238 wxString GetRightLocation(const wxString& location) {
2239 return wxFileSystemHandler::GetRightLocation(location);
2240 }
2241
2242 wxString GetMimeTypeFromExt(const wxString& location) {
2243 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2244 }
2245
2246 PYPRIVATE;
2247 };
2248
2249
2250 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2251 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2252 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2253 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_bool(PyObject *obj, bool *val)
2258 {
2259 if (obj == Py_True) {
2260 if (val) *val = true;
2261 return 1;
2262 }
2263 if (obj == Py_False) {
2264 if (val) *val = false;
2265 return 1;
2266 }
2267 int res = 0;
2268 if (SWIG_AsVal_int(obj, &res)) {
2269 if (val) *val = res ? true : false;
2270 return 1;
2271 } else {
2272 PyErr_Clear();
2273 }
2274 if (val) {
2275 SWIG_type_error("bool", obj);
2276 }
2277 return 0;
2278 }
2279
2280
2281 SWIGINTERNINLINE bool
2282 SWIG_As_bool(PyObject* obj)
2283 {
2284 bool v;
2285 if (!SWIG_AsVal_bool(obj, &v)) {
2286 /*
2287 this is needed to make valgrind/purify happier.
2288 */
2289 memset((void*)&v, 0, sizeof(bool));
2290 }
2291 return v;
2292 }
2293
2294
2295 SWIGINTERNINLINE int
2296 SWIG_Check_bool(PyObject* obj)
2297 {
2298 return SWIG_AsVal_bool(obj, (bool*)0);
2299 }
2300
2301 static wxString wxFileSystem_URLToFileName(wxString const &url){
2302 wxFileName fname = wxFileSystem::URLToFileName(url);
2303 return fname.GetFullPath();
2304 }
2305
2306 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2307 wxImage& image,
2308 long type) {
2309 wxMemoryFSHandler::AddFile(filename, image, type);
2310 }
2311
2312 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2313 const wxBitmap& bitmap,
2314 long type) {
2315 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2316 }
2317
2318 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2319 PyObject* data) {
2320 if (! PyString_Check(data)) {
2321 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2322 "Expected string object"));
2323 return;
2324 }
2325
2326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2327 void* ptr = (void*)PyString_AsString(data);
2328 size_t size = PyString_Size(data);
2329 wxPyEndBlockThreads(blocked);
2330
2331 wxMemoryFSHandler::AddFile(filename, ptr, size);
2332 }
2333
2334
2335 #include "wx/wxPython/pyistream.h"
2336
2337
2338 SWIGINTERN int
2339 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2340 {
2341 long v = 0;
2342 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2343 SWIG_Python_TypeError("unsigned number", obj);
2344 }
2345 else if (val)
2346 *val = (unsigned long)v;
2347 return 1;
2348 }
2349
2350
2351 SWIGINTERNINLINE int
2352 SWIG_CheckUnsignedLongInRange(unsigned long value,
2353 unsigned long max_value,
2354 const char *errmsg)
2355 {
2356 if (value > max_value) {
2357 if (errmsg) {
2358 PyErr_Format(PyExc_OverflowError,
2359 "value %lu is greater than '%s' minimum %lu",
2360 value, errmsg, max_value);
2361 }
2362 return 0;
2363 }
2364 return 1;
2365 }
2366
2367
2368 SWIGINTERN int
2369 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2370 {
2371 const char* errmsg = val ? "unsigned char" : (char*)0;
2372 unsigned long v;
2373 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2374 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2375 if (val) *val = static_cast<unsigned char >(v);
2376 return 1;
2377 } else {
2378 return 0;
2379 }
2380 } else {
2381 PyErr_Clear();
2382 }
2383 if (val) {
2384 SWIG_type_error(errmsg, obj);
2385 }
2386 return 0;
2387 }
2388
2389
2390 SWIGINTERNINLINE unsigned char
2391 SWIG_As_unsigned_SS_char(PyObject* obj)
2392 {
2393 unsigned char v;
2394 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2395 /*
2396 this is needed to make valgrind/purify happier.
2397 */
2398 memset((void*)&v, 0, sizeof(unsigned char));
2399 }
2400 return v;
2401 }
2402
2403
2404 SWIGINTERNINLINE int
2405 SWIG_Check_unsigned_SS_char(PyObject* obj)
2406 {
2407 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2408 }
2409
2410
2411 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2412 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2413 /*@@*/
2414
2415
2416
2417 SWIGINTERNINLINE unsigned long
2418 SWIG_As_unsigned_SS_long(PyObject* obj)
2419 {
2420 unsigned long v;
2421 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2422 /*
2423 this is needed to make valgrind/purify happier.
2424 */
2425 memset((void*)&v, 0, sizeof(unsigned long));
2426 }
2427 return v;
2428 }
2429
2430
2431 SWIGINTERNINLINE int
2432 SWIG_Check_unsigned_SS_long(PyObject* obj)
2433 {
2434 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2435 }
2436
2437 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2438 wxImageHistogramEntry e = (*self)[key];
2439 return e.value;
2440 }
2441 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2442 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2443 wxImageHistogramEntry e = (*self)[key];
2444 return e.value;
2445 }
2446 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2447 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2448 colour.Green(),
2449 colour.Blue());
2450 wxImageHistogramEntry e = (*self)[key];
2451 return e.value;
2452 }
2453
2454 typedef unsigned char* buffer;
2455
2456
2457 // Pull the nested class out to the top level for SWIG's sake
2458 #define wxImage_RGBValue wxImage::RGBValue
2459 #define wxImage_HSVValue wxImage::HSVValue
2460
2461 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2462 if (width > 0 && height > 0)
2463 return new wxImage(width, height, clear);
2464 else
2465 return new wxImage;
2466 }
2467 static wxImage *new_wxImage(wxBitmap const &bitmap){
2468 return new wxImage(bitmap.ConvertToImage());
2469 }
2470 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2471 if (DATASIZE != width*height*3) {
2472 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2473 return NULL;
2474 }
2475
2476 // Copy the source data so the wxImage can clean it up later
2477 buffer copy = (buffer)malloc(DATASIZE);
2478 if (copy == NULL) {
2479 wxPyBLOCK_THREADS(PyErr_NoMemory());
2480 return NULL;
2481 }
2482 memcpy(copy, data, DATASIZE);
2483 return new wxImage(width, height, copy, false);
2484 }
2485 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2486 if (DATASIZE != width*height*3) {
2487 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2488 return NULL;
2489 }
2490 if (ALPHASIZE != width*height) {
2491 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2492 return NULL;
2493 }
2494
2495 // Copy the source data so the wxImage can clean it up later
2496 buffer dcopy = (buffer)malloc(DATASIZE);
2497 if (dcopy == NULL) {
2498 wxPyBLOCK_THREADS(PyErr_NoMemory());
2499 return NULL;
2500 }
2501 memcpy(dcopy, data, DATASIZE);
2502
2503 buffer acopy = (buffer)malloc(ALPHASIZE);
2504 if (acopy == NULL) {
2505 wxPyBLOCK_THREADS(PyErr_NoMemory());
2506 return NULL;
2507 }
2508 memcpy(acopy, alpha, ALPHASIZE);
2509
2510 return new wxImage(width, height, dcopy, acopy, false);
2511 }
2512 static wxSize wxImage_GetSize(wxImage *self){
2513 wxSize size(self->GetWidth(), self->GetHeight());
2514 return size;
2515 }
2516 static PyObject *wxImage_GetData(wxImage *self){
2517 buffer data = self->GetData();
2518 int len = self->GetWidth() * self->GetHeight() * 3;
2519 PyObject* rv;
2520 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2521 return rv;
2522 }
2523 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2524 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2525 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2526 return;
2527 }
2528 buffer copy = (buffer)malloc(DATASIZE);
2529 if (copy == NULL) {
2530 wxPyBLOCK_THREADS(PyErr_NoMemory());
2531 return;
2532 }
2533 memcpy(copy, data, DATASIZE);
2534 self->SetData(copy, false);
2535 // wxImage takes ownership of copy...
2536 }
2537 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2538 buffer data = self->GetData();
2539 int len = self->GetWidth() * self->GetHeight() * 3;
2540 PyObject* rv;
2541 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2542 return rv;
2543 }
2544 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2545 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2546 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2547 return;
2548 }
2549 self->SetData(data, true);
2550 }
2551 static PyObject *wxImage_GetAlphaData(wxImage *self){
2552 buffer data = self->GetAlpha();
2553 if (! data) {
2554 RETURN_NONE();
2555 } else {
2556 int len = self->GetWidth() * self->GetHeight();
2557 PyObject* rv;
2558 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2559 return rv;
2560 }
2561 }
2562 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2563 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2564 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2565 return;
2566 }
2567 buffer acopy = (buffer)malloc(ALPHASIZE);
2568 if (acopy == NULL) {
2569 wxPyBLOCK_THREADS(PyErr_NoMemory());
2570 return;
2571 }
2572 memcpy(acopy, alpha, ALPHASIZE);
2573 self->SetAlpha(acopy, false);
2574 // wxImage takes ownership of acopy...
2575 }
2576 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2577 buffer data = self->GetAlpha();
2578 int len = self->GetWidth() * self->GetHeight();
2579 PyObject* rv;
2580 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2581 return rv;
2582 }
2583 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2584 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2585 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2586 return;
2587 }
2588 self->SetAlpha(alpha, true);
2589 }
2590 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2591 wxBitmap bitmap(*self, depth);
2592 return bitmap;
2593 }
2594 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2595 wxImage mono = self->ConvertToMono( red, green, blue );
2596 wxBitmap bitmap( mono, 1 );
2597 return bitmap;
2598 }
2599 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2600 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2601 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2602 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2603 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2604 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2605 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2606 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2607 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2608 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2609 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2610 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2611 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2612 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2613 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2614
2615 #include <wx/quantize.h>
2616
2617 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2618 return wxQuantize::Quantize(src, dest,
2619 //NULL, // palette
2620 desiredNoColours,
2621 NULL, // eightBitData
2622 flags);
2623 }
2624 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2625 if (PyCallable_Check(func)) {
2626 self->Connect(id, lastId, eventType,
2627 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2628 new wxPyCallback(func));
2629 }
2630 else if (func == Py_None) {
2631 self->Disconnect(id, lastId, eventType,
2632 (wxObjectEventFunction)
2633 &wxPyCallback::EventThunker);
2634 }
2635 else {
2636 wxPyBLOCK_THREADS(
2637 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2638 }
2639 }
2640 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2641 return self->Disconnect(id, lastId, eventType,
2642 (wxObjectEventFunction)
2643 &wxPyCallback::EventThunker);
2644 }
2645 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2646 if (_self && _self != Py_None) {
2647 self->SetClientObject(new wxPyOORClientData(_self, incref));
2648 }
2649 else {
2650 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2651 if (data) {
2652 self->SetClientObject(NULL); // This will delete it too
2653 }
2654 }
2655 }
2656
2657 #if ! wxUSE_HOTKEY
2658 #define wxEVT_HOTKEY -9999
2659 #endif
2660
2661
2662 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2663 #if wxUSE_UNICODE
2664 return self->GetUnicodeKey();
2665 #else
2666 return 0;
2667 #endif
2668 }
2669
2670 #if UINT_MAX < LONG_MAX
2671 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2672 #define SWIG_From_unsigned_SS_int SWIG_From_long
2673 /*@@*/
2674 #else
2675 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2676 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2677 /*@@*/
2678 #endif
2679
2680
2681 #if UINT_MAX != ULONG_MAX
2682 SWIGINTERN int
2683 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2684 {
2685 const char* errmsg = val ? "unsigned int" : (char*)0;
2686 unsigned long v;
2687 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2688 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2689 if (val) *val = static_cast<unsigned int >(v);
2690 return 1;
2691 }
2692 } else {
2693 PyErr_Clear();
2694 }
2695 if (val) {
2696 SWIG_type_error(errmsg, obj);
2697 }
2698 return 0;
2699 }
2700 #else
2701 SWIGINTERNINLINE unsigned int
2702 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2703 {
2704 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2705 }
2706 #endif
2707
2708
2709 SWIGINTERNINLINE unsigned int
2710 SWIG_As_unsigned_SS_int(PyObject* obj)
2711 {
2712 unsigned int v;
2713 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2714 /*
2715 this is needed to make valgrind/purify happier.
2716 */
2717 memset((void*)&v, 0, sizeof(unsigned int));
2718 }
2719 return v;
2720 }
2721
2722
2723 SWIGINTERNINLINE int
2724 SWIG_Check_unsigned_SS_int(PyObject* obj)
2725 {
2726 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2727 }
2728
2729 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2730 self->m_size = size;
2731 }
2732 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2733 int count = self->GetNumberOfFiles();
2734 wxString* files = self->GetFiles();
2735 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2736 PyObject* list = PyList_New(count);
2737
2738 if (!list) {
2739 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2740 wxPyEndBlockThreads(blocked);
2741 return NULL;
2742 }
2743
2744 for (int i=0; i<count; i++) {
2745 PyList_SetItem(list, i, wx2PyString(files[i]));
2746 }
2747 wxPyEndBlockThreads(blocked);
2748 return list;
2749 }
2750
2751
2752 static wxPyApp *new_wxPyApp(){
2753 wxPythonApp = new wxPyApp();
2754 return wxPythonApp;
2755 }
2756 static int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2757
2758 void wxApp_CleanUp() {
2759 __wxPyCleanup();
2760 }
2761
2762
2763 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2764
2765
2766 SWIGINTERNINLINE int
2767 SWIG_AsCharPtr(PyObject *obj, char **val)
2768 {
2769 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2770 return 1;
2771 }
2772 if (val) {
2773 PyErr_Clear();
2774 SWIG_type_error("char *", obj);
2775 }
2776 return 0;
2777 }
2778
2779
2780 SWIGINTERN PyObject *
2781 SWIG_FromCharPtr(const char* cptr)
2782 {
2783 if (cptr) {
2784 size_t size = strlen(cptr);
2785 if (size > INT_MAX) {
2786 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2787 SWIG_TypeQuery("char *"), 0);
2788 } else {
2789 if (size != 0) {
2790 return PyString_FromStringAndSize(cptr, size);
2791 } else {
2792 return PyString_FromString(cptr);
2793 }
2794 }
2795 }
2796 Py_INCREF(Py_None);
2797 return Py_None;
2798 }
2799
2800
2801 #if 0 // #ifdef __WXMAC__
2802
2803 // A dummy class that raises an exception if used...
2804 class wxEventLoop
2805 {
2806 public:
2807 wxEventLoop() { wxPyRaiseNotImplemented(); }
2808 int Run() { return 0; }
2809 void Exit(int rc = 0) {}
2810 bool Pending() const { return false; }
2811 bool Dispatch() { return false; }
2812 bool IsRunning() const { return false; }
2813 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2814 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2815 };
2816
2817 #else
2818
2819 #include <wx/evtloop.h>
2820
2821 #endif
2822
2823
2824
2825 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2826 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2827 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2828 static PyObject *wxWindow_GetChildren(wxWindow *self){
2829 wxWindowList& list = self->GetChildren();
2830 return wxPy_ConvertList(&list);
2831 }
2832 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2833 #if wxUSE_HOTKEY
2834 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2835 #else
2836 return false;
2837 #endif
2838 }
2839 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2840
2841
2842
2843 return false;
2844
2845 }
2846 static long wxWindow_GetHandle(wxWindow *self){
2847 return wxPyGetWinHandle(self);
2848 }
2849 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2850 self->AssociateHandle((WXWidget)handle);
2851 }
2852 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2853
2854 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2855 return wxWindow::FindWindowById(id, parent);
2856 }
2857
2858 wxWindow* wxFindWindowByName( const wxString& name,
2859 const wxWindow *parent = NULL ) {
2860 return wxWindow::FindWindowByName(name, parent);
2861 }
2862
2863 wxWindow* wxFindWindowByLabel( const wxString& label,
2864 const wxWindow *parent = NULL ) {
2865 return wxWindow::FindWindowByLabel(label, parent);
2866 }
2867
2868
2869 #ifdef __WXMSW__
2870 #include <wx/msw/private.h> // to get wxGetWindowId
2871 #endif
2872
2873
2874 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2875 #ifdef __WXMSW__
2876 WXHWND hWnd = (WXHWND)_hWnd;
2877 long id = wxGetWindowId(hWnd);
2878 wxWindow* win = new wxWindow;
2879 if (parent)
2880 parent->AddChild(win);
2881 win->SetEventHandler(win);
2882 win->SetHWND(hWnd);
2883 win->SetId(id);
2884 win->SubclassWin(hWnd);
2885 win->AdoptAttributesFromHWND();
2886 win->SetupColours();
2887 return win;
2888 #else
2889 wxPyRaiseNotImplemented();
2890 return NULL;
2891 #endif
2892 }
2893
2894
2895 PyObject* GetTopLevelWindows() {
2896 return wxPy_ConvertList(&wxTopLevelWindows);
2897 }
2898
2899
2900 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2901 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2902 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2903
2904 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2905
2906 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2907 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2908 wxMenuItemList& list = self->GetMenuItems();
2909 return wxPy_ConvertList(&list);
2910 }
2911 static void wxMenuBar_SetAutoWindowMenu(bool enable){}
2912 static bool wxMenuBar_GetAutoWindowMenu(){ return false; }
2913 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2914 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2915 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2916 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2917 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2918 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2919 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
2920 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2921 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2922 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2923 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2924 static int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
2925 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2926 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2927 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2928 static const wxString wxPyControlNameStr(wxControlNameStr);
2929 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2930 if (clientData) {
2931 wxPyClientData* data = new wxPyClientData(clientData);
2932 return self->Append(item, data);
2933 } else
2934 return self->Append(item);
2935 }
2936 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2937 if (clientData) {
2938 wxPyClientData* data = new wxPyClientData(clientData);
2939 return self->Insert(item, pos, data);
2940 } else
2941 return self->Insert(item, pos);
2942 }
2943 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2944 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2945 if (data) {
2946 Py_INCREF(data->m_obj);
2947 return data->m_obj;
2948 } else {
2949 Py_INCREF(Py_None);
2950 return Py_None;
2951 }
2952 }
2953 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2954 wxPyClientData* data = new wxPyClientData(clientData);
2955 self->SetClientObject(n, data);
2956 }
2957
2958
2959 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2960 wxPyUserData* data = NULL;
2961 if ( userData ) {
2962 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2963 data = new wxPyUserData(userData);
2964 wxPyEndBlockThreads(blocked);
2965 }
2966 return new wxSizerItem(window, proportion, flag, border, data);
2967 }
2968 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2969 wxPyUserData* data = NULL;
2970 if ( userData ) {
2971 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2972 data = new wxPyUserData(userData);
2973 wxPyEndBlockThreads(blocked);
2974 }
2975 return new wxSizerItem(width, height, proportion, flag, border, data);
2976 }
2977 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2978 wxPyUserData* data = NULL;
2979 if ( userData ) {
2980 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2981 data = new wxPyUserData(userData);
2982 wxPyEndBlockThreads(blocked);
2983 }
2984 return new wxSizerItem(sizer, proportion, flag, border, data);
2985 }
2986
2987 #include <float.h>
2988 SWIGINTERN int
2989 SWIG_CheckDoubleInRange(double value, double min_value,
2990 double max_value, const char* errmsg)
2991 {
2992 if (value < min_value) {
2993 if (errmsg) {
2994 PyErr_Format(PyExc_OverflowError,
2995 "value %g is less than %s minimum %g",
2996 value, errmsg, min_value);
2997 }
2998 return 0;
2999 } else if (value > max_value) {
3000 if (errmsg) {
3001 PyErr_Format(PyExc_OverflowError,
3002 "value %g is greater than %s maximum %g",
3003 value, errmsg, max_value);
3004 }
3005 return 0;
3006 }
3007 return 1;
3008 }
3009
3010
3011 SWIGINTERN int
3012 SWIG_AsVal_float(PyObject *obj, float *val)
3013 {
3014 const char* errmsg = val ? "float" : (char*)0;
3015 double v;
3016 if (SWIG_AsVal_double(obj, &v)) {
3017 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3018 if (val) *val = static_cast<float >(v);
3019 return 1;
3020 } else {
3021 return 0;
3022 }
3023 } else {
3024 PyErr_Clear();
3025 }
3026 if (val) {
3027 SWIG_type_error(errmsg, obj);
3028 }
3029 return 0;
3030 }
3031
3032
3033 SWIGINTERNINLINE float
3034 SWIG_As_float(PyObject* obj)
3035 {
3036 float v;
3037 if (!SWIG_AsVal_float(obj, &v)) {
3038 /*
3039 this is needed to make valgrind/purify happier.
3040 */
3041 memset((void*)&v, 0, sizeof(float));
3042 }
3043 return v;
3044 }
3045
3046
3047 SWIGINTERNINLINE int
3048 SWIG_Check_float(PyObject* obj)
3049 {
3050 return SWIG_AsVal_float(obj, (float*)0);
3051 }
3052
3053
3054 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
3055 #define SWIG_From_float PyFloat_FromDouble
3056 /*@@*/
3057
3058 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3059 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3060 if (data) {
3061 Py_INCREF(data->m_obj);
3062 return data->m_obj;
3063 } else {
3064 Py_INCREF(Py_None);
3065 return Py_None;
3066 }
3067 }
3068 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3069 wxPyUserData* data = NULL;
3070 if ( userData ) {
3071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3072 data = new wxPyUserData(userData);
3073 wxPyEndBlockThreads(blocked);
3074 }
3075 self->SetUserData(data);
3076 }
3077
3078 // Figure out the type of the sizer item
3079
3080 struct wxPySizerItemInfo {
3081 wxPySizerItemInfo()
3082 : window(NULL), sizer(NULL), gotSize(false),
3083 size(wxDefaultSize), gotPos(false), pos(-1)
3084 {}
3085
3086 wxWindow* window;
3087 wxSizer* sizer;
3088 bool gotSize;
3089 wxSize size;
3090 bool gotPos;
3091 int pos;
3092 };
3093
3094 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3095
3096 wxPySizerItemInfo info;
3097 wxSize size;
3098 wxSize* sizePtr = &size;
3099
3100 // Find out what the type of the item is
3101 // try wxWindow
3102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3103 PyErr_Clear();
3104 info.window = NULL;
3105
3106 // try wxSizer
3107 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3108 PyErr_Clear();
3109 info.sizer = NULL;
3110
3111 // try wxSize or (w,h)
3112 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3113 info.size = *sizePtr;
3114 info.gotSize = true;
3115 }
3116
3117 // or a single int
3118 if (checkIdx && PyInt_Check(item)) {
3119 info.pos = PyInt_AsLong(item);
3120 info.gotPos = true;
3121 }
3122 }
3123 }
3124
3125 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3126 // no expected type, figure out what kind of error message to generate
3127 if ( !checkSize && !checkIdx )
3128 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3129 else if ( checkSize && !checkIdx )
3130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3131 else if ( !checkSize && checkIdx)
3132 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3133 else
3134 // can this one happen?
3135 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3136 }
3137
3138 return info;
3139 }
3140
3141 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3142 if (!self->GetClientObject())
3143 self->SetClientObject(new wxPyOORClientData(_self));
3144 }
3145 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3146
3147 wxPyUserData* data = NULL;
3148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3150 if ( userData && (info.window || info.sizer || info.gotSize) )
3151 data = new wxPyUserData(userData);
3152 if ( info.sizer )
3153 PyObject_SetAttrString(item,"thisown",Py_False);
3154 wxPyEndBlockThreads(blocked);
3155
3156 // Now call the real Add method if a valid item type was found
3157 if ( info.window )
3158 return self->Add(info.window, proportion, flag, border, data);
3159 else if ( info.sizer )
3160 return self->Add(info.sizer, proportion, flag, border, data);
3161 else if (info.gotSize)
3162 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3163 proportion, flag, border, data);
3164 else
3165 return NULL;
3166 }
3167 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3168
3169 wxPyUserData* data = NULL;
3170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3172 if ( userData && (info.window || info.sizer || info.gotSize) )
3173 data = new wxPyUserData(userData);
3174 if ( info.sizer )
3175 PyObject_SetAttrString(item,"thisown",Py_False);
3176 wxPyEndBlockThreads(blocked);
3177
3178 // Now call the real Insert method if a valid item type was found
3179 if ( info.window )
3180 return self->Insert(before, info.window, proportion, flag, border, data);
3181 else if ( info.sizer )
3182 return self->Insert(before, info.sizer, proportion, flag, border, data);
3183 else if (info.gotSize)
3184 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3185 proportion, flag, border, data);
3186 else
3187 return NULL;
3188 }
3189 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3190
3191 wxPyUserData* data = NULL;
3192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3194 if ( userData && (info.window || info.sizer || info.gotSize) )
3195 data = new wxPyUserData(userData);
3196 if ( info.sizer )
3197 PyObject_SetAttrString(item,"thisown",Py_False);
3198 wxPyEndBlockThreads(blocked);
3199
3200 // Now call the real Prepend method if a valid item type was found
3201 if ( info.window )
3202 return self->Prepend(info.window, proportion, flag, border, data);
3203 else if ( info.sizer )
3204 return self->Prepend(info.sizer, proportion, flag, border, data);
3205 else if (info.gotSize)
3206 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3207 proportion, flag, border, data);
3208 else
3209 return NULL;
3210 }
3211 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3214 wxPyEndBlockThreads(blocked);
3215 if ( info.window )
3216 return self->Remove(info.window);
3217 else if ( info.sizer )
3218 return self->Remove(info.sizer);
3219 else if ( info.gotPos )
3220 return self->Remove(info.pos);
3221 else
3222 return false;
3223 }
3224 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3225 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3226 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3227 wxPyEndBlockThreads(blocked);
3228 if ( info.window )
3229 return self->Detach(info.window);
3230 else if ( info.sizer )
3231 return self->Detach(info.sizer);
3232 else if ( info.gotPos )
3233 return self->Detach(info.pos);
3234 else
3235 return false;
3236 }
3237 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3239 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3240 wxPyEndBlockThreads(blocked);
3241 if ( info.window )
3242 return self->GetItem(info.window);
3243 else if ( info.sizer )
3244 return self->GetItem(info.sizer);
3245 else if ( info.gotPos )
3246 return self->GetItem(info.pos);
3247 else
3248 return NULL;
3249 }
3250 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3252 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3253 wxPyEndBlockThreads(blocked);
3254 if ( info.window )
3255 self->SetItemMinSize(info.window, size);
3256 else if ( info.sizer )
3257 self->SetItemMinSize(info.sizer, size);
3258 else if ( info.gotPos )
3259 self->SetItemMinSize(info.pos, size);
3260 }
3261 static PyObject *wxSizer_GetChildren(wxSizer *self){
3262 wxSizerItemList& list = self->GetChildren();
3263 return wxPy_ConvertList(&list);
3264 }
3265 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3267 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3268 wxPyEndBlockThreads(blocked);
3269 if ( info.window )
3270 return self->Show(info.window, show, recursive);
3271 else if ( info.sizer )
3272 return self->Show(info.sizer, show, recursive);
3273 else if ( info.gotPos )
3274 return self->Show(info.pos, show);
3275 else
3276 return false;
3277 }
3278 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3280 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3281 wxPyEndBlockThreads(blocked);
3282 if ( info.window )
3283 return self->IsShown(info.window);
3284 else if ( info.sizer )
3285 return self->IsShown(info.sizer);
3286 else if ( info.gotPos )
3287 return self->IsShown(info.pos);
3288 else
3289 return false;
3290 }
3291
3292 // See pyclasses.h
3293 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3294 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3295 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3296
3297
3298
3299
3300 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3301 {
3302 if (source == Py_None) {
3303 **obj = wxGBPosition(-1,-1);
3304 return true;
3305 }
3306 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3307 }
3308
3309 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3310 {
3311 if (source == Py_None) {
3312 **obj = wxGBSpan(-1,-1);
3313 return true;
3314 }
3315 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3316 }
3317
3318
3319 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3320 self->SetRow(row);
3321 self->SetCol(col);
3322 }
3323 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3325 PyObject* tup = PyTuple_New(2);
3326 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3327 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3328 wxPyEndBlockThreads(blocked);
3329 return tup;
3330 }
3331 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3332 self->SetRowspan(rowspan);
3333 self->SetColspan(colspan);
3334 }
3335 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3337 PyObject* tup = PyTuple_New(2);
3338 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3339 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3340 wxPyEndBlockThreads(blocked);
3341 return tup;
3342 }
3343 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3344 wxPyUserData* data = NULL;
3345 if ( userData ) {
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 data = new wxPyUserData(userData);
3348 wxPyEndBlockThreads(blocked);
3349 }
3350 return new wxGBSizerItem(window, pos, span, flag, border, data);
3351 }
3352 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3353 wxPyUserData* data = NULL;
3354 if ( userData ) {
3355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3356 data = new wxPyUserData(userData);
3357 wxPyEndBlockThreads(blocked);
3358 }
3359 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3360 }
3361 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3362 wxPyUserData* data = NULL;
3363 if ( userData ) {
3364 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3365 data = new wxPyUserData(userData);
3366 wxPyEndBlockThreads(blocked);
3367 }
3368 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3369 }
3370 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3371 int row, col;
3372 self->GetEndPos(row, col);
3373 return wxGBPosition(row, col);
3374 }
3375 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3376
3377 wxPyUserData* data = NULL;
3378 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3379 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3380 if ( userData && (info.window || info.sizer || info.gotSize) )
3381 data = new wxPyUserData(userData);
3382 if ( info.sizer )
3383 PyObject_SetAttrString(item,"thisown",Py_False);
3384 wxPyEndBlockThreads(blocked);
3385
3386 // Now call the real Add method if a valid item type was found
3387 if ( info.window )
3388 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3389 else if ( info.sizer )
3390 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3391 else if (info.gotSize)
3392 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3393 pos, span, flag, border, data);
3394 return NULL;
3395 }
3396
3397
3398 #ifdef __cplusplus
3399 extern "C" {
3400 #endif
3401 static int _wrap_EmptyString_set(PyObject *) {
3402 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3403 return 1;
3404 }
3405
3406
3407 static PyObject *_wrap_EmptyString_get(void) {
3408 PyObject *pyobj = NULL;
3409
3410 {
3411 #if wxUSE_UNICODE
3412 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3413 #else
3414 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3415 #endif
3416 }
3417 return pyobj;
3418 }
3419
3420
3421 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3422 PyObject *resultobj = NULL;
3423 wxObject *arg1 = (wxObject *) 0 ;
3424 wxString result;
3425 PyObject * obj0 = 0 ;
3426 char *kwnames[] = {
3427 (char *) "self", NULL
3428 };
3429
3430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3432 if (SWIG_arg_fail(1)) SWIG_fail;
3433 {
3434 PyThreadState* __tstate = wxPyBeginAllowThreads();
3435 result = wxObject_GetClassName(arg1);
3436
3437 wxPyEndAllowThreads(__tstate);
3438 if (PyErr_Occurred()) SWIG_fail;
3439 }
3440 {
3441 #if wxUSE_UNICODE
3442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3443 #else
3444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3445 #endif
3446 }
3447 return resultobj;
3448 fail:
3449 return NULL;
3450 }
3451
3452
3453 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3454 PyObject *resultobj = NULL;
3455 wxObject *arg1 = (wxObject *) 0 ;
3456 PyObject * obj0 = 0 ;
3457 char *kwnames[] = {
3458 (char *) "self", NULL
3459 };
3460
3461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3463 if (SWIG_arg_fail(1)) SWIG_fail;
3464 {
3465 PyThreadState* __tstate = wxPyBeginAllowThreads();
3466 wxObject_Destroy(arg1);
3467
3468 wxPyEndAllowThreads(__tstate);
3469 if (PyErr_Occurred()) SWIG_fail;
3470 }
3471 Py_INCREF(Py_None); resultobj = Py_None;
3472 return resultobj;
3473 fail:
3474 return NULL;
3475 }
3476
3477
3478 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3479 PyObject *obj;
3480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3481 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3482 Py_INCREF(obj);
3483 return Py_BuildValue((char *)"");
3484 }
3485 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3486 PyObject *resultobj = NULL;
3487 wxSize *arg1 = (wxSize *) 0 ;
3488 int arg2 ;
3489 PyObject * obj0 = 0 ;
3490 PyObject * obj1 = 0 ;
3491 char *kwnames[] = {
3492 (char *) "self",(char *) "x", NULL
3493 };
3494
3495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3497 if (SWIG_arg_fail(1)) SWIG_fail;
3498 {
3499 arg2 = static_cast<int >(SWIG_As_int(obj1));
3500 if (SWIG_arg_fail(2)) SWIG_fail;
3501 }
3502 if (arg1) (arg1)->x = arg2;
3503
3504 Py_INCREF(Py_None); resultobj = Py_None;
3505 return resultobj;
3506 fail:
3507 return NULL;
3508 }
3509
3510
3511 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3512 PyObject *resultobj = NULL;
3513 wxSize *arg1 = (wxSize *) 0 ;
3514 int result;
3515 PyObject * obj0 = 0 ;
3516 char *kwnames[] = {
3517 (char *) "self", NULL
3518 };
3519
3520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3522 if (SWIG_arg_fail(1)) SWIG_fail;
3523 result = (int) ((arg1)->x);
3524
3525 {
3526 resultobj = SWIG_From_int(static_cast<int >(result));
3527 }
3528 return resultobj;
3529 fail:
3530 return NULL;
3531 }
3532
3533
3534 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3535 PyObject *resultobj = NULL;
3536 wxSize *arg1 = (wxSize *) 0 ;
3537 int arg2 ;
3538 PyObject * obj0 = 0 ;
3539 PyObject * obj1 = 0 ;
3540 char *kwnames[] = {
3541 (char *) "self",(char *) "y", NULL
3542 };
3543
3544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3546 if (SWIG_arg_fail(1)) SWIG_fail;
3547 {
3548 arg2 = static_cast<int >(SWIG_As_int(obj1));
3549 if (SWIG_arg_fail(2)) SWIG_fail;
3550 }
3551 if (arg1) (arg1)->y = arg2;
3552
3553 Py_INCREF(Py_None); resultobj = Py_None;
3554 return resultobj;
3555 fail:
3556 return NULL;
3557 }
3558
3559
3560 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3561 PyObject *resultobj = NULL;
3562 wxSize *arg1 = (wxSize *) 0 ;
3563 int result;
3564 PyObject * obj0 = 0 ;
3565 char *kwnames[] = {
3566 (char *) "self", NULL
3567 };
3568
3569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(1)) SWIG_fail;
3572 result = (int) ((arg1)->y);
3573
3574 {
3575 resultobj = SWIG_From_int(static_cast<int >(result));
3576 }
3577 return resultobj;
3578 fail:
3579 return NULL;
3580 }
3581
3582
3583 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3584 PyObject *resultobj = NULL;
3585 int arg1 = (int) 0 ;
3586 int arg2 = (int) 0 ;
3587 wxSize *result;
3588 PyObject * obj0 = 0 ;
3589 PyObject * obj1 = 0 ;
3590 char *kwnames[] = {
3591 (char *) "w",(char *) "h", NULL
3592 };
3593
3594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3595 if (obj0) {
3596 {
3597 arg1 = static_cast<int >(SWIG_As_int(obj0));
3598 if (SWIG_arg_fail(1)) SWIG_fail;
3599 }
3600 }
3601 if (obj1) {
3602 {
3603 arg2 = static_cast<int >(SWIG_As_int(obj1));
3604 if (SWIG_arg_fail(2)) SWIG_fail;
3605 }
3606 }
3607 {
3608 PyThreadState* __tstate = wxPyBeginAllowThreads();
3609 result = (wxSize *)new wxSize(arg1,arg2);
3610
3611 wxPyEndAllowThreads(__tstate);
3612 if (PyErr_Occurred()) SWIG_fail;
3613 }
3614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3615 return resultobj;
3616 fail:
3617 return NULL;
3618 }
3619
3620
3621 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3622 PyObject *resultobj = NULL;
3623 wxSize *arg1 = (wxSize *) 0 ;
3624 PyObject * obj0 = 0 ;
3625 char *kwnames[] = {
3626 (char *) "self", NULL
3627 };
3628
3629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3631 if (SWIG_arg_fail(1)) SWIG_fail;
3632 {
3633 PyThreadState* __tstate = wxPyBeginAllowThreads();
3634 delete arg1;
3635
3636 wxPyEndAllowThreads(__tstate);
3637 if (PyErr_Occurred()) SWIG_fail;
3638 }
3639 Py_INCREF(Py_None); resultobj = Py_None;
3640 return resultobj;
3641 fail:
3642 return NULL;
3643 }
3644
3645
3646 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj = NULL;
3648 wxSize *arg1 = (wxSize *) 0 ;
3649 wxSize *arg2 = 0 ;
3650 bool result;
3651 wxSize temp2 ;
3652 PyObject * obj0 = 0 ;
3653 PyObject * obj1 = 0 ;
3654 char *kwnames[] = {
3655 (char *) "self",(char *) "sz", NULL
3656 };
3657
3658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3660 if (SWIG_arg_fail(1)) SWIG_fail;
3661 {
3662 arg2 = &temp2;
3663 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3664 }
3665 {
3666 PyThreadState* __tstate = wxPyBeginAllowThreads();
3667 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3668
3669 wxPyEndAllowThreads(__tstate);
3670 if (PyErr_Occurred()) SWIG_fail;
3671 }
3672 {
3673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3674 }
3675 return resultobj;
3676 fail:
3677 return NULL;
3678 }
3679
3680
3681 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3682 PyObject *resultobj = NULL;
3683 wxSize *arg1 = (wxSize *) 0 ;
3684 wxSize *arg2 = 0 ;
3685 bool result;
3686 wxSize temp2 ;
3687 PyObject * obj0 = 0 ;
3688 PyObject * obj1 = 0 ;
3689 char *kwnames[] = {
3690 (char *) "self",(char *) "sz", NULL
3691 };
3692
3693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3695 if (SWIG_arg_fail(1)) SWIG_fail;
3696 {
3697 arg2 = &temp2;
3698 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3699 }
3700 {
3701 PyThreadState* __tstate = wxPyBeginAllowThreads();
3702 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3703
3704 wxPyEndAllowThreads(__tstate);
3705 if (PyErr_Occurred()) SWIG_fail;
3706 }
3707 {
3708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3709 }
3710 return resultobj;
3711 fail:
3712 return NULL;
3713 }
3714
3715
3716 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3717 PyObject *resultobj = NULL;
3718 wxSize *arg1 = (wxSize *) 0 ;
3719 wxSize *arg2 = 0 ;
3720 wxSize result;
3721 wxSize temp2 ;
3722 PyObject * obj0 = 0 ;
3723 PyObject * obj1 = 0 ;
3724 char *kwnames[] = {
3725 (char *) "self",(char *) "sz", NULL
3726 };
3727
3728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3730 if (SWIG_arg_fail(1)) SWIG_fail;
3731 {
3732 arg2 = &temp2;
3733 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3734 }
3735 {
3736 PyThreadState* __tstate = wxPyBeginAllowThreads();
3737 result = (arg1)->operator +((wxSize const &)*arg2);
3738
3739 wxPyEndAllowThreads(__tstate);
3740 if (PyErr_Occurred()) SWIG_fail;
3741 }
3742 {
3743 wxSize * resultptr;
3744 resultptr = new wxSize(static_cast<wxSize & >(result));
3745 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3746 }
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj = NULL;
3755 wxSize *arg1 = (wxSize *) 0 ;
3756 wxSize *arg2 = 0 ;
3757 wxSize result;
3758 wxSize temp2 ;
3759 PyObject * obj0 = 0 ;
3760 PyObject * obj1 = 0 ;
3761 char *kwnames[] = {
3762 (char *) "self",(char *) "sz", NULL
3763 };
3764
3765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3767 if (SWIG_arg_fail(1)) SWIG_fail;
3768 {
3769 arg2 = &temp2;
3770 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3771 }
3772 {
3773 PyThreadState* __tstate = wxPyBeginAllowThreads();
3774 result = (arg1)->operator -((wxSize const &)*arg2);
3775
3776 wxPyEndAllowThreads(__tstate);
3777 if (PyErr_Occurred()) SWIG_fail;
3778 }
3779 {
3780 wxSize * resultptr;
3781 resultptr = new wxSize(static_cast<wxSize & >(result));
3782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3783 }
3784 return resultobj;
3785 fail:
3786 return NULL;
3787 }
3788
3789
3790 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3791 PyObject *resultobj = NULL;
3792 wxSize *arg1 = (wxSize *) 0 ;
3793 wxSize *arg2 = 0 ;
3794 wxSize temp2 ;
3795 PyObject * obj0 = 0 ;
3796 PyObject * obj1 = 0 ;
3797 char *kwnames[] = {
3798 (char *) "self",(char *) "sz", NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3803 if (SWIG_arg_fail(1)) SWIG_fail;
3804 {
3805 arg2 = &temp2;
3806 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3807 }
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 (arg1)->IncTo((wxSize const &)*arg2);
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 Py_INCREF(Py_None); resultobj = Py_None;
3816 return resultobj;
3817 fail:
3818 return NULL;
3819 }
3820
3821
3822 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3823 PyObject *resultobj = NULL;
3824 wxSize *arg1 = (wxSize *) 0 ;
3825 wxSize *arg2 = 0 ;
3826 wxSize temp2 ;
3827 PyObject * obj0 = 0 ;
3828 PyObject * obj1 = 0 ;
3829 char *kwnames[] = {
3830 (char *) "self",(char *) "sz", NULL
3831 };
3832
3833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3835 if (SWIG_arg_fail(1)) SWIG_fail;
3836 {
3837 arg2 = &temp2;
3838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3839 }
3840 {
3841 PyThreadState* __tstate = wxPyBeginAllowThreads();
3842 (arg1)->DecTo((wxSize const &)*arg2);
3843
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 Py_INCREF(Py_None); resultobj = Py_None;
3848 return resultobj;
3849 fail:
3850 return NULL;
3851 }
3852
3853
3854 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3855 PyObject *resultobj = NULL;
3856 wxSize *arg1 = (wxSize *) 0 ;
3857 int arg2 ;
3858 int arg3 ;
3859 PyObject * obj0 = 0 ;
3860 PyObject * obj1 = 0 ;
3861 PyObject * obj2 = 0 ;
3862 char *kwnames[] = {
3863 (char *) "self",(char *) "w",(char *) "h", NULL
3864 };
3865
3866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3868 if (SWIG_arg_fail(1)) SWIG_fail;
3869 {
3870 arg2 = static_cast<int >(SWIG_As_int(obj1));
3871 if (SWIG_arg_fail(2)) SWIG_fail;
3872 }
3873 {
3874 arg3 = static_cast<int >(SWIG_As_int(obj2));
3875 if (SWIG_arg_fail(3)) SWIG_fail;
3876 }
3877 {
3878 PyThreadState* __tstate = wxPyBeginAllowThreads();
3879 (arg1)->Set(arg2,arg3);
3880
3881 wxPyEndAllowThreads(__tstate);
3882 if (PyErr_Occurred()) SWIG_fail;
3883 }
3884 Py_INCREF(Py_None); resultobj = Py_None;
3885 return resultobj;
3886 fail:
3887 return NULL;
3888 }
3889
3890
3891 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3892 PyObject *resultobj = NULL;
3893 wxSize *arg1 = (wxSize *) 0 ;
3894 int arg2 ;
3895 PyObject * obj0 = 0 ;
3896 PyObject * obj1 = 0 ;
3897 char *kwnames[] = {
3898 (char *) "self",(char *) "w", NULL
3899 };
3900
3901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3903 if (SWIG_arg_fail(1)) SWIG_fail;
3904 {
3905 arg2 = static_cast<int >(SWIG_As_int(obj1));
3906 if (SWIG_arg_fail(2)) SWIG_fail;
3907 }
3908 {
3909 PyThreadState* __tstate = wxPyBeginAllowThreads();
3910 (arg1)->SetWidth(arg2);
3911
3912 wxPyEndAllowThreads(__tstate);
3913 if (PyErr_Occurred()) SWIG_fail;
3914 }
3915 Py_INCREF(Py_None); resultobj = Py_None;
3916 return resultobj;
3917 fail:
3918 return NULL;
3919 }
3920
3921
3922 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3923 PyObject *resultobj = NULL;
3924 wxSize *arg1 = (wxSize *) 0 ;
3925 int arg2 ;
3926 PyObject * obj0 = 0 ;
3927 PyObject * obj1 = 0 ;
3928 char *kwnames[] = {
3929 (char *) "self",(char *) "h", NULL
3930 };
3931
3932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3934 if (SWIG_arg_fail(1)) SWIG_fail;
3935 {
3936 arg2 = static_cast<int >(SWIG_As_int(obj1));
3937 if (SWIG_arg_fail(2)) SWIG_fail;
3938 }
3939 {
3940 PyThreadState* __tstate = wxPyBeginAllowThreads();
3941 (arg1)->SetHeight(arg2);
3942
3943 wxPyEndAllowThreads(__tstate);
3944 if (PyErr_Occurred()) SWIG_fail;
3945 }
3946 Py_INCREF(Py_None); resultobj = Py_None;
3947 return resultobj;
3948 fail:
3949 return NULL;
3950 }
3951
3952
3953 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3954 PyObject *resultobj = NULL;
3955 wxSize *arg1 = (wxSize *) 0 ;
3956 int result;
3957 PyObject * obj0 = 0 ;
3958 char *kwnames[] = {
3959 (char *) "self", NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3964 if (SWIG_arg_fail(1)) SWIG_fail;
3965 {
3966 PyThreadState* __tstate = wxPyBeginAllowThreads();
3967 result = (int)((wxSize const *)arg1)->GetWidth();
3968
3969 wxPyEndAllowThreads(__tstate);
3970 if (PyErr_Occurred()) SWIG_fail;
3971 }
3972 {
3973 resultobj = SWIG_From_int(static_cast<int >(result));
3974 }
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj = NULL;
3983 wxSize *arg1 = (wxSize *) 0 ;
3984 int result;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 {
3994 PyThreadState* __tstate = wxPyBeginAllowThreads();
3995 result = (int)((wxSize const *)arg1)->GetHeight();
3996
3997 wxPyEndAllowThreads(__tstate);
3998 if (PyErr_Occurred()) SWIG_fail;
3999 }
4000 {
4001 resultobj = SWIG_From_int(static_cast<int >(result));
4002 }
4003 return resultobj;
4004 fail:
4005 return NULL;
4006 }
4007
4008
4009 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
4010 PyObject *resultobj = NULL;
4011 wxSize *arg1 = (wxSize *) 0 ;
4012 bool result;
4013 PyObject * obj0 = 0 ;
4014 char *kwnames[] = {
4015 (char *) "self", NULL
4016 };
4017
4018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4020 if (SWIG_arg_fail(1)) SWIG_fail;
4021 {
4022 PyThreadState* __tstate = wxPyBeginAllowThreads();
4023 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4024
4025 wxPyEndAllowThreads(__tstate);
4026 if (PyErr_Occurred()) SWIG_fail;
4027 }
4028 {
4029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4030 }
4031 return resultobj;
4032 fail:
4033 return NULL;
4034 }
4035
4036
4037 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4038 PyObject *resultobj = NULL;
4039 wxSize *arg1 = (wxSize *) 0 ;
4040 wxSize *arg2 = 0 ;
4041 wxSize temp2 ;
4042 PyObject * obj0 = 0 ;
4043 PyObject * obj1 = 0 ;
4044 char *kwnames[] = {
4045 (char *) "self",(char *) "size", NULL
4046 };
4047
4048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4050 if (SWIG_arg_fail(1)) SWIG_fail;
4051 {
4052 arg2 = &temp2;
4053 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4054 }
4055 {
4056 PyThreadState* __tstate = wxPyBeginAllowThreads();
4057 (arg1)->SetDefaults((wxSize const &)*arg2);
4058
4059 wxPyEndAllowThreads(__tstate);
4060 if (PyErr_Occurred()) SWIG_fail;
4061 }
4062 Py_INCREF(Py_None); resultobj = Py_None;
4063 return resultobj;
4064 fail:
4065 return NULL;
4066 }
4067
4068
4069 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4070 PyObject *resultobj = NULL;
4071 wxSize *arg1 = (wxSize *) 0 ;
4072 PyObject *result;
4073 PyObject * obj0 = 0 ;
4074 char *kwnames[] = {
4075 (char *) "self", NULL
4076 };
4077
4078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4080 if (SWIG_arg_fail(1)) SWIG_fail;
4081 {
4082 PyThreadState* __tstate = wxPyBeginAllowThreads();
4083 result = (PyObject *)wxSize_Get(arg1);
4084
4085 wxPyEndAllowThreads(__tstate);
4086 if (PyErr_Occurred()) SWIG_fail;
4087 }
4088 resultobj = result;
4089 return resultobj;
4090 fail:
4091 return NULL;
4092 }
4093
4094
4095 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4096 PyObject *obj;
4097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4098 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4099 Py_INCREF(obj);
4100 return Py_BuildValue((char *)"");
4101 }
4102 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj = NULL;
4104 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4105 double arg2 ;
4106 PyObject * obj0 = 0 ;
4107 PyObject * obj1 = 0 ;
4108 char *kwnames[] = {
4109 (char *) "self",(char *) "x", NULL
4110 };
4111
4112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4114 if (SWIG_arg_fail(1)) SWIG_fail;
4115 {
4116 arg2 = static_cast<double >(SWIG_As_double(obj1));
4117 if (SWIG_arg_fail(2)) SWIG_fail;
4118 }
4119 if (arg1) (arg1)->x = arg2;
4120
4121 Py_INCREF(Py_None); resultobj = Py_None;
4122 return resultobj;
4123 fail:
4124 return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4129 PyObject *resultobj = NULL;
4130 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4131 double result;
4132 PyObject * obj0 = 0 ;
4133 char *kwnames[] = {
4134 (char *) "self", NULL
4135 };
4136
4137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4139 if (SWIG_arg_fail(1)) SWIG_fail;
4140 result = (double) ((arg1)->x);
4141
4142 {
4143 resultobj = SWIG_From_double(static_cast<double >(result));
4144 }
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj = NULL;
4153 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4154 double arg2 ;
4155 PyObject * obj0 = 0 ;
4156 PyObject * obj1 = 0 ;
4157 char *kwnames[] = {
4158 (char *) "self",(char *) "y", NULL
4159 };
4160
4161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4163 if (SWIG_arg_fail(1)) SWIG_fail;
4164 {
4165 arg2 = static_cast<double >(SWIG_As_double(obj1));
4166 if (SWIG_arg_fail(2)) SWIG_fail;
4167 }
4168 if (arg1) (arg1)->y = arg2;
4169
4170 Py_INCREF(Py_None); resultobj = Py_None;
4171 return resultobj;
4172 fail:
4173 return NULL;
4174 }
4175
4176
4177 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4178 PyObject *resultobj = NULL;
4179 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4180 double result;
4181 PyObject * obj0 = 0 ;
4182 char *kwnames[] = {
4183 (char *) "self", NULL
4184 };
4185
4186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4188 if (SWIG_arg_fail(1)) SWIG_fail;
4189 result = (double) ((arg1)->y);
4190
4191 {
4192 resultobj = SWIG_From_double(static_cast<double >(result));
4193 }
4194 return resultobj;
4195 fail:
4196 return NULL;
4197 }
4198
4199
4200 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4201 PyObject *resultobj = NULL;
4202 double arg1 = (double) 0.0 ;
4203 double arg2 = (double) 0.0 ;
4204 wxRealPoint *result;
4205 PyObject * obj0 = 0 ;
4206 PyObject * obj1 = 0 ;
4207 char *kwnames[] = {
4208 (char *) "x",(char *) "y", NULL
4209 };
4210
4211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4212 if (obj0) {
4213 {
4214 arg1 = static_cast<double >(SWIG_As_double(obj0));
4215 if (SWIG_arg_fail(1)) SWIG_fail;
4216 }
4217 }
4218 if (obj1) {
4219 {
4220 arg2 = static_cast<double >(SWIG_As_double(obj1));
4221 if (SWIG_arg_fail(2)) SWIG_fail;
4222 }
4223 }
4224 {
4225 PyThreadState* __tstate = wxPyBeginAllowThreads();
4226 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4227
4228 wxPyEndAllowThreads(__tstate);
4229 if (PyErr_Occurred()) SWIG_fail;
4230 }
4231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4232 return resultobj;
4233 fail:
4234 return NULL;
4235 }
4236
4237
4238 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4239 PyObject *resultobj = NULL;
4240 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4241 PyObject * obj0 = 0 ;
4242 char *kwnames[] = {
4243 (char *) "self", NULL
4244 };
4245
4246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4248 if (SWIG_arg_fail(1)) SWIG_fail;
4249 {
4250 PyThreadState* __tstate = wxPyBeginAllowThreads();
4251 delete arg1;
4252
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 Py_INCREF(Py_None); resultobj = Py_None;
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4264 PyObject *resultobj = NULL;
4265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4266 wxRealPoint *arg2 = 0 ;
4267 bool result;
4268 wxRealPoint temp2 ;
4269 PyObject * obj0 = 0 ;
4270 PyObject * obj1 = 0 ;
4271 char *kwnames[] = {
4272 (char *) "self",(char *) "pt", NULL
4273 };
4274
4275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4277 if (SWIG_arg_fail(1)) SWIG_fail;
4278 {
4279 arg2 = &temp2;
4280 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4281 }
4282 {
4283 PyThreadState* __tstate = wxPyBeginAllowThreads();
4284 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4285
4286 wxPyEndAllowThreads(__tstate);
4287 if (PyErr_Occurred()) SWIG_fail;
4288 }
4289 {
4290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4291 }
4292 return resultobj;
4293 fail:
4294 return NULL;
4295 }
4296
4297
4298 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4299 PyObject *resultobj = NULL;
4300 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4301 wxRealPoint *arg2 = 0 ;
4302 bool result;
4303 wxRealPoint temp2 ;
4304 PyObject * obj0 = 0 ;
4305 PyObject * obj1 = 0 ;
4306 char *kwnames[] = {
4307 (char *) "self",(char *) "pt", NULL
4308 };
4309
4310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4312 if (SWIG_arg_fail(1)) SWIG_fail;
4313 {
4314 arg2 = &temp2;
4315 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4316 }
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4320
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 {
4325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4326 }
4327 return resultobj;
4328 fail:
4329 return NULL;
4330 }
4331
4332
4333 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4334 PyObject *resultobj = NULL;
4335 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4336 wxRealPoint *arg2 = 0 ;
4337 wxRealPoint result;
4338 wxRealPoint temp2 ;
4339 PyObject * obj0 = 0 ;
4340 PyObject * obj1 = 0 ;
4341 char *kwnames[] = {
4342 (char *) "self",(char *) "pt", NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4347 if (SWIG_arg_fail(1)) SWIG_fail;
4348 {
4349 arg2 = &temp2;
4350 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4351 }
4352 {
4353 PyThreadState* __tstate = wxPyBeginAllowThreads();
4354 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4355
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 {
4360 wxRealPoint * resultptr;
4361 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4363 }
4364 return resultobj;
4365 fail:
4366 return NULL;
4367 }
4368
4369
4370 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj = NULL;
4372 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4373 wxRealPoint *arg2 = 0 ;
4374 wxRealPoint result;
4375 wxRealPoint temp2 ;
4376 PyObject * obj0 = 0 ;
4377 PyObject * obj1 = 0 ;
4378 char *kwnames[] = {
4379 (char *) "self",(char *) "pt", NULL
4380 };
4381
4382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4384 if (SWIG_arg_fail(1)) SWIG_fail;
4385 {
4386 arg2 = &temp2;
4387 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4388 }
4389 {
4390 PyThreadState* __tstate = wxPyBeginAllowThreads();
4391 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4392
4393 wxPyEndAllowThreads(__tstate);
4394 if (PyErr_Occurred()) SWIG_fail;
4395 }
4396 {
4397 wxRealPoint * resultptr;
4398 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4399 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4400 }
4401 return resultobj;
4402 fail:
4403 return NULL;
4404 }
4405
4406
4407 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4408 PyObject *resultobj = NULL;
4409 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4410 double arg2 ;
4411 double arg3 ;
4412 PyObject * obj0 = 0 ;
4413 PyObject * obj1 = 0 ;
4414 PyObject * obj2 = 0 ;
4415 char *kwnames[] = {
4416 (char *) "self",(char *) "x",(char *) "y", NULL
4417 };
4418
4419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4421 if (SWIG_arg_fail(1)) SWIG_fail;
4422 {
4423 arg2 = static_cast<double >(SWIG_As_double(obj1));
4424 if (SWIG_arg_fail(2)) SWIG_fail;
4425 }
4426 {
4427 arg3 = static_cast<double >(SWIG_As_double(obj2));
4428 if (SWIG_arg_fail(3)) SWIG_fail;
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 wxRealPoint_Set(arg1,arg2,arg3);
4433
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 Py_INCREF(Py_None); resultobj = Py_None;
4438 return resultobj;
4439 fail:
4440 return NULL;
4441 }
4442
4443
4444 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4445 PyObject *resultobj = NULL;
4446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4447 PyObject *result;
4448 PyObject * obj0 = 0 ;
4449 char *kwnames[] = {
4450 (char *) "self", NULL
4451 };
4452
4453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4455 if (SWIG_arg_fail(1)) SWIG_fail;
4456 {
4457 PyThreadState* __tstate = wxPyBeginAllowThreads();
4458 result = (PyObject *)wxRealPoint_Get(arg1);
4459
4460 wxPyEndAllowThreads(__tstate);
4461 if (PyErr_Occurred()) SWIG_fail;
4462 }
4463 resultobj = result;
4464 return resultobj;
4465 fail:
4466 return NULL;
4467 }
4468
4469
4470 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4471 PyObject *obj;
4472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4473 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4474 Py_INCREF(obj);
4475 return Py_BuildValue((char *)"");
4476 }
4477 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj = NULL;
4479 wxPoint *arg1 = (wxPoint *) 0 ;
4480 int arg2 ;
4481 PyObject * obj0 = 0 ;
4482 PyObject * obj1 = 0 ;
4483 char *kwnames[] = {
4484 (char *) "self",(char *) "x", NULL
4485 };
4486
4487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4489 if (SWIG_arg_fail(1)) SWIG_fail;
4490 {
4491 arg2 = static_cast<int >(SWIG_As_int(obj1));
4492 if (SWIG_arg_fail(2)) SWIG_fail;
4493 }
4494 if (arg1) (arg1)->x = arg2;
4495
4496 Py_INCREF(Py_None); resultobj = Py_None;
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj = NULL;
4505 wxPoint *arg1 = (wxPoint *) 0 ;
4506 int result;
4507 PyObject * obj0 = 0 ;
4508 char *kwnames[] = {
4509 (char *) "self", NULL
4510 };
4511
4512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4514 if (SWIG_arg_fail(1)) SWIG_fail;
4515 result = (int) ((arg1)->x);
4516
4517 {
4518 resultobj = SWIG_From_int(static_cast<int >(result));
4519 }
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj = NULL;
4528 wxPoint *arg1 = (wxPoint *) 0 ;
4529 int arg2 ;
4530 PyObject * obj0 = 0 ;
4531 PyObject * obj1 = 0 ;
4532 char *kwnames[] = {
4533 (char *) "self",(char *) "y", NULL
4534 };
4535
4536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4538 if (SWIG_arg_fail(1)) SWIG_fail;
4539 {
4540 arg2 = static_cast<int >(SWIG_As_int(obj1));
4541 if (SWIG_arg_fail(2)) SWIG_fail;
4542 }
4543 if (arg1) (arg1)->y = arg2;
4544
4545 Py_INCREF(Py_None); resultobj = Py_None;
4546 return resultobj;
4547 fail:
4548 return NULL;
4549 }
4550
4551
4552 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4553 PyObject *resultobj = NULL;
4554 wxPoint *arg1 = (wxPoint *) 0 ;
4555 int result;
4556 PyObject * obj0 = 0 ;
4557 char *kwnames[] = {
4558 (char *) "self", NULL
4559 };
4560
4561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4563 if (SWIG_arg_fail(1)) SWIG_fail;
4564 result = (int) ((arg1)->y);
4565
4566 {
4567 resultobj = SWIG_From_int(static_cast<int >(result));
4568 }
4569 return resultobj;
4570 fail:
4571 return NULL;
4572 }
4573
4574
4575 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4576 PyObject *resultobj = NULL;
4577 int arg1 = (int) 0 ;
4578 int arg2 = (int) 0 ;
4579 wxPoint *result;
4580 PyObject * obj0 = 0 ;
4581 PyObject * obj1 = 0 ;
4582 char *kwnames[] = {
4583 (char *) "x",(char *) "y", NULL
4584 };
4585
4586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4587 if (obj0) {
4588 {
4589 arg1 = static_cast<int >(SWIG_As_int(obj0));
4590 if (SWIG_arg_fail(1)) SWIG_fail;
4591 }
4592 }
4593 if (obj1) {
4594 {
4595 arg2 = static_cast<int >(SWIG_As_int(obj1));
4596 if (SWIG_arg_fail(2)) SWIG_fail;
4597 }
4598 }
4599 {
4600 PyThreadState* __tstate = wxPyBeginAllowThreads();
4601 result = (wxPoint *)new wxPoint(arg1,arg2);
4602
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4607 return resultobj;
4608 fail:
4609 return NULL;
4610 }
4611
4612
4613 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4614 PyObject *resultobj = NULL;
4615 wxPoint *arg1 = (wxPoint *) 0 ;
4616 PyObject * obj0 = 0 ;
4617 char *kwnames[] = {
4618 (char *) "self", NULL
4619 };
4620
4621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4623 if (SWIG_arg_fail(1)) SWIG_fail;
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 delete arg1;
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 Py_INCREF(Py_None); resultobj = Py_None;
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = NULL;
4640 wxPoint *arg1 = (wxPoint *) 0 ;
4641 wxPoint *arg2 = 0 ;
4642 bool result;
4643 wxPoint temp2 ;
4644 PyObject * obj0 = 0 ;
4645 PyObject * obj1 = 0 ;
4646 char *kwnames[] = {
4647 (char *) "self",(char *) "pt", NULL
4648 };
4649
4650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4652 if (SWIG_arg_fail(1)) SWIG_fail;
4653 {
4654 arg2 = &temp2;
4655 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4656 }
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4660
4661 wxPyEndAllowThreads(__tstate);
4662 if (PyErr_Occurred()) SWIG_fail;
4663 }
4664 {
4665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4666 }
4667 return resultobj;
4668 fail:
4669 return NULL;
4670 }
4671
4672
4673 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4674 PyObject *resultobj = NULL;
4675 wxPoint *arg1 = (wxPoint *) 0 ;
4676 wxPoint *arg2 = 0 ;
4677 bool result;
4678 wxPoint temp2 ;
4679 PyObject * obj0 = 0 ;
4680 PyObject * obj1 = 0 ;
4681 char *kwnames[] = {
4682 (char *) "self",(char *) "pt", NULL
4683 };
4684
4685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4687 if (SWIG_arg_fail(1)) SWIG_fail;
4688 {
4689 arg2 = &temp2;
4690 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4691 }
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4695
4696 wxPyEndAllowThreads(__tstate);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 {
4700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4701 }
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = NULL;
4710 wxPoint *arg1 = (wxPoint *) 0 ;
4711 wxPoint *arg2 = 0 ;
4712 wxPoint result;
4713 wxPoint temp2 ;
4714 PyObject * obj0 = 0 ;
4715 PyObject * obj1 = 0 ;
4716 char *kwnames[] = {
4717 (char *) "self",(char *) "pt", NULL
4718 };
4719
4720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4722 if (SWIG_arg_fail(1)) SWIG_fail;
4723 {
4724 arg2 = &temp2;
4725 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (arg1)->operator +((wxPoint const &)*arg2);
4730
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 {
4735 wxPoint * resultptr;
4736 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4737 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4738 }
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = NULL;
4747 wxPoint *arg1 = (wxPoint *) 0 ;
4748 wxPoint *arg2 = 0 ;
4749 wxPoint result;
4750 wxPoint temp2 ;
4751 PyObject * obj0 = 0 ;
4752 PyObject * obj1 = 0 ;
4753 char *kwnames[] = {
4754 (char *) "self",(char *) "pt", NULL
4755 };
4756
4757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4759 if (SWIG_arg_fail(1)) SWIG_fail;
4760 {
4761 arg2 = &temp2;
4762 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4763 }
4764 {
4765 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (arg1)->operator -((wxPoint const &)*arg2);
4767
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 {
4772 wxPoint * resultptr;
4773 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4774 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4775 }
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj = NULL;
4784 wxPoint *arg1 = (wxPoint *) 0 ;
4785 wxPoint *arg2 = 0 ;
4786 wxPoint *result;
4787 wxPoint temp2 ;
4788 PyObject * obj0 = 0 ;
4789 PyObject * obj1 = 0 ;
4790 char *kwnames[] = {
4791 (char *) "self",(char *) "pt", NULL
4792 };
4793
4794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4796 if (SWIG_arg_fail(1)) SWIG_fail;
4797 {
4798 arg2 = &temp2;
4799 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4800 }
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 {
4804 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4805 result = (wxPoint *) &_result_ref;
4806 }
4807
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj = NULL;
4820 wxPoint *arg1 = (wxPoint *) 0 ;
4821 wxPoint *arg2 = 0 ;
4822 wxPoint *result;
4823 wxPoint temp2 ;
4824 PyObject * obj0 = 0 ;
4825 PyObject * obj1 = 0 ;
4826 char *kwnames[] = {
4827 (char *) "self",(char *) "pt", NULL
4828 };
4829
4830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4832 if (SWIG_arg_fail(1)) SWIG_fail;
4833 {
4834 arg2 = &temp2;
4835 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 {
4840 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4841 result = (wxPoint *) &_result_ref;
4842 }
4843
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj = NULL;
4856 wxPoint *arg1 = (wxPoint *) 0 ;
4857 long arg2 ;
4858 long arg3 ;
4859 PyObject * obj0 = 0 ;
4860 PyObject * obj1 = 0 ;
4861 PyObject * obj2 = 0 ;
4862 char *kwnames[] = {
4863 (char *) "self",(char *) "x",(char *) "y", NULL
4864 };
4865
4866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4868 if (SWIG_arg_fail(1)) SWIG_fail;
4869 {
4870 arg2 = static_cast<long >(SWIG_As_long(obj1));
4871 if (SWIG_arg_fail(2)) SWIG_fail;
4872 }
4873 {
4874 arg3 = static_cast<long >(SWIG_As_long(obj2));
4875 if (SWIG_arg_fail(3)) SWIG_fail;
4876 }
4877 {
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 wxPoint_Set(arg1,arg2,arg3);
4880
4881 wxPyEndAllowThreads(__tstate);
4882 if (PyErr_Occurred()) SWIG_fail;
4883 }
4884 Py_INCREF(Py_None); resultobj = Py_None;
4885 return resultobj;
4886 fail:
4887 return NULL;
4888 }
4889
4890
4891 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4892 PyObject *resultobj = NULL;
4893 wxPoint *arg1 = (wxPoint *) 0 ;
4894 PyObject *result;
4895 PyObject * obj0 = 0 ;
4896 char *kwnames[] = {
4897 (char *) "self", NULL
4898 };
4899
4900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4902 if (SWIG_arg_fail(1)) SWIG_fail;
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 result = (PyObject *)wxPoint_Get(arg1);
4906
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = result;
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4918 PyObject *obj;
4919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4920 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4921 Py_INCREF(obj);
4922 return Py_BuildValue((char *)"");
4923 }
4924 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj = NULL;
4926 int arg1 = (int) 0 ;
4927 int arg2 = (int) 0 ;
4928 int arg3 = (int) 0 ;
4929 int arg4 = (int) 0 ;
4930 wxRect *result;
4931 PyObject * obj0 = 0 ;
4932 PyObject * obj1 = 0 ;
4933 PyObject * obj2 = 0 ;
4934 PyObject * obj3 = 0 ;
4935 char *kwnames[] = {
4936 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4937 };
4938
4939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4940 if (obj0) {
4941 {
4942 arg1 = static_cast<int >(SWIG_As_int(obj0));
4943 if (SWIG_arg_fail(1)) SWIG_fail;
4944 }
4945 }
4946 if (obj1) {
4947 {
4948 arg2 = static_cast<int >(SWIG_As_int(obj1));
4949 if (SWIG_arg_fail(2)) SWIG_fail;
4950 }
4951 }
4952 if (obj2) {
4953 {
4954 arg3 = static_cast<int >(SWIG_As_int(obj2));
4955 if (SWIG_arg_fail(3)) SWIG_fail;
4956 }
4957 }
4958 if (obj3) {
4959 {
4960 arg4 = static_cast<int >(SWIG_As_int(obj3));
4961 if (SWIG_arg_fail(4)) SWIG_fail;
4962 }
4963 }
4964 {
4965 PyThreadState* __tstate = wxPyBeginAllowThreads();
4966 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4967
4968 wxPyEndAllowThreads(__tstate);
4969 if (PyErr_Occurred()) SWIG_fail;
4970 }
4971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4972 return resultobj;
4973 fail:
4974 return NULL;
4975 }
4976
4977
4978 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4979 PyObject *resultobj = NULL;
4980 wxPoint *arg1 = 0 ;
4981 wxPoint *arg2 = 0 ;
4982 wxRect *result;
4983 wxPoint temp1 ;
4984 wxPoint temp2 ;
4985 PyObject * obj0 = 0 ;
4986 PyObject * obj1 = 0 ;
4987 char *kwnames[] = {
4988 (char *) "topLeft",(char *) "bottomRight", NULL
4989 };
4990
4991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4992 {
4993 arg1 = &temp1;
4994 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4995 }
4996 {
4997 arg2 = &temp2;
4998 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4999 }
5000 {
5001 PyThreadState* __tstate = wxPyBeginAllowThreads();
5002 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
5003
5004 wxPyEndAllowThreads(__tstate);
5005 if (PyErr_Occurred()) SWIG_fail;
5006 }
5007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5008 return resultobj;
5009 fail:
5010 return NULL;
5011 }
5012
5013
5014 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5015 PyObject *resultobj = NULL;
5016 wxPoint *arg1 = 0 ;
5017 wxSize *arg2 = 0 ;
5018 wxRect *result;
5019 wxPoint temp1 ;
5020 wxSize temp2 ;
5021 PyObject * obj0 = 0 ;
5022 PyObject * obj1 = 0 ;
5023 char *kwnames[] = {
5024 (char *) "pos",(char *) "size", NULL
5025 };
5026
5027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5028 {
5029 arg1 = &temp1;
5030 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5031 }
5032 {
5033 arg2 = &temp2;
5034 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5035 }
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5039
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5044 return resultobj;
5045 fail:
5046 return NULL;
5047 }
5048
5049
5050 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5051 PyObject *resultobj = NULL;
5052 wxSize *arg1 = 0 ;
5053 wxRect *result;
5054 wxSize temp1 ;
5055 PyObject * obj0 = 0 ;
5056 char *kwnames[] = {
5057 (char *) "size", NULL
5058 };
5059
5060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5061 {
5062 arg1 = &temp1;
5063 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5064 }
5065 {
5066 PyThreadState* __tstate = wxPyBeginAllowThreads();
5067 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5068
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5080 PyObject *resultobj = NULL;
5081 wxRect *arg1 = (wxRect *) 0 ;
5082 PyObject * obj0 = 0 ;
5083 char *kwnames[] = {
5084 (char *) "self", NULL
5085 };
5086
5087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5089 if (SWIG_arg_fail(1)) SWIG_fail;
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 delete arg1;
5093
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 Py_INCREF(Py_None); resultobj = Py_None;
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5105 PyObject *resultobj = NULL;
5106 wxRect *arg1 = (wxRect *) 0 ;
5107 int result;
5108 PyObject * obj0 = 0 ;
5109 char *kwnames[] = {
5110 (char *) "self", NULL
5111 };
5112
5113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5115 if (SWIG_arg_fail(1)) SWIG_fail;
5116 {
5117 PyThreadState* __tstate = wxPyBeginAllowThreads();
5118 result = (int)((wxRect const *)arg1)->GetX();
5119
5120 wxPyEndAllowThreads(__tstate);
5121 if (PyErr_Occurred()) SWIG_fail;
5122 }
5123 {
5124 resultobj = SWIG_From_int(static_cast<int >(result));
5125 }
5126 return resultobj;
5127 fail:
5128 return NULL;
5129 }
5130
5131
5132 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5133 PyObject *resultobj = NULL;
5134 wxRect *arg1 = (wxRect *) 0 ;
5135 int arg2 ;
5136 PyObject * obj0 = 0 ;
5137 PyObject * obj1 = 0 ;
5138 char *kwnames[] = {
5139 (char *) "self",(char *) "x", NULL
5140 };
5141
5142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5144 if (SWIG_arg_fail(1)) SWIG_fail;
5145 {
5146 arg2 = static_cast<int >(SWIG_As_int(obj1));
5147 if (SWIG_arg_fail(2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetX(arg2);
5152
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 Py_INCREF(Py_None); resultobj = Py_None;
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5164 PyObject *resultobj = NULL;
5165 wxRect *arg1 = (wxRect *) 0 ;
5166 int result;
5167 PyObject * obj0 = 0 ;
5168 char *kwnames[] = {
5169 (char *) "self", NULL
5170 };
5171
5172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5174 if (SWIG_arg_fail(1)) SWIG_fail;
5175 {
5176 PyThreadState* __tstate = wxPyBeginAllowThreads();
5177 result = (int)(arg1)->GetY();
5178
5179 wxPyEndAllowThreads(__tstate);
5180 if (PyErr_Occurred()) SWIG_fail;
5181 }
5182 {
5183 resultobj = SWIG_From_int(static_cast<int >(result));
5184 }
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5192 PyObject *resultobj = NULL;
5193 wxRect *arg1 = (wxRect *) 0 ;
5194 int arg2 ;
5195 PyObject * obj0 = 0 ;
5196 PyObject * obj1 = 0 ;
5197 char *kwnames[] = {
5198 (char *) "self",(char *) "y", NULL
5199 };
5200
5201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5203 if (SWIG_arg_fail(1)) SWIG_fail;
5204 {
5205 arg2 = static_cast<int >(SWIG_As_int(obj1));
5206 if (SWIG_arg_fail(2)) SWIG_fail;
5207 }
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 (arg1)->SetY(arg2);
5211
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 Py_INCREF(Py_None); resultobj = Py_None;
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = NULL;
5224 wxRect *arg1 = (wxRect *) 0 ;
5225 int result;
5226 PyObject * obj0 = 0 ;
5227 char *kwnames[] = {
5228 (char *) "self", NULL
5229 };
5230
5231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5233 if (SWIG_arg_fail(1)) SWIG_fail;
5234 {
5235 PyThreadState* __tstate = wxPyBeginAllowThreads();
5236 result = (int)((wxRect const *)arg1)->GetWidth();
5237
5238 wxPyEndAllowThreads(__tstate);
5239 if (PyErr_Occurred()) SWIG_fail;
5240 }
5241 {
5242 resultobj = SWIG_From_int(static_cast<int >(result));
5243 }
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj = NULL;
5252 wxRect *arg1 = (wxRect *) 0 ;
5253 int arg2 ;
5254 PyObject * obj0 = 0 ;
5255 PyObject * obj1 = 0 ;
5256 char *kwnames[] = {
5257 (char *) "self",(char *) "w", NULL
5258 };
5259
5260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5262 if (SWIG_arg_fail(1)) SWIG_fail;
5263 {
5264 arg2 = static_cast<int >(SWIG_As_int(obj1));
5265 if (SWIG_arg_fail(2)) SWIG_fail;
5266 }
5267 {
5268 PyThreadState* __tstate = wxPyBeginAllowThreads();
5269 (arg1)->SetWidth(arg2);
5270
5271 wxPyEndAllowThreads(__tstate);
5272 if (PyErr_Occurred()) SWIG_fail;
5273 }
5274 Py_INCREF(Py_None); resultobj = Py_None;
5275 return resultobj;
5276 fail:
5277 return NULL;
5278 }
5279
5280
5281 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5282 PyObject *resultobj = NULL;
5283 wxRect *arg1 = (wxRect *) 0 ;
5284 int result;
5285 PyObject * obj0 = 0 ;
5286 char *kwnames[] = {
5287 (char *) "self", NULL
5288 };
5289
5290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5292 if (SWIG_arg_fail(1)) SWIG_fail;
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = (int)((wxRect const *)arg1)->GetHeight();
5296
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 {
5301 resultobj = SWIG_From_int(static_cast<int >(result));
5302 }
5303 return resultobj;
5304 fail:
5305 return NULL;
5306 }
5307
5308
5309 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5310 PyObject *resultobj = NULL;
5311 wxRect *arg1 = (wxRect *) 0 ;
5312 int arg2 ;
5313 PyObject * obj0 = 0 ;
5314 PyObject * obj1 = 0 ;
5315 char *kwnames[] = {
5316 (char *) "self",(char *) "h", NULL
5317 };
5318
5319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5321 if (SWIG_arg_fail(1)) SWIG_fail;
5322 {
5323 arg2 = static_cast<int >(SWIG_As_int(obj1));
5324 if (SWIG_arg_fail(2)) SWIG_fail;
5325 }
5326 {
5327 PyThreadState* __tstate = wxPyBeginAllowThreads();
5328 (arg1)->SetHeight(arg2);
5329
5330 wxPyEndAllowThreads(__tstate);
5331 if (PyErr_Occurred()) SWIG_fail;
5332 }
5333 Py_INCREF(Py_None); resultobj = Py_None;
5334 return resultobj;
5335 fail:
5336 return NULL;
5337 }
5338
5339
5340 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5341 PyObject *resultobj = NULL;
5342 wxRect *arg1 = (wxRect *) 0 ;
5343 wxPoint result;
5344 PyObject * obj0 = 0 ;
5345 char *kwnames[] = {
5346 (char *) "self", NULL
5347 };
5348
5349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5351 if (SWIG_arg_fail(1)) SWIG_fail;
5352 {
5353 PyThreadState* __tstate = wxPyBeginAllowThreads();
5354 result = ((wxRect const *)arg1)->GetPosition();
5355
5356 wxPyEndAllowThreads(__tstate);
5357 if (PyErr_Occurred()) SWIG_fail;
5358 }
5359 {
5360 wxPoint * resultptr;
5361 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5363 }
5364 return resultobj;
5365 fail:
5366 return NULL;
5367 }
5368
5369
5370 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5371 PyObject *resultobj = NULL;
5372 wxRect *arg1 = (wxRect *) 0 ;
5373 wxPoint *arg2 = 0 ;
5374 wxPoint temp2 ;
5375 PyObject * obj0 = 0 ;
5376 PyObject * obj1 = 0 ;
5377 char *kwnames[] = {
5378 (char *) "self",(char *) "p", NULL
5379 };
5380
5381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5383 if (SWIG_arg_fail(1)) SWIG_fail;
5384 {
5385 arg2 = &temp2;
5386 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5387 }
5388 {
5389 PyThreadState* __tstate = wxPyBeginAllowThreads();
5390 (arg1)->SetPosition((wxPoint const &)*arg2);
5391
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 Py_INCREF(Py_None); resultobj = Py_None;
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj = NULL;
5404 wxRect *arg1 = (wxRect *) 0 ;
5405 wxSize result;
5406 PyObject * obj0 = 0 ;
5407 char *kwnames[] = {
5408 (char *) "self", NULL
5409 };
5410
5411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5413 if (SWIG_arg_fail(1)) SWIG_fail;
5414 {
5415 PyThreadState* __tstate = wxPyBeginAllowThreads();
5416 result = ((wxRect const *)arg1)->GetSize();
5417
5418 wxPyEndAllowThreads(__tstate);
5419 if (PyErr_Occurred()) SWIG_fail;
5420 }
5421 {
5422 wxSize * resultptr;
5423 resultptr = new wxSize(static_cast<wxSize & >(result));
5424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5433 PyObject *resultobj = NULL;
5434 wxRect *arg1 = (wxRect *) 0 ;
5435 wxSize *arg2 = 0 ;
5436 wxSize temp2 ;
5437 PyObject * obj0 = 0 ;
5438 PyObject * obj1 = 0 ;
5439 char *kwnames[] = {
5440 (char *) "self",(char *) "s", NULL
5441 };
5442
5443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5445 if (SWIG_arg_fail(1)) SWIG_fail;
5446 {
5447 arg2 = &temp2;
5448 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5449 }
5450 {
5451 PyThreadState* __tstate = wxPyBeginAllowThreads();
5452 (arg1)->SetSize((wxSize const &)*arg2);
5453
5454 wxPyEndAllowThreads(__tstate);
5455 if (PyErr_Occurred()) SWIG_fail;
5456 }
5457 Py_INCREF(Py_None); resultobj = Py_None;
5458 return resultobj;
5459 fail:
5460 return NULL;
5461 }
5462
5463
5464 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5465 PyObject *resultobj = NULL;
5466 wxRect *arg1 = (wxRect *) 0 ;
5467 bool result;
5468 PyObject * obj0 = 0 ;
5469 char *kwnames[] = {
5470 (char *) "self", NULL
5471 };
5472
5473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5475 if (SWIG_arg_fail(1)) SWIG_fail;
5476 {
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 result = (bool)((wxRect const *)arg1)->IsEmpty();
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5485 }
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5493 PyObject *resultobj = NULL;
5494 wxRect *arg1 = (wxRect *) 0 ;
5495 wxPoint result;
5496 PyObject * obj0 = 0 ;
5497 char *kwnames[] = {
5498 (char *) "self", NULL
5499 };
5500
5501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5503 if (SWIG_arg_fail(1)) SWIG_fail;
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 result = ((wxRect const *)arg1)->GetTopLeft();
5507
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 {
5512 wxPoint * resultptr;
5513 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5515 }
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = NULL;
5524 wxRect *arg1 = (wxRect *) 0 ;
5525 wxPoint *arg2 = 0 ;
5526 wxPoint temp2 ;
5527 PyObject * obj0 = 0 ;
5528 PyObject * obj1 = 0 ;
5529 char *kwnames[] = {
5530 (char *) "self",(char *) "p", NULL
5531 };
5532
5533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5535 if (SWIG_arg_fail(1)) SWIG_fail;
5536 {
5537 arg2 = &temp2;
5538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5539 }
5540 {
5541 PyThreadState* __tstate = wxPyBeginAllowThreads();
5542 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5543
5544 wxPyEndAllowThreads(__tstate);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 Py_INCREF(Py_None); resultobj = Py_None;
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5555 PyObject *resultobj = NULL;
5556 wxRect *arg1 = (wxRect *) 0 ;
5557 wxPoint result;
5558 PyObject * obj0 = 0 ;
5559 char *kwnames[] = {
5560 (char *) "self", NULL
5561 };
5562
5563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5565 if (SWIG_arg_fail(1)) SWIG_fail;
5566 {
5567 PyThreadState* __tstate = wxPyBeginAllowThreads();
5568 result = ((wxRect const *)arg1)->GetBottomRight();
5569
5570 wxPyEndAllowThreads(__tstate);
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 {
5574 wxPoint * resultptr;
5575 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5577 }
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5585 PyObject *resultobj = NULL;
5586 wxRect *arg1 = (wxRect *) 0 ;
5587 wxPoint *arg2 = 0 ;
5588 wxPoint temp2 ;
5589 PyObject * obj0 = 0 ;
5590 PyObject * obj1 = 0 ;
5591 char *kwnames[] = {
5592 (char *) "self",(char *) "p", NULL
5593 };
5594
5595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5597 if (SWIG_arg_fail(1)) SWIG_fail;
5598 {
5599 arg2 = &temp2;
5600 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5601 }
5602 {
5603 PyThreadState* __tstate = wxPyBeginAllowThreads();
5604 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5605
5606 wxPyEndAllowThreads(__tstate);
5607 if (PyErr_Occurred()) SWIG_fail;
5608 }
5609 Py_INCREF(Py_None); resultobj = Py_None;
5610 return resultobj;
5611 fail:
5612 return NULL;
5613 }
5614
5615
5616 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5617 PyObject *resultobj = NULL;
5618 wxRect *arg1 = (wxRect *) 0 ;
5619 int result;
5620 PyObject * obj0 = 0 ;
5621 char *kwnames[] = {
5622 (char *) "self", NULL
5623 };
5624
5625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5627 if (SWIG_arg_fail(1)) SWIG_fail;
5628 {
5629 PyThreadState* __tstate = wxPyBeginAllowThreads();
5630 result = (int)((wxRect const *)arg1)->GetLeft();
5631
5632 wxPyEndAllowThreads(__tstate);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 {
5636 resultobj = SWIG_From_int(static_cast<int >(result));
5637 }
5638 return resultobj;
5639 fail:
5640 return NULL;
5641 }
5642
5643
5644 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5645 PyObject *resultobj = NULL;
5646 wxRect *arg1 = (wxRect *) 0 ;
5647 int result;
5648 PyObject * obj0 = 0 ;
5649 char *kwnames[] = {
5650 (char *) "self", NULL
5651 };
5652
5653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5655 if (SWIG_arg_fail(1)) SWIG_fail;
5656 {
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 result = (int)((wxRect const *)arg1)->GetTop();
5659
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 {
5664 resultobj = SWIG_From_int(static_cast<int >(result));
5665 }
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5673 PyObject *resultobj = NULL;
5674 wxRect *arg1 = (wxRect *) 0 ;
5675 int result;
5676 PyObject * obj0 = 0 ;
5677 char *kwnames[] = {
5678 (char *) "self", NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5683 if (SWIG_arg_fail(1)) SWIG_fail;
5684 {
5685 PyThreadState* __tstate = wxPyBeginAllowThreads();
5686 result = (int)((wxRect const *)arg1)->GetBottom();
5687
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 {
5692 resultobj = SWIG_From_int(static_cast<int >(result));
5693 }
5694 return resultobj;
5695 fail:
5696 return NULL;
5697 }
5698
5699
5700 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5701 PyObject *resultobj = NULL;
5702 wxRect *arg1 = (wxRect *) 0 ;
5703 int result;
5704 PyObject * obj0 = 0 ;
5705 char *kwnames[] = {
5706 (char *) "self", NULL
5707 };
5708
5709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5711 if (SWIG_arg_fail(1)) SWIG_fail;
5712 {
5713 PyThreadState* __tstate = wxPyBeginAllowThreads();
5714 result = (int)((wxRect const *)arg1)->GetRight();
5715
5716 wxPyEndAllowThreads(__tstate);
5717 if (PyErr_Occurred()) SWIG_fail;
5718 }
5719 {
5720 resultobj = SWIG_From_int(static_cast<int >(result));
5721 }
5722 return resultobj;
5723 fail:
5724 return NULL;
5725 }
5726
5727
5728 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5729 PyObject *resultobj = NULL;
5730 wxRect *arg1 = (wxRect *) 0 ;
5731 int arg2 ;
5732 PyObject * obj0 = 0 ;
5733 PyObject * obj1 = 0 ;
5734 char *kwnames[] = {
5735 (char *) "self",(char *) "left", NULL
5736 };
5737
5738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5740 if (SWIG_arg_fail(1)) SWIG_fail;
5741 {
5742 arg2 = static_cast<int >(SWIG_As_int(obj1));
5743 if (SWIG_arg_fail(2)) SWIG_fail;
5744 }
5745 {
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 (arg1)->SetLeft(arg2);
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 Py_INCREF(Py_None); resultobj = Py_None;
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj = NULL;
5761 wxRect *arg1 = (wxRect *) 0 ;
5762 int arg2 ;
5763 PyObject * obj0 = 0 ;
5764 PyObject * obj1 = 0 ;
5765 char *kwnames[] = {
5766 (char *) "self",(char *) "right", NULL
5767 };
5768
5769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5771 if (SWIG_arg_fail(1)) SWIG_fail;
5772 {
5773 arg2 = static_cast<int >(SWIG_As_int(obj1));
5774 if (SWIG_arg_fail(2)) SWIG_fail;
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 (arg1)->SetRight(arg2);
5779
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 Py_INCREF(Py_None); resultobj = Py_None;
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = NULL;
5792 wxRect *arg1 = (wxRect *) 0 ;
5793 int arg2 ;
5794 PyObject * obj0 = 0 ;
5795 PyObject * obj1 = 0 ;
5796 char *kwnames[] = {
5797 (char *) "self",(char *) "top", NULL
5798 };
5799
5800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5802 if (SWIG_arg_fail(1)) SWIG_fail;
5803 {
5804 arg2 = static_cast<int >(SWIG_As_int(obj1));
5805 if (SWIG_arg_fail(2)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 (arg1)->SetTop(arg2);
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 Py_INCREF(Py_None); resultobj = Py_None;
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj = NULL;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 int arg2 ;
5825 PyObject * obj0 = 0 ;
5826 PyObject * obj1 = 0 ;
5827 char *kwnames[] = {
5828 (char *) "self",(char *) "bottom", NULL
5829 };
5830
5831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5833 if (SWIG_arg_fail(1)) SWIG_fail;
5834 {
5835 arg2 = static_cast<int >(SWIG_As_int(obj1));
5836 if (SWIG_arg_fail(2)) SWIG_fail;
5837 }
5838 {
5839 PyThreadState* __tstate = wxPyBeginAllowThreads();
5840 (arg1)->SetBottom(arg2);
5841
5842 wxPyEndAllowThreads(__tstate);
5843 if (PyErr_Occurred()) SWIG_fail;
5844 }
5845 Py_INCREF(Py_None); resultobj = Py_None;
5846 return resultobj;
5847 fail:
5848 return NULL;
5849 }
5850
5851
5852 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5853 PyObject *resultobj = NULL;
5854 wxRect *arg1 = (wxRect *) 0 ;
5855 int arg2 ;
5856 int arg3 ;
5857 wxRect *result;
5858 PyObject * obj0 = 0 ;
5859 PyObject * obj1 = 0 ;
5860 PyObject * obj2 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "dx",(char *) "dy", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = static_cast<int >(SWIG_As_int(obj1));
5870 if (SWIG_arg_fail(2)) SWIG_fail;
5871 }
5872 {
5873 arg3 = static_cast<int >(SWIG_As_int(obj2));
5874 if (SWIG_arg_fail(3)) SWIG_fail;
5875 }
5876 {
5877 PyThreadState* __tstate = wxPyBeginAllowThreads();
5878 {
5879 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5880 result = (wxRect *) &_result_ref;
5881 }
5882
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj = NULL;
5895 wxRect *arg1 = (wxRect *) 0 ;
5896 int arg2 ;
5897 int arg3 ;
5898 wxRect *result;
5899 PyObject * obj0 = 0 ;
5900 PyObject * obj1 = 0 ;
5901 PyObject * obj2 = 0 ;
5902 char *kwnames[] = {
5903 (char *) "self",(char *) "dx",(char *) "dy", NULL
5904 };
5905
5906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5908 if (SWIG_arg_fail(1)) SWIG_fail;
5909 {
5910 arg2 = static_cast<int >(SWIG_As_int(obj1));
5911 if (SWIG_arg_fail(2)) SWIG_fail;
5912 }
5913 {
5914 arg3 = static_cast<int >(SWIG_As_int(obj2));
5915 if (SWIG_arg_fail(3)) SWIG_fail;
5916 }
5917 {
5918 PyThreadState* __tstate = wxPyBeginAllowThreads();
5919 {
5920 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5921 result = (wxRect *) &_result_ref;
5922 }
5923
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5928 return resultobj;
5929 fail:
5930 return NULL;
5931 }
5932
5933
5934 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj = NULL;
5936 wxRect *arg1 = (wxRect *) 0 ;
5937 int arg2 ;
5938 int arg3 ;
5939 PyObject * obj0 = 0 ;
5940 PyObject * obj1 = 0 ;
5941 PyObject * obj2 = 0 ;
5942 char *kwnames[] = {
5943 (char *) "self",(char *) "dx",(char *) "dy", NULL
5944 };
5945
5946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5948 if (SWIG_arg_fail(1)) SWIG_fail;
5949 {
5950 arg2 = static_cast<int >(SWIG_As_int(obj1));
5951 if (SWIG_arg_fail(2)) SWIG_fail;
5952 }
5953 {
5954 arg3 = static_cast<int >(SWIG_As_int(obj2));
5955 if (SWIG_arg_fail(3)) SWIG_fail;
5956 }
5957 {
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 (arg1)->Offset(arg2,arg3);
5960
5961 wxPyEndAllowThreads(__tstate);
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 Py_INCREF(Py_None); resultobj = Py_None;
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5972 PyObject *resultobj = NULL;
5973 wxRect *arg1 = (wxRect *) 0 ;
5974 wxPoint *arg2 = 0 ;
5975 wxPoint temp2 ;
5976 PyObject * obj0 = 0 ;
5977 PyObject * obj1 = 0 ;
5978 char *kwnames[] = {
5979 (char *) "self",(char *) "pt", NULL
5980 };
5981
5982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5984 if (SWIG_arg_fail(1)) SWIG_fail;
5985 {
5986 arg2 = &temp2;
5987 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5988 }
5989 {
5990 PyThreadState* __tstate = wxPyBeginAllowThreads();
5991 (arg1)->Offset((wxPoint const &)*arg2);
5992
5993 wxPyEndAllowThreads(__tstate);
5994 if (PyErr_Occurred()) SWIG_fail;
5995 }
5996 Py_INCREF(Py_None); resultobj = Py_None;
5997 return resultobj;
5998 fail:
5999 return NULL;
6000 }
6001
6002
6003 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6004 PyObject *resultobj = NULL;
6005 wxRect *arg1 = (wxRect *) 0 ;
6006 wxRect *arg2 = 0 ;
6007 wxRect result;
6008 wxRect temp2 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 char *kwnames[] = {
6012 (char *) "self",(char *) "rect", NULL
6013 };
6014
6015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6017 if (SWIG_arg_fail(1)) SWIG_fail;
6018 {
6019 arg2 = &temp2;
6020 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6021 }
6022 {
6023 PyThreadState* __tstate = wxPyBeginAllowThreads();
6024 result = (arg1)->Intersect((wxRect const &)*arg2);
6025
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 {
6030 wxRect * resultptr;
6031 resultptr = new wxRect(static_cast<wxRect & >(result));
6032 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6033 }
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj = NULL;
6042 wxRect *arg1 = (wxRect *) 0 ;
6043 wxRect *arg2 = 0 ;
6044 wxRect result;
6045 wxRect temp2 ;
6046 PyObject * obj0 = 0 ;
6047 PyObject * obj1 = 0 ;
6048 char *kwnames[] = {
6049 (char *) "self",(char *) "rect", NULL
6050 };
6051
6052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6054 if (SWIG_arg_fail(1)) SWIG_fail;
6055 {
6056 arg2 = &temp2;
6057 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (arg1)->Union((wxRect const &)*arg2);
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 {
6067 wxRect * resultptr;
6068 resultptr = new wxRect(static_cast<wxRect & >(result));
6069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6070 }
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj = NULL;
6079 wxRect *arg1 = (wxRect *) 0 ;
6080 wxRect *arg2 = 0 ;
6081 wxRect result;
6082 wxRect temp2 ;
6083 PyObject * obj0 = 0 ;
6084 PyObject * obj1 = 0 ;
6085 char *kwnames[] = {
6086 (char *) "self",(char *) "rect", NULL
6087 };
6088
6089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6091 if (SWIG_arg_fail(1)) SWIG_fail;
6092 {
6093 arg2 = &temp2;
6094 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6095 }
6096 {
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6099
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 {
6104 wxRect * resultptr;
6105 resultptr = new wxRect(static_cast<wxRect & >(result));
6106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6107 }
6108 return resultobj;
6109 fail:
6110 return NULL;
6111 }
6112
6113
6114 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6115 PyObject *resultobj = NULL;
6116 wxRect *arg1 = (wxRect *) 0 ;
6117 wxRect *arg2 = 0 ;
6118 wxRect *result;
6119 wxRect temp2 ;
6120 PyObject * obj0 = 0 ;
6121 PyObject * obj1 = 0 ;
6122 char *kwnames[] = {
6123 (char *) "self",(char *) "rect", NULL
6124 };
6125
6126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6128 if (SWIG_arg_fail(1)) SWIG_fail;
6129 {
6130 arg2 = &temp2;
6131 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6132 }
6133 {
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 {
6136 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6137 result = (wxRect *) &_result_ref;
6138 }
6139
6140 wxPyEndAllowThreads(__tstate);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6151 PyObject *resultobj = NULL;
6152 wxRect *arg1 = (wxRect *) 0 ;
6153 wxRect *arg2 = 0 ;
6154 bool result;
6155 wxRect temp2 ;
6156 PyObject * obj0 = 0 ;
6157 PyObject * obj1 = 0 ;
6158 char *kwnames[] = {
6159 (char *) "self",(char *) "rect", NULL
6160 };
6161
6162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6164 if (SWIG_arg_fail(1)) SWIG_fail;
6165 {
6166 arg2 = &temp2;
6167 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6168 }
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 {
6177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6178 }
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj = NULL;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 wxRect *arg2 = 0 ;
6189 bool result;
6190 wxRect temp2 ;
6191 PyObject * obj0 = 0 ;
6192 PyObject * obj1 = 0 ;
6193 char *kwnames[] = {
6194 (char *) "self",(char *) "rect", NULL
6195 };
6196
6197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6199 if (SWIG_arg_fail(1)) SWIG_fail;
6200 {
6201 arg2 = &temp2;
6202 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6203 }
6204 {
6205 PyThreadState* __tstate = wxPyBeginAllowThreads();
6206 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6207
6208 wxPyEndAllowThreads(__tstate);
6209 if (PyErr_Occurred()) SWIG_fail;
6210 }
6211 {
6212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6213 }
6214 return resultobj;
6215 fail:
6216 return NULL;
6217 }
6218
6219
6220 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6221 PyObject *resultobj = NULL;
6222 wxRect *arg1 = (wxRect *) 0 ;
6223 int arg2 ;
6224 int arg3 ;
6225 bool result;
6226 PyObject * obj0 = 0 ;
6227 PyObject * obj1 = 0 ;
6228 PyObject * obj2 = 0 ;
6229 char *kwnames[] = {
6230 (char *) "self",(char *) "x",(char *) "y", NULL
6231 };
6232
6233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6235 if (SWIG_arg_fail(1)) SWIG_fail;
6236 {
6237 arg2 = static_cast<int >(SWIG_As_int(obj1));
6238 if (SWIG_arg_fail(2)) SWIG_fail;
6239 }
6240 {
6241 arg3 = static_cast<int >(SWIG_As_int(obj2));
6242 if (SWIG_arg_fail(3)) SWIG_fail;
6243 }
6244 {
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 {
6252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6253 }
6254 return resultobj;
6255 fail:
6256 return NULL;
6257 }
6258
6259
6260 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6261 PyObject *resultobj = NULL;
6262 wxRect *arg1 = (wxRect *) 0 ;
6263 wxPoint *arg2 = 0 ;
6264 bool result;
6265 wxPoint temp2 ;
6266 PyObject * obj0 = 0 ;
6267 PyObject * obj1 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "self",(char *) "pt", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6274 if (SWIG_arg_fail(1)) SWIG_fail;
6275 {
6276 arg2 = &temp2;
6277 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6278 }
6279 {
6280 PyThreadState* __tstate = wxPyBeginAllowThreads();
6281 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6282
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 {
6287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6288 }
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj = NULL;
6297 wxRect *arg1 = (wxRect *) 0 ;
6298 wxRect *arg2 = 0 ;
6299 bool result;
6300 wxRect temp2 ;
6301 PyObject * obj0 = 0 ;
6302 PyObject * obj1 = 0 ;
6303 char *kwnames[] = {
6304 (char *) "self",(char *) "rect", NULL
6305 };
6306
6307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6309 if (SWIG_arg_fail(1)) SWIG_fail;
6310 {
6311 arg2 = &temp2;
6312 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6313 }
6314 {
6315 PyThreadState* __tstate = wxPyBeginAllowThreads();
6316 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6317
6318 wxPyEndAllowThreads(__tstate);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 {
6322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6323 }
6324 return resultobj;
6325 fail:
6326 return NULL;
6327 }
6328
6329
6330 static PyObject *_wrap_Rect_CenterIn(PyObject *, PyObject *args, PyObject *kwargs) {
6331 PyObject *resultobj = NULL;
6332 wxRect *arg1 = (wxRect *) 0 ;
6333 wxRect *arg2 = 0 ;
6334 int arg3 = (int) wxBOTH ;
6335 wxRect result;
6336 wxRect temp2 ;
6337 PyObject * obj0 = 0 ;
6338 PyObject * obj1 = 0 ;
6339 PyObject * obj2 = 0 ;
6340 char *kwnames[] = {
6341 (char *) "self",(char *) "r",(char *) "dir", NULL
6342 };
6343
6344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) goto fail;
6345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6346 if (SWIG_arg_fail(1)) SWIG_fail;
6347 {
6348 arg2 = &temp2;
6349 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6350 }
6351 if (obj2) {
6352 {
6353 arg3 = static_cast<int >(SWIG_As_int(obj2));
6354 if (SWIG_arg_fail(3)) SWIG_fail;
6355 }
6356 }
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
6360
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 {
6365 wxRect * resultptr;
6366 resultptr = new wxRect(static_cast<wxRect & >(result));
6367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6368 }
6369 return resultobj;
6370 fail:
6371 return NULL;
6372 }
6373
6374
6375 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6376 PyObject *resultobj = NULL;
6377 wxRect *arg1 = (wxRect *) 0 ;
6378 int arg2 ;
6379 PyObject * obj0 = 0 ;
6380 PyObject * obj1 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self",(char *) "x", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 {
6389 arg2 = static_cast<int >(SWIG_As_int(obj1));
6390 if (SWIG_arg_fail(2)) SWIG_fail;
6391 }
6392 if (arg1) (arg1)->x = arg2;
6393
6394 Py_INCREF(Py_None); resultobj = Py_None;
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = NULL;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 int result;
6405 PyObject * obj0 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "self", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 result = (int) ((arg1)->x);
6414
6415 {
6416 resultobj = SWIG_From_int(static_cast<int >(result));
6417 }
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj = NULL;
6426 wxRect *arg1 = (wxRect *) 0 ;
6427 int arg2 ;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 char *kwnames[] = {
6431 (char *) "self",(char *) "y", NULL
6432 };
6433
6434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6436 if (SWIG_arg_fail(1)) SWIG_fail;
6437 {
6438 arg2 = static_cast<int >(SWIG_As_int(obj1));
6439 if (SWIG_arg_fail(2)) SWIG_fail;
6440 }
6441 if (arg1) (arg1)->y = arg2;
6442
6443 Py_INCREF(Py_None); resultobj = Py_None;
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6451 PyObject *resultobj = NULL;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 int result;
6454 PyObject * obj0 = 0 ;
6455 char *kwnames[] = {
6456 (char *) "self", NULL
6457 };
6458
6459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6461 if (SWIG_arg_fail(1)) SWIG_fail;
6462 result = (int) ((arg1)->y);
6463
6464 {
6465 resultobj = SWIG_From_int(static_cast<int >(result));
6466 }
6467 return resultobj;
6468 fail:
6469 return NULL;
6470 }
6471
6472
6473 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6474 PyObject *resultobj = NULL;
6475 wxRect *arg1 = (wxRect *) 0 ;
6476 int arg2 ;
6477 PyObject * obj0 = 0 ;
6478 PyObject * obj1 = 0 ;
6479 char *kwnames[] = {
6480 (char *) "self",(char *) "width", NULL
6481 };
6482
6483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6485 if (SWIG_arg_fail(1)) SWIG_fail;
6486 {
6487 arg2 = static_cast<int >(SWIG_As_int(obj1));
6488 if (SWIG_arg_fail(2)) SWIG_fail;
6489 }
6490 if (arg1) (arg1)->width = arg2;
6491
6492 Py_INCREF(Py_None); resultobj = Py_None;
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj = NULL;
6501 wxRect *arg1 = (wxRect *) 0 ;
6502 int result;
6503 PyObject * obj0 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "self", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6510 if (SWIG_arg_fail(1)) SWIG_fail;
6511 result = (int) ((arg1)->width);
6512
6513 {
6514 resultobj = SWIG_From_int(static_cast<int >(result));
6515 }
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6523 PyObject *resultobj = NULL;
6524 wxRect *arg1 = (wxRect *) 0 ;
6525 int arg2 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 char *kwnames[] = {
6529 (char *) "self",(char *) "height", NULL
6530 };
6531
6532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6534 if (SWIG_arg_fail(1)) SWIG_fail;
6535 {
6536 arg2 = static_cast<int >(SWIG_As_int(obj1));
6537 if (SWIG_arg_fail(2)) SWIG_fail;
6538 }
6539 if (arg1) (arg1)->height = arg2;
6540
6541 Py_INCREF(Py_None); resultobj = Py_None;
6542 return resultobj;
6543 fail:
6544 return NULL;
6545 }
6546
6547
6548 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj = NULL;
6550 wxRect *arg1 = (wxRect *) 0 ;
6551 int result;
6552 PyObject * obj0 = 0 ;
6553 char *kwnames[] = {
6554 (char *) "self", NULL
6555 };
6556
6557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6559 if (SWIG_arg_fail(1)) SWIG_fail;
6560 result = (int) ((arg1)->height);
6561
6562 {
6563 resultobj = SWIG_From_int(static_cast<int >(result));
6564 }
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj = NULL;
6573 wxRect *arg1 = (wxRect *) 0 ;
6574 int arg2 = (int) 0 ;
6575 int arg3 = (int) 0 ;
6576 int arg4 = (int) 0 ;
6577 int arg5 = (int) 0 ;
6578 PyObject * obj0 = 0 ;
6579 PyObject * obj1 = 0 ;
6580 PyObject * obj2 = 0 ;
6581 PyObject * obj3 = 0 ;
6582 PyObject * obj4 = 0 ;
6583 char *kwnames[] = {
6584 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6585 };
6586
6587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 if (obj1) {
6591 {
6592 arg2 = static_cast<int >(SWIG_As_int(obj1));
6593 if (SWIG_arg_fail(2)) SWIG_fail;
6594 }
6595 }
6596 if (obj2) {
6597 {
6598 arg3 = static_cast<int >(SWIG_As_int(obj2));
6599 if (SWIG_arg_fail(3)) SWIG_fail;
6600 }
6601 }
6602 if (obj3) {
6603 {
6604 arg4 = static_cast<int >(SWIG_As_int(obj3));
6605 if (SWIG_arg_fail(4)) SWIG_fail;
6606 }
6607 }
6608 if (obj4) {
6609 {
6610 arg5 = static_cast<int >(SWIG_As_int(obj4));
6611 if (SWIG_arg_fail(5)) SWIG_fail;
6612 }
6613 }
6614 {
6615 PyThreadState* __tstate = wxPyBeginAllowThreads();
6616 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6617
6618 wxPyEndAllowThreads(__tstate);
6619 if (PyErr_Occurred()) SWIG_fail;
6620 }
6621 Py_INCREF(Py_None); resultobj = Py_None;
6622 return resultobj;
6623 fail:
6624 return NULL;
6625 }
6626
6627
6628 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6629 PyObject *resultobj = NULL;
6630 wxRect *arg1 = (wxRect *) 0 ;
6631 PyObject *result;
6632 PyObject * obj0 = 0 ;
6633 char *kwnames[] = {
6634 (char *) "self", NULL
6635 };
6636
6637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6639 if (SWIG_arg_fail(1)) SWIG_fail;
6640 {
6641 PyThreadState* __tstate = wxPyBeginAllowThreads();
6642 result = (PyObject *)wxRect_Get(arg1);
6643
6644 wxPyEndAllowThreads(__tstate);
6645 if (PyErr_Occurred()) SWIG_fail;
6646 }
6647 resultobj = result;
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6655 PyObject *obj;
6656 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6657 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6658 Py_INCREF(obj);
6659 return Py_BuildValue((char *)"");
6660 }
6661 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj = NULL;
6663 wxRect *arg1 = (wxRect *) 0 ;
6664 wxRect *arg2 = (wxRect *) 0 ;
6665 PyObject *result;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 char *kwnames[] = {
6669 (char *) "r1",(char *) "r2", NULL
6670 };
6671
6672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(1)) SWIG_fail;
6675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6676 if (SWIG_arg_fail(2)) SWIG_fail;
6677 {
6678 if (!wxPyCheckForApp()) SWIG_fail;
6679 PyThreadState* __tstate = wxPyBeginAllowThreads();
6680 result = (PyObject *)wxIntersectRect(arg1,arg2);
6681
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 resultobj = result;
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj = NULL;
6694 double arg1 = (double) 0.0 ;
6695 double arg2 = (double) 0.0 ;
6696 wxPoint2D *result;
6697 PyObject * obj0 = 0 ;
6698 PyObject * obj1 = 0 ;
6699 char *kwnames[] = {
6700 (char *) "x",(char *) "y", NULL
6701 };
6702
6703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6704 if (obj0) {
6705 {
6706 arg1 = static_cast<double >(SWIG_As_double(obj0));
6707 if (SWIG_arg_fail(1)) SWIG_fail;
6708 }
6709 }
6710 if (obj1) {
6711 {
6712 arg2 = static_cast<double >(SWIG_As_double(obj1));
6713 if (SWIG_arg_fail(2)) SWIG_fail;
6714 }
6715 }
6716 {
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6719
6720 wxPyEndAllowThreads(__tstate);
6721 if (PyErr_Occurred()) SWIG_fail;
6722 }
6723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6724 return resultobj;
6725 fail:
6726 return NULL;
6727 }
6728
6729
6730 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6731 PyObject *resultobj = NULL;
6732 wxPoint2D *arg1 = 0 ;
6733 wxPoint2D *result;
6734 wxPoint2D temp1 ;
6735 PyObject * obj0 = 0 ;
6736 char *kwnames[] = {
6737 (char *) "pt", NULL
6738 };
6739
6740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6741 {
6742 arg1 = &temp1;
6743 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6744 }
6745 {
6746 PyThreadState* __tstate = wxPyBeginAllowThreads();
6747 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6748
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6760 PyObject *resultobj = NULL;
6761 wxPoint *arg1 = 0 ;
6762 wxPoint2D *result;
6763 wxPoint temp1 ;
6764 PyObject * obj0 = 0 ;
6765 char *kwnames[] = {
6766 (char *) "pt", NULL
6767 };
6768
6769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6770 {
6771 arg1 = &temp1;
6772 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6773 }
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6777
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj = NULL;
6790 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6791 int *arg2 = (int *) 0 ;
6792 int *arg3 = (int *) 0 ;
6793 int temp2 ;
6794 int res2 = 0 ;
6795 int temp3 ;
6796 int res3 = 0 ;
6797 PyObject * obj0 = 0 ;
6798 char *kwnames[] = {
6799 (char *) "self", NULL
6800 };
6801
6802 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6803 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6806 if (SWIG_arg_fail(1)) SWIG_fail;
6807 {
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6810
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 Py_INCREF(Py_None); resultobj = Py_None;
6815 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6816 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6817 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6818 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6826 PyObject *resultobj = NULL;
6827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6828 int *arg2 = (int *) 0 ;
6829 int *arg3 = (int *) 0 ;
6830 int temp2 ;
6831 int res2 = 0 ;
6832 int temp3 ;
6833 int res3 = 0 ;
6834 PyObject * obj0 = 0 ;
6835 char *kwnames[] = {
6836 (char *) "self", NULL
6837 };
6838
6839 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6840 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6843 if (SWIG_arg_fail(1)) SWIG_fail;
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6847
6848 wxPyEndAllowThreads(__tstate);
6849 if (PyErr_Occurred()) SWIG_fail;
6850 }
6851 Py_INCREF(Py_None); resultobj = Py_None;
6852 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6853 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6854 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6855 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj = NULL;
6864 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6865 double result;
6866 PyObject * obj0 = 0 ;
6867 char *kwnames[] = {
6868 (char *) "self", NULL
6869 };
6870
6871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6873 if (SWIG_arg_fail(1)) SWIG_fail;
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6877
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 {
6882 resultobj = SWIG_From_double(static_cast<double >(result));
6883 }
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6891 PyObject *resultobj = NULL;
6892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6893 double result;
6894 PyObject * obj0 = 0 ;
6895 char *kwnames[] = {
6896 (char *) "self", NULL
6897 };
6898
6899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6901 if (SWIG_arg_fail(1)) SWIG_fail;
6902 {
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6905
6906 wxPyEndAllowThreads(__tstate);
6907 if (PyErr_Occurred()) SWIG_fail;
6908 }
6909 {
6910 resultobj = SWIG_From_double(static_cast<double >(result));
6911 }
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6919 PyObject *resultobj = NULL;
6920 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6921 double arg2 ;
6922 PyObject * obj0 = 0 ;
6923 PyObject * obj1 = 0 ;
6924 char *kwnames[] = {
6925 (char *) "self",(char *) "length", NULL
6926 };
6927
6928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6930 if (SWIG_arg_fail(1)) SWIG_fail;
6931 {
6932 arg2 = static_cast<double >(SWIG_As_double(obj1));
6933 if (SWIG_arg_fail(2)) SWIG_fail;
6934 }
6935 {
6936 PyThreadState* __tstate = wxPyBeginAllowThreads();
6937 (arg1)->SetVectorLength(arg2);
6938
6939 wxPyEndAllowThreads(__tstate);
6940 if (PyErr_Occurred()) SWIG_fail;
6941 }
6942 Py_INCREF(Py_None); resultobj = Py_None;
6943 return resultobj;
6944 fail:
6945 return NULL;
6946 }
6947
6948
6949 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj = NULL;
6951 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6952 double arg2 ;
6953 PyObject * obj0 = 0 ;
6954 PyObject * obj1 = 0 ;
6955 char *kwnames[] = {
6956 (char *) "self",(char *) "degrees", NULL
6957 };
6958
6959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6961 if (SWIG_arg_fail(1)) SWIG_fail;
6962 {
6963 arg2 = static_cast<double >(SWIG_As_double(obj1));
6964 if (SWIG_arg_fail(2)) SWIG_fail;
6965 }
6966 {
6967 PyThreadState* __tstate = wxPyBeginAllowThreads();
6968 (arg1)->SetVectorAngle(arg2);
6969
6970 wxPyEndAllowThreads(__tstate);
6971 if (PyErr_Occurred()) SWIG_fail;
6972 }
6973 Py_INCREF(Py_None); resultobj = Py_None;
6974 return resultobj;
6975 fail:
6976 return NULL;
6977 }
6978
6979
6980 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6981 PyObject *resultobj = NULL;
6982 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6983 wxPoint2D *arg2 = 0 ;
6984 double result;
6985 wxPoint2D temp2 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char *kwnames[] = {
6989 (char *) "self",(char *) "pt", NULL
6990 };
6991
6992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6994 if (SWIG_arg_fail(1)) SWIG_fail;
6995 {
6996 arg2 = &temp2;
6997 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6998 }
6999 {
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
7002
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 {
7007 resultobj = SWIG_From_double(static_cast<double >(result));
7008 }
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = NULL;
7017 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7018 wxPoint2D *arg2 = 0 ;
7019 double result;
7020 wxPoint2D temp2 ;
7021 PyObject * obj0 = 0 ;
7022 PyObject * obj1 = 0 ;
7023 char *kwnames[] = {
7024 (char *) "self",(char *) "pt", NULL
7025 };
7026
7027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
7028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7029 if (SWIG_arg_fail(1)) SWIG_fail;
7030 {
7031 arg2 = &temp2;
7032 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7033 }
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 {
7042 resultobj = SWIG_From_double(static_cast<double >(result));
7043 }
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj = NULL;
7052 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7053 wxPoint2D *arg2 = 0 ;
7054 double result;
7055 wxPoint2D temp2 ;
7056 PyObject * obj0 = 0 ;
7057 PyObject * obj1 = 0 ;
7058 char *kwnames[] = {
7059 (char *) "self",(char *) "vec", NULL
7060 };
7061
7062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7064 if (SWIG_arg_fail(1)) SWIG_fail;
7065 {
7066 arg2 = &temp2;
7067 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7068 }
7069 {
7070 PyThreadState* __tstate = wxPyBeginAllowThreads();
7071 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7072
7073 wxPyEndAllowThreads(__tstate);
7074 if (PyErr_Occurred()) SWIG_fail;
7075 }
7076 {
7077 resultobj = SWIG_From_double(static_cast<double >(result));
7078 }
7079 return resultobj;
7080 fail:
7081 return NULL;
7082 }
7083
7084
7085 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7086 PyObject *resultobj = NULL;
7087 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7088 wxPoint2D *arg2 = 0 ;
7089 double result;
7090 wxPoint2D temp2 ;
7091 PyObject * obj0 = 0 ;
7092 PyObject * obj1 = 0 ;
7093 char *kwnames[] = {
7094 (char *) "self",(char *) "vec", NULL
7095 };
7096
7097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7099 if (SWIG_arg_fail(1)) SWIG_fail;
7100 {
7101 arg2 = &temp2;
7102 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7103 }
7104 {
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7107
7108 wxPyEndAllowThreads(__tstate);
7109 if (PyErr_Occurred()) SWIG_fail;
7110 }
7111 {
7112 resultobj = SWIG_From_double(static_cast<double >(result));
7113 }
7114 return resultobj;
7115 fail:
7116 return NULL;
7117 }
7118
7119
7120 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7121 PyObject *resultobj = NULL;
7122 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7123 wxPoint2D result;
7124 PyObject * obj0 = 0 ;
7125 char *kwnames[] = {
7126 (char *) "self", NULL
7127 };
7128
7129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7131 if (SWIG_arg_fail(1)) SWIG_fail;
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 result = (arg1)->operator -();
7135
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 {
7140 wxPoint2D * resultptr;
7141 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7143 }
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7151 PyObject *resultobj = NULL;
7152 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7153 wxPoint2D *arg2 = 0 ;
7154 wxPoint2D *result;
7155 wxPoint2D temp2 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char *kwnames[] = {
7159 (char *) "self",(char *) "pt", NULL
7160 };
7161
7162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7164 if (SWIG_arg_fail(1)) SWIG_fail;
7165 {
7166 arg2 = &temp2;
7167 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7168 }
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 {
7172 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7173 result = (wxPoint2D *) &_result_ref;
7174 }
7175
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj = NULL;
7188 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7189 wxPoint2D *arg2 = 0 ;
7190 wxPoint2D *result;
7191 wxPoint2D temp2 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 char *kwnames[] = {
7195 (char *) "self",(char *) "pt", NULL
7196 };
7197
7198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7200 if (SWIG_arg_fail(1)) SWIG_fail;
7201 {
7202 arg2 = &temp2;
7203 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7204 }
7205 {
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 {
7208 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7209 result = (wxPoint2D *) &_result_ref;
7210 }
7211
7212 wxPyEndAllowThreads(__tstate);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = NULL;
7224 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7225 wxPoint2D *arg2 = 0 ;
7226 wxPoint2D *result;
7227 wxPoint2D temp2 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self",(char *) "pt", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 {
7238 arg2 = &temp2;
7239 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7240 }
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 {
7244 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7245 result = (wxPoint2D *) &_result_ref;
7246 }
7247
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj = NULL;
7260 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7261 wxPoint2D *arg2 = 0 ;
7262 wxPoint2D *result;
7263 wxPoint2D temp2 ;
7264 PyObject * obj0 = 0 ;
7265 PyObject * obj1 = 0 ;
7266 char *kwnames[] = {
7267 (char *) "self",(char *) "pt", NULL
7268 };
7269
7270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7272 if (SWIG_arg_fail(1)) SWIG_fail;
7273 {
7274 arg2 = &temp2;
7275 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7276 }
7277 {
7278 PyThreadState* __tstate = wxPyBeginAllowThreads();
7279 {
7280 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7281 result = (wxPoint2D *) &_result_ref;
7282 }
7283
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = NULL;
7296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7297 wxPoint2D *arg2 = 0 ;
7298 bool result;
7299 wxPoint2D temp2 ;
7300 PyObject * obj0 = 0 ;
7301 PyObject * obj1 = 0 ;
7302 char *kwnames[] = {
7303 (char *) "self",(char *) "pt", NULL
7304 };
7305
7306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7308 if (SWIG_arg_fail(1)) SWIG_fail;
7309 {
7310 arg2 = &temp2;
7311 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7312 }
7313 {
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7316
7317 wxPyEndAllowThreads(__tstate);
7318 if (PyErr_Occurred()) SWIG_fail;
7319 }
7320 {
7321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7322 }
7323 return resultobj;
7324 fail:
7325 return NULL;
7326 }
7327
7328
7329 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7330 PyObject *resultobj = NULL;
7331 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7332 wxPoint2D *arg2 = 0 ;
7333 bool result;
7334 wxPoint2D temp2 ;
7335 PyObject * obj0 = 0 ;
7336 PyObject * obj1 = 0 ;
7337 char *kwnames[] = {
7338 (char *) "self",(char *) "pt", NULL
7339 };
7340
7341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7343 if (SWIG_arg_fail(1)) SWIG_fail;
7344 {
7345 arg2 = &temp2;
7346 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7347 }
7348 {
7349 PyThreadState* __tstate = wxPyBeginAllowThreads();
7350 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7351
7352 wxPyEndAllowThreads(__tstate);
7353 if (PyErr_Occurred()) SWIG_fail;
7354 }
7355 {
7356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7357 }
7358 return resultobj;
7359 fail:
7360 return NULL;
7361 }
7362
7363
7364 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7365 PyObject *resultobj = NULL;
7366 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7367 double arg2 ;
7368 PyObject * obj0 = 0 ;
7369 PyObject * obj1 = 0 ;
7370 char *kwnames[] = {
7371 (char *) "self",(char *) "m_x", NULL
7372 };
7373
7374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7376 if (SWIG_arg_fail(1)) SWIG_fail;
7377 {
7378 arg2 = static_cast<double >(SWIG_As_double(obj1));
7379 if (SWIG_arg_fail(2)) SWIG_fail;
7380 }
7381 if (arg1) (arg1)->m_x = arg2;
7382
7383 Py_INCREF(Py_None); resultobj = Py_None;
7384 return resultobj;
7385 fail:
7386 return NULL;
7387 }
7388
7389
7390 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7391 PyObject *resultobj = NULL;
7392 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7393 double result;
7394 PyObject * obj0 = 0 ;
7395 char *kwnames[] = {
7396 (char *) "self", NULL
7397 };
7398
7399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7401 if (SWIG_arg_fail(1)) SWIG_fail;
7402 result = (double) ((arg1)->m_x);
7403
7404 {
7405 resultobj = SWIG_From_double(static_cast<double >(result));
7406 }
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj = NULL;
7415 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7416 double arg2 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char *kwnames[] = {
7420 (char *) "self",(char *) "m_y", NULL
7421 };
7422
7423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(1)) SWIG_fail;
7426 {
7427 arg2 = static_cast<double >(SWIG_As_double(obj1));
7428 if (SWIG_arg_fail(2)) SWIG_fail;
7429 }
7430 if (arg1) (arg1)->m_y = arg2;
7431
7432 Py_INCREF(Py_None); resultobj = Py_None;
7433 return resultobj;
7434 fail:
7435 return NULL;
7436 }
7437
7438
7439 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7440 PyObject *resultobj = NULL;
7441 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7442 double result;
7443 PyObject * obj0 = 0 ;
7444 char *kwnames[] = {
7445 (char *) "self", NULL
7446 };
7447
7448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7450 if (SWIG_arg_fail(1)) SWIG_fail;
7451 result = (double) ((arg1)->m_y);
7452
7453 {
7454 resultobj = SWIG_From_double(static_cast<double >(result));
7455 }
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj = NULL;
7464 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7465 double arg2 = (double) 0 ;
7466 double arg3 = (double) 0 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 PyObject * obj2 = 0 ;
7470 char *kwnames[] = {
7471 (char *) "self",(char *) "x",(char *) "y", NULL
7472 };
7473
7474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7476 if (SWIG_arg_fail(1)) SWIG_fail;
7477 if (obj1) {
7478 {
7479 arg2 = static_cast<double >(SWIG_As_double(obj1));
7480 if (SWIG_arg_fail(2)) SWIG_fail;
7481 }
7482 }
7483 if (obj2) {
7484 {
7485 arg3 = static_cast<double >(SWIG_As_double(obj2));
7486 if (SWIG_arg_fail(3)) SWIG_fail;
7487 }
7488 }
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 wxPoint2D_Set(arg1,arg2,arg3);
7492
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 Py_INCREF(Py_None); resultobj = Py_None;
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj = NULL;
7505 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7506 PyObject *result;
7507 PyObject * obj0 = 0 ;
7508 char *kwnames[] = {
7509 (char *) "self", NULL
7510 };
7511
7512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7514 if (SWIG_arg_fail(1)) SWIG_fail;
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 result = (PyObject *)wxPoint2D_Get(arg1);
7518
7519 wxPyEndAllowThreads(__tstate);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 resultobj = result;
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7530 PyObject *obj;
7531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7532 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7533 Py_INCREF(obj);
7534 return Py_BuildValue((char *)"");
7535 }
7536 static int _wrap_DefaultPosition_set(PyObject *) {
7537 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7538 return 1;
7539 }
7540
7541
7542 static PyObject *_wrap_DefaultPosition_get(void) {
7543 PyObject *pyobj = NULL;
7544
7545 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7546 return pyobj;
7547 }
7548
7549
7550 static int _wrap_DefaultSize_set(PyObject *) {
7551 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7552 return 1;
7553 }
7554
7555
7556 static PyObject *_wrap_DefaultSize_get(void) {
7557 PyObject *pyobj = NULL;
7558
7559 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7560 return pyobj;
7561 }
7562
7563
7564 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj = NULL;
7566 PyObject *arg1 = (PyObject *) 0 ;
7567 wxPyInputStream *result;
7568 PyObject * obj0 = 0 ;
7569 char *kwnames[] = {
7570 (char *) "p", NULL
7571 };
7572
7573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7574 arg1 = obj0;
7575 {
7576 PyThreadState* __tstate = wxPyBeginAllowThreads();
7577 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7578
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_delete_InputStream(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:delete_InputStream",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 delete arg1;
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_close(PyObject *, PyObject *args, PyObject *kwargs) {
7615 PyObject *resultobj = NULL;
7616 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7617 PyObject * obj0 = 0 ;
7618 char *kwnames[] = {
7619 (char *) "self", NULL
7620 };
7621
7622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7624 if (SWIG_arg_fail(1)) SWIG_fail;
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 (arg1)->close();
7628
7629 wxPyEndAllowThreads(__tstate);
7630 if (PyErr_Occurred()) SWIG_fail;
7631 }
7632 Py_INCREF(Py_None); resultobj = Py_None;
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
7639 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj = NULL;
7641 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7642 PyObject * obj0 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "self", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(1)) SWIG_fail;
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 (arg1)->flush();
7653
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 Py_INCREF(Py_None); resultobj = Py_None;
7658 return resultobj;
7659 fail:
7660 return NULL;
7661 }
7662
7663
7664 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7665 PyObject *resultobj = NULL;
7666 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7667 bool result;
7668 PyObject * obj0 = 0 ;
7669 char *kwnames[] = {
7670 (char *) "self", NULL
7671 };
7672
7673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7675 if (SWIG_arg_fail(1)) SWIG_fail;
7676 {
7677 PyThreadState* __tstate = wxPyBeginAllowThreads();
7678 result = (bool)(arg1)->eof();
7679
7680 wxPyEndAllowThreads(__tstate);
7681 if (PyErr_Occurred()) SWIG_fail;
7682 }
7683 {
7684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7685 }
7686 return resultobj;
7687 fail:
7688 return NULL;
7689 }
7690
7691
7692 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7693 PyObject *resultobj = NULL;
7694 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7695 int arg2 = (int) -1 ;
7696 PyObject *result;
7697 PyObject * obj0 = 0 ;
7698 PyObject * obj1 = 0 ;
7699 char *kwnames[] = {
7700 (char *) "self",(char *) "size", NULL
7701 };
7702
7703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7705 if (SWIG_arg_fail(1)) SWIG_fail;
7706 if (obj1) {
7707 {
7708 arg2 = static_cast<int >(SWIG_As_int(obj1));
7709 if (SWIG_arg_fail(2)) SWIG_fail;
7710 }
7711 }
7712 {
7713 PyThreadState* __tstate = wxPyBeginAllowThreads();
7714 result = (PyObject *)(arg1)->read(arg2);
7715
7716 wxPyEndAllowThreads(__tstate);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 resultobj = result;
7720 return resultobj;
7721 fail:
7722 return NULL;
7723 }
7724
7725
7726 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7727 PyObject *resultobj = NULL;
7728 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7729 int arg2 = (int) -1 ;
7730 PyObject *result;
7731 PyObject * obj0 = 0 ;
7732 PyObject * obj1 = 0 ;
7733 char *kwnames[] = {
7734 (char *) "self",(char *) "size", NULL
7735 };
7736
7737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7739 if (SWIG_arg_fail(1)) SWIG_fail;
7740 if (obj1) {
7741 {
7742 arg2 = static_cast<int >(SWIG_As_int(obj1));
7743 if (SWIG_arg_fail(2)) SWIG_fail;
7744 }
7745 }
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (PyObject *)(arg1)->readline(arg2);
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 resultobj = result;
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj = NULL;
7762 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7763 int arg2 = (int) -1 ;
7764 PyObject *result;
7765 PyObject * obj0 = 0 ;
7766 PyObject * obj1 = 0 ;
7767 char *kwnames[] = {
7768 (char *) "self",(char *) "sizehint", NULL
7769 };
7770
7771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7773 if (SWIG_arg_fail(1)) SWIG_fail;
7774 if (obj1) {
7775 {
7776 arg2 = static_cast<int >(SWIG_As_int(obj1));
7777 if (SWIG_arg_fail(2)) SWIG_fail;
7778 }
7779 }
7780 {
7781 PyThreadState* __tstate = wxPyBeginAllowThreads();
7782 result = (PyObject *)(arg1)->readlines(arg2);
7783
7784 wxPyEndAllowThreads(__tstate);
7785 if (PyErr_Occurred()) SWIG_fail;
7786 }
7787 resultobj = result;
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
7794 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7795 PyObject *resultobj = NULL;
7796 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7797 int arg2 ;
7798 int arg3 = (int) 0 ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 PyObject * obj2 = 0 ;
7802 char *kwnames[] = {
7803 (char *) "self",(char *) "offset",(char *) "whence", NULL
7804 };
7805
7806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7808 if (SWIG_arg_fail(1)) SWIG_fail;
7809 {
7810 arg2 = static_cast<int >(SWIG_As_int(obj1));
7811 if (SWIG_arg_fail(2)) SWIG_fail;
7812 }
7813 if (obj2) {
7814 {
7815 arg3 = static_cast<int >(SWIG_As_int(obj2));
7816 if (SWIG_arg_fail(3)) SWIG_fail;
7817 }
7818 }
7819 {
7820 PyThreadState* __tstate = wxPyBeginAllowThreads();
7821 (arg1)->seek(arg2,arg3);
7822
7823 wxPyEndAllowThreads(__tstate);
7824 if (PyErr_Occurred()) SWIG_fail;
7825 }
7826 Py_INCREF(Py_None); resultobj = Py_None;
7827 return resultobj;
7828 fail:
7829 return NULL;
7830 }
7831
7832
7833 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7834 PyObject *resultobj = NULL;
7835 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7836 int result;
7837 PyObject * obj0 = 0 ;
7838 char *kwnames[] = {
7839 (char *) "self", NULL
7840 };
7841
7842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7844 if (SWIG_arg_fail(1)) SWIG_fail;
7845 {
7846 PyThreadState* __tstate = wxPyBeginAllowThreads();
7847 result = (int)(arg1)->tell();
7848
7849 wxPyEndAllowThreads(__tstate);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 {
7853 resultobj = SWIG_From_int(static_cast<int >(result));
7854 }
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj = NULL;
7863 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7864 char result;
7865 PyObject * obj0 = 0 ;
7866 char *kwnames[] = {
7867 (char *) "self", NULL
7868 };
7869
7870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7872 if (SWIG_arg_fail(1)) SWIG_fail;
7873 {
7874 PyThreadState* __tstate = wxPyBeginAllowThreads();
7875 result = (char)(arg1)->Peek();
7876
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 {
7881 resultobj = SWIG_From_char(static_cast<char >(result));
7882 }
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7890 PyObject *resultobj = NULL;
7891 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7892 char result;
7893 PyObject * obj0 = 0 ;
7894 char *kwnames[] = {
7895 (char *) "self", NULL
7896 };
7897
7898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7900 if (SWIG_arg_fail(1)) SWIG_fail;
7901 {
7902 PyThreadState* __tstate = wxPyBeginAllowThreads();
7903 result = (char)(arg1)->GetC();
7904
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 {
7909 resultobj = SWIG_From_char(static_cast<char >(result));
7910 }
7911 return resultobj;
7912 fail:
7913 return NULL;
7914 }
7915
7916
7917 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj = NULL;
7919 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7920 size_t result;
7921 PyObject * obj0 = 0 ;
7922 char *kwnames[] = {
7923 (char *) "self", NULL
7924 };
7925
7926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7928 if (SWIG_arg_fail(1)) SWIG_fail;
7929 {
7930 PyThreadState* __tstate = wxPyBeginAllowThreads();
7931 result = (size_t)(arg1)->LastRead();
7932
7933 wxPyEndAllowThreads(__tstate);
7934 if (PyErr_Occurred()) SWIG_fail;
7935 }
7936 {
7937 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7938 }
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7946 PyObject *resultobj = NULL;
7947 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7948 bool result;
7949 PyObject * obj0 = 0 ;
7950 char *kwnames[] = {
7951 (char *) "self", NULL
7952 };
7953
7954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7956 if (SWIG_arg_fail(1)) SWIG_fail;
7957 {
7958 PyThreadState* __tstate = wxPyBeginAllowThreads();
7959 result = (bool)(arg1)->CanRead();
7960
7961 wxPyEndAllowThreads(__tstate);
7962 if (PyErr_Occurred()) SWIG_fail;
7963 }
7964 {
7965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7966 }
7967 return resultobj;
7968 fail:
7969 return NULL;
7970 }
7971
7972
7973 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7974 PyObject *resultobj = NULL;
7975 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7976 bool result;
7977 PyObject * obj0 = 0 ;
7978 char *kwnames[] = {
7979 (char *) "self", NULL
7980 };
7981
7982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7984 if (SWIG_arg_fail(1)) SWIG_fail;
7985 {
7986 PyThreadState* __tstate = wxPyBeginAllowThreads();
7987 result = (bool)(arg1)->Eof();
7988
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 {
7993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7994 }
7995 return resultobj;
7996 fail:
7997 return NULL;
7998 }
7999
8000
8001 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
8002 PyObject *resultobj = NULL;
8003 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8004 char arg2 ;
8005 bool result;
8006 PyObject * obj0 = 0 ;
8007 PyObject * obj1 = 0 ;
8008 char *kwnames[] = {
8009 (char *) "self",(char *) "c", NULL
8010 };
8011
8012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
8013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8014 if (SWIG_arg_fail(1)) SWIG_fail;
8015 {
8016 arg2 = static_cast<char >(SWIG_As_char(obj1));
8017 if (SWIG_arg_fail(2)) SWIG_fail;
8018 }
8019 {
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 result = (bool)(arg1)->Ungetch(arg2);
8022
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 {
8027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8028 }
8029 return resultobj;
8030 fail:
8031 return NULL;
8032 }
8033
8034
8035 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
8036 PyObject *resultobj = NULL;
8037 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8038 long arg2 ;
8039 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
8040 long result;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 PyObject * obj2 = 0 ;
8044 char *kwnames[] = {
8045 (char *) "self",(char *) "pos",(char *) "mode", NULL
8046 };
8047
8048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
8049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8050 if (SWIG_arg_fail(1)) SWIG_fail;
8051 {
8052 arg2 = static_cast<long >(SWIG_As_long(obj1));
8053 if (SWIG_arg_fail(2)) SWIG_fail;
8054 }
8055 if (obj2) {
8056 {
8057 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8058 if (SWIG_arg_fail(3)) SWIG_fail;
8059 }
8060 }
8061 {
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 result = (long)(arg1)->SeekI(arg2,arg3);
8064
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 resultobj = SWIG_From_long(static_cast<long >(result));
8070 }
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8078 PyObject *resultobj = NULL;
8079 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8080 long result;
8081 PyObject * obj0 = 0 ;
8082 char *kwnames[] = {
8083 (char *) "self", NULL
8084 };
8085
8086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8088 if (SWIG_arg_fail(1)) SWIG_fail;
8089 {
8090 PyThreadState* __tstate = wxPyBeginAllowThreads();
8091 result = (long)(arg1)->TellI();
8092
8093 wxPyEndAllowThreads(__tstate);
8094 if (PyErr_Occurred()) SWIG_fail;
8095 }
8096 {
8097 resultobj = SWIG_From_long(static_cast<long >(result));
8098 }
8099 return resultobj;
8100 fail:
8101 return NULL;
8102 }
8103
8104
8105 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8106 PyObject *obj;
8107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8108 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8109 Py_INCREF(obj);
8110 return Py_BuildValue((char *)"");
8111 }
8112 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8113 PyObject *resultobj = NULL;
8114 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8115 PyObject *arg2 = (PyObject *) 0 ;
8116 PyObject * obj0 = 0 ;
8117 PyObject * obj1 = 0 ;
8118 char *kwnames[] = {
8119 (char *) "self",(char *) "obj", NULL
8120 };
8121
8122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8124 if (SWIG_arg_fail(1)) SWIG_fail;
8125 arg2 = obj1;
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 wxOutputStream_write(arg1,arg2);
8129
8130 wxPyEndAllowThreads(__tstate);
8131 if (PyErr_Occurred()) SWIG_fail;
8132 }
8133 Py_INCREF(Py_None); resultobj = Py_None;
8134 return resultobj;
8135 fail:
8136 return NULL;
8137 }
8138
8139
8140 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8141 PyObject *obj;
8142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8143 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8144 Py_INCREF(obj);
8145 return Py_BuildValue((char *)"");
8146 }
8147 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj = NULL;
8149 wxInputStream *arg1 = (wxInputStream *) 0 ;
8150 wxString *arg2 = 0 ;
8151 wxString *arg3 = 0 ;
8152 wxString *arg4 = 0 ;
8153 wxDateTime arg5 ;
8154 wxFSFile *result;
8155 wxPyInputStream *temp1 ;
8156 bool temp2 = false ;
8157 bool temp3 = false ;
8158 bool temp4 = false ;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 PyObject * obj2 = 0 ;
8162 PyObject * obj3 = 0 ;
8163 PyObject * obj4 = 0 ;
8164 char *kwnames[] = {
8165 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8166 };
8167
8168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8169 {
8170 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8171 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8172 } else {
8173 PyErr_Clear(); // clear the failure of the wxPyConvert above
8174 arg1 = wxPyCBInputStream_create(obj0, true);
8175 if (arg1 == NULL) {
8176 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8177 SWIG_fail;
8178 }
8179 }
8180 }
8181 {
8182 arg2 = wxString_in_helper(obj1);
8183 if (arg2 == NULL) SWIG_fail;
8184 temp2 = true;
8185 }
8186 {
8187 arg3 = wxString_in_helper(obj2);
8188 if (arg3 == NULL) SWIG_fail;
8189 temp3 = true;
8190 }
8191 {
8192 arg4 = wxString_in_helper(obj3);
8193 if (arg4 == NULL) SWIG_fail;
8194 temp4 = true;
8195 }
8196 {
8197 wxDateTime * argp;
8198 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8199 if (SWIG_arg_fail(5)) SWIG_fail;
8200 if (argp == NULL) {
8201 SWIG_null_ref("wxDateTime");
8202 }
8203 if (SWIG_arg_fail(5)) SWIG_fail;
8204 arg5 = *argp;
8205 }
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8209
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 {
8214 resultobj = wxPyMake_wxObject(result, (bool)1);
8215 }
8216 {
8217 if (temp2)
8218 delete arg2;
8219 }
8220 {
8221 if (temp3)
8222 delete arg3;
8223 }
8224 {
8225 if (temp4)
8226 delete arg4;
8227 }
8228 return resultobj;
8229 fail:
8230 {
8231 if (temp2)
8232 delete arg2;
8233 }
8234 {
8235 if (temp3)
8236 delete arg3;
8237 }
8238 {
8239 if (temp4)
8240 delete arg4;
8241 }
8242 return NULL;
8243 }
8244
8245
8246 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8247 PyObject *resultobj = NULL;
8248 wxFSFile *arg1 = (wxFSFile *) 0 ;
8249 PyObject * obj0 = 0 ;
8250 char *kwnames[] = {
8251 (char *) "self", NULL
8252 };
8253
8254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8256 if (SWIG_arg_fail(1)) SWIG_fail;
8257 {
8258 PyThreadState* __tstate = wxPyBeginAllowThreads();
8259 delete arg1;
8260
8261 wxPyEndAllowThreads(__tstate);
8262 if (PyErr_Occurred()) SWIG_fail;
8263 }
8264 Py_INCREF(Py_None); resultobj = Py_None;
8265 return resultobj;
8266 fail:
8267 return NULL;
8268 }
8269
8270
8271 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8272 PyObject *resultobj = NULL;
8273 wxFSFile *arg1 = (wxFSFile *) 0 ;
8274 wxInputStream *result;
8275 PyObject * obj0 = 0 ;
8276 char *kwnames[] = {
8277 (char *) "self", NULL
8278 };
8279
8280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8282 if (SWIG_arg_fail(1)) SWIG_fail;
8283 {
8284 PyThreadState* __tstate = wxPyBeginAllowThreads();
8285 result = (wxInputStream *)(arg1)->GetStream();
8286
8287 wxPyEndAllowThreads(__tstate);
8288 if (PyErr_Occurred()) SWIG_fail;
8289 }
8290 {
8291 wxPyInputStream * _ptr = NULL;
8292
8293 if (result) {
8294 _ptr = new wxPyInputStream(result);
8295 }
8296 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8297 }
8298 return resultobj;
8299 fail:
8300 return NULL;
8301 }
8302
8303
8304 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj = NULL;
8306 wxFSFile *arg1 = (wxFSFile *) 0 ;
8307 wxString *result;
8308 PyObject * obj0 = 0 ;
8309 char *kwnames[] = {
8310 (char *) "self", NULL
8311 };
8312
8313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8315 if (SWIG_arg_fail(1)) SWIG_fail;
8316 {
8317 PyThreadState* __tstate = wxPyBeginAllowThreads();
8318 {
8319 wxString const &_result_ref = (arg1)->GetMimeType();
8320 result = (wxString *) &_result_ref;
8321 }
8322
8323 wxPyEndAllowThreads(__tstate);
8324 if (PyErr_Occurred()) SWIG_fail;
8325 }
8326 {
8327 #if wxUSE_UNICODE
8328 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8329 #else
8330 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8331 #endif
8332 }
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = NULL;
8341 wxFSFile *arg1 = (wxFSFile *) 0 ;
8342 wxString *result;
8343 PyObject * obj0 = 0 ;
8344 char *kwnames[] = {
8345 (char *) "self", NULL
8346 };
8347
8348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8350 if (SWIG_arg_fail(1)) SWIG_fail;
8351 {
8352 PyThreadState* __tstate = wxPyBeginAllowThreads();
8353 {
8354 wxString const &_result_ref = (arg1)->GetLocation();
8355 result = (wxString *) &_result_ref;
8356 }
8357
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 {
8362 #if wxUSE_UNICODE
8363 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8364 #else
8365 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8366 #endif
8367 }
8368 return resultobj;
8369 fail:
8370 return NULL;
8371 }
8372
8373
8374 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8375 PyObject *resultobj = NULL;
8376 wxFSFile *arg1 = (wxFSFile *) 0 ;
8377 wxString *result;
8378 PyObject * obj0 = 0 ;
8379 char *kwnames[] = {
8380 (char *) "self", NULL
8381 };
8382
8383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8385 if (SWIG_arg_fail(1)) SWIG_fail;
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 {
8389 wxString const &_result_ref = (arg1)->GetAnchor();
8390 result = (wxString *) &_result_ref;
8391 }
8392
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 {
8397 #if wxUSE_UNICODE
8398 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8399 #else
8400 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8401 #endif
8402 }
8403 return resultobj;
8404 fail:
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj = NULL;
8411 wxFSFile *arg1 = (wxFSFile *) 0 ;
8412 wxDateTime result;
8413 PyObject * obj0 = 0 ;
8414 char *kwnames[] = {
8415 (char *) "self", NULL
8416 };
8417
8418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8420 if (SWIG_arg_fail(1)) SWIG_fail;
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (arg1)->GetModificationTime();
8424
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 {
8429 wxDateTime * resultptr;
8430 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8432 }
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8440 PyObject *obj;
8441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8442 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8443 Py_INCREF(obj);
8444 return Py_BuildValue((char *)"");
8445 }
8446 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8447 PyObject *obj;
8448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8449 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8450 Py_INCREF(obj);
8451 return Py_BuildValue((char *)"");
8452 }
8453 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8454 PyObject *resultobj = NULL;
8455 wxPyFileSystemHandler *result;
8456 char *kwnames[] = {
8457 NULL
8458 };
8459
8460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj = NULL;
8477 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8478 PyObject *arg2 = (PyObject *) 0 ;
8479 PyObject *arg3 = (PyObject *) 0 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 PyObject * obj2 = 0 ;
8483 char *kwnames[] = {
8484 (char *) "self",(char *) "self",(char *) "_class", NULL
8485 };
8486
8487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8489 if (SWIG_arg_fail(1)) SWIG_fail;
8490 arg2 = obj1;
8491 arg3 = obj2;
8492 {
8493 PyThreadState* __tstate = wxPyBeginAllowThreads();
8494 (arg1)->_setCallbackInfo(arg2,arg3);
8495
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 Py_INCREF(Py_None); resultobj = Py_None;
8500 return resultobj;
8501 fail:
8502 return NULL;
8503 }
8504
8505
8506 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8507 PyObject *resultobj = NULL;
8508 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8509 wxString *arg2 = 0 ;
8510 bool result;
8511 bool temp2 = false ;
8512 PyObject * obj0 = 0 ;
8513 PyObject * obj1 = 0 ;
8514 char *kwnames[] = {
8515 (char *) "self",(char *) "location", NULL
8516 };
8517
8518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8520 if (SWIG_arg_fail(1)) SWIG_fail;
8521 {
8522 arg2 = wxString_in_helper(obj1);
8523 if (arg2 == NULL) SWIG_fail;
8524 temp2 = true;
8525 }
8526 {
8527 PyThreadState* __tstate = wxPyBeginAllowThreads();
8528 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8529
8530 wxPyEndAllowThreads(__tstate);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 {
8534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8535 }
8536 {
8537 if (temp2)
8538 delete arg2;
8539 }
8540 return resultobj;
8541 fail:
8542 {
8543 if (temp2)
8544 delete arg2;
8545 }
8546 return NULL;
8547 }
8548
8549
8550 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8551 PyObject *resultobj = NULL;
8552 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8553 wxFileSystem *arg2 = 0 ;
8554 wxString *arg3 = 0 ;
8555 wxFSFile *result;
8556 bool temp3 = false ;
8557 PyObject * obj0 = 0 ;
8558 PyObject * obj1 = 0 ;
8559 PyObject * obj2 = 0 ;
8560 char *kwnames[] = {
8561 (char *) "self",(char *) "fs",(char *) "location", NULL
8562 };
8563
8564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8566 if (SWIG_arg_fail(1)) SWIG_fail;
8567 {
8568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8569 if (SWIG_arg_fail(2)) SWIG_fail;
8570 if (arg2 == NULL) {
8571 SWIG_null_ref("wxFileSystem");
8572 }
8573 if (SWIG_arg_fail(2)) SWIG_fail;
8574 }
8575 {
8576 arg3 = wxString_in_helper(obj2);
8577 if (arg3 == NULL) SWIG_fail;
8578 temp3 = true;
8579 }
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8583
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 {
8588 resultobj = wxPyMake_wxObject(result, (bool)1);
8589 }
8590 {
8591 if (temp3)
8592 delete arg3;
8593 }
8594 return resultobj;
8595 fail:
8596 {
8597 if (temp3)
8598 delete arg3;
8599 }
8600 return NULL;
8601 }
8602
8603
8604 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8605 PyObject *resultobj = NULL;
8606 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8607 wxString *arg2 = 0 ;
8608 int arg3 = (int) 0 ;
8609 wxString result;
8610 bool temp2 = false ;
8611 PyObject * obj0 = 0 ;
8612 PyObject * obj1 = 0 ;
8613 PyObject * obj2 = 0 ;
8614 char *kwnames[] = {
8615 (char *) "self",(char *) "spec",(char *) "flags", NULL
8616 };
8617
8618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8620 if (SWIG_arg_fail(1)) SWIG_fail;
8621 {
8622 arg2 = wxString_in_helper(obj1);
8623 if (arg2 == NULL) SWIG_fail;
8624 temp2 = true;
8625 }
8626 if (obj2) {
8627 {
8628 arg3 = static_cast<int >(SWIG_As_int(obj2));
8629 if (SWIG_arg_fail(3)) SWIG_fail;
8630 }
8631 }
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8635
8636 wxPyEndAllowThreads(__tstate);
8637 if (PyErr_Occurred()) SWIG_fail;
8638 }
8639 {
8640 #if wxUSE_UNICODE
8641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8642 #else
8643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8644 #endif
8645 }
8646 {
8647 if (temp2)
8648 delete arg2;
8649 }
8650 return resultobj;
8651 fail:
8652 {
8653 if (temp2)
8654 delete arg2;
8655 }
8656 return NULL;
8657 }
8658
8659
8660 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = NULL;
8662 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8663 wxString result;
8664 PyObject * obj0 = 0 ;
8665 char *kwnames[] = {
8666 (char *) "self", NULL
8667 };
8668
8669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8671 if (SWIG_arg_fail(1)) SWIG_fail;
8672 {
8673 PyThreadState* __tstate = wxPyBeginAllowThreads();
8674 result = (arg1)->FindNext();
8675
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 {
8680 #if wxUSE_UNICODE
8681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8682 #else
8683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8684 #endif
8685 }
8686 return resultobj;
8687 fail:
8688 return NULL;
8689 }
8690
8691
8692 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8693 PyObject *resultobj = NULL;
8694 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8695 wxString *arg2 = 0 ;
8696 wxString result;
8697 bool temp2 = false ;
8698 PyObject * obj0 = 0 ;
8699 PyObject * obj1 = 0 ;
8700 char *kwnames[] = {
8701 (char *) "self",(char *) "location", NULL
8702 };
8703
8704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8706 if (SWIG_arg_fail(1)) SWIG_fail;
8707 {
8708 arg2 = wxString_in_helper(obj1);
8709 if (arg2 == NULL) SWIG_fail;
8710 temp2 = true;
8711 }
8712 {
8713 PyThreadState* __tstate = wxPyBeginAllowThreads();
8714 result = (arg1)->GetProtocol((wxString const &)*arg2);
8715
8716 wxPyEndAllowThreads(__tstate);
8717 if (PyErr_Occurred()) SWIG_fail;
8718 }
8719 {
8720 #if wxUSE_UNICODE
8721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8722 #else
8723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8724 #endif
8725 }
8726 {
8727 if (temp2)
8728 delete arg2;
8729 }
8730 return resultobj;
8731 fail:
8732 {
8733 if (temp2)
8734 delete arg2;
8735 }
8736 return NULL;
8737 }
8738
8739
8740 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8741 PyObject *resultobj = NULL;
8742 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8743 wxString *arg2 = 0 ;
8744 wxString result;
8745 bool temp2 = false ;
8746 PyObject * obj0 = 0 ;
8747 PyObject * obj1 = 0 ;
8748 char *kwnames[] = {
8749 (char *) "self",(char *) "location", NULL
8750 };
8751
8752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8754 if (SWIG_arg_fail(1)) SWIG_fail;
8755 {
8756 arg2 = wxString_in_helper(obj1);
8757 if (arg2 == NULL) SWIG_fail;
8758 temp2 = true;
8759 }
8760 {
8761 PyThreadState* __tstate = wxPyBeginAllowThreads();
8762 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8763
8764 wxPyEndAllowThreads(__tstate);
8765 if (PyErr_Occurred()) SWIG_fail;
8766 }
8767 {
8768 #if wxUSE_UNICODE
8769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8770 #else
8771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8772 #endif
8773 }
8774 {
8775 if (temp2)
8776 delete arg2;
8777 }
8778 return resultobj;
8779 fail:
8780 {
8781 if (temp2)
8782 delete arg2;
8783 }
8784 return NULL;
8785 }
8786
8787
8788 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = NULL;
8790 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8791 wxString *arg2 = 0 ;
8792 wxString result;
8793 bool temp2 = false ;
8794 PyObject * obj0 = 0 ;
8795 PyObject * obj1 = 0 ;
8796 char *kwnames[] = {
8797 (char *) "self",(char *) "location", NULL
8798 };
8799
8800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8802 if (SWIG_arg_fail(1)) SWIG_fail;
8803 {
8804 arg2 = wxString_in_helper(obj1);
8805 if (arg2 == NULL) SWIG_fail;
8806 temp2 = true;
8807 }
8808 {
8809 PyThreadState* __tstate = wxPyBeginAllowThreads();
8810 result = (arg1)->GetAnchor((wxString const &)*arg2);
8811
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 {
8816 #if wxUSE_UNICODE
8817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8818 #else
8819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8820 #endif
8821 }
8822 {
8823 if (temp2)
8824 delete arg2;
8825 }
8826 return resultobj;
8827 fail:
8828 {
8829 if (temp2)
8830 delete arg2;
8831 }
8832 return NULL;
8833 }
8834
8835
8836 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj = NULL;
8838 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8839 wxString *arg2 = 0 ;
8840 wxString result;
8841 bool temp2 = false ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 char *kwnames[] = {
8845 (char *) "self",(char *) "location", NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8850 if (SWIG_arg_fail(1)) SWIG_fail;
8851 {
8852 arg2 = wxString_in_helper(obj1);
8853 if (arg2 == NULL) SWIG_fail;
8854 temp2 = true;
8855 }
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8859
8860 wxPyEndAllowThreads(__tstate);
8861 if (PyErr_Occurred()) SWIG_fail;
8862 }
8863 {
8864 #if wxUSE_UNICODE
8865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8866 #else
8867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8868 #endif
8869 }
8870 {
8871 if (temp2)
8872 delete arg2;
8873 }
8874 return resultobj;
8875 fail:
8876 {
8877 if (temp2)
8878 delete arg2;
8879 }
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj = NULL;
8886 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8887 wxString *arg2 = 0 ;
8888 wxString result;
8889 bool temp2 = false ;
8890 PyObject * obj0 = 0 ;
8891 PyObject * obj1 = 0 ;
8892 char *kwnames[] = {
8893 (char *) "self",(char *) "location", NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 {
8900 arg2 = wxString_in_helper(obj1);
8901 if (arg2 == NULL) SWIG_fail;
8902 temp2 = true;
8903 }
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8907
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 #if wxUSE_UNICODE
8913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8914 #else
8915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8916 #endif
8917 }
8918 {
8919 if (temp2)
8920 delete arg2;
8921 }
8922 return resultobj;
8923 fail:
8924 {
8925 if (temp2)
8926 delete arg2;
8927 }
8928 return NULL;
8929 }
8930
8931
8932 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8933 PyObject *obj;
8934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8935 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8936 Py_INCREF(obj);
8937 return Py_BuildValue((char *)"");
8938 }
8939 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8940 PyObject *resultobj = NULL;
8941 wxFileSystem *result;
8942 char *kwnames[] = {
8943 NULL
8944 };
8945
8946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8947 {
8948 PyThreadState* __tstate = wxPyBeginAllowThreads();
8949 result = (wxFileSystem *)new wxFileSystem();
8950
8951 wxPyEndAllowThreads(__tstate);
8952 if (PyErr_Occurred()) SWIG_fail;
8953 }
8954 {
8955 resultobj = wxPyMake_wxObject(result, (bool)1);
8956 }
8957 return resultobj;
8958 fail:
8959 return NULL;
8960 }
8961
8962
8963 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj = NULL;
8965 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8966 PyObject * obj0 = 0 ;
8967 char *kwnames[] = {
8968 (char *) "self", NULL
8969 };
8970
8971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8973 if (SWIG_arg_fail(1)) SWIG_fail;
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 delete arg1;
8977
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 Py_INCREF(Py_None); resultobj = Py_None;
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8989 PyObject *resultobj = NULL;
8990 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8991 wxString *arg2 = 0 ;
8992 bool arg3 = (bool) false ;
8993 bool temp2 = false ;
8994 PyObject * obj0 = 0 ;
8995 PyObject * obj1 = 0 ;
8996 PyObject * obj2 = 0 ;
8997 char *kwnames[] = {
8998 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8999 };
9000
9001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
9002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9003 if (SWIG_arg_fail(1)) SWIG_fail;
9004 {
9005 arg2 = wxString_in_helper(obj1);
9006 if (arg2 == NULL) SWIG_fail;
9007 temp2 = true;
9008 }
9009 if (obj2) {
9010 {
9011 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9012 if (SWIG_arg_fail(3)) SWIG_fail;
9013 }
9014 }
9015 {
9016 PyThreadState* __tstate = wxPyBeginAllowThreads();
9017 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
9018
9019 wxPyEndAllowThreads(__tstate);
9020 if (PyErr_Occurred()) SWIG_fail;
9021 }
9022 Py_INCREF(Py_None); resultobj = Py_None;
9023 {
9024 if (temp2)
9025 delete arg2;
9026 }
9027 return resultobj;
9028 fail:
9029 {
9030 if (temp2)
9031 delete arg2;
9032 }
9033 return NULL;
9034 }
9035
9036
9037 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj = NULL;
9039 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9040 wxString result;
9041 PyObject * obj0 = 0 ;
9042 char *kwnames[] = {
9043 (char *) "self", NULL
9044 };
9045
9046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
9047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9048 if (SWIG_arg_fail(1)) SWIG_fail;
9049 {
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 result = (arg1)->GetPath();
9052
9053 wxPyEndAllowThreads(__tstate);
9054 if (PyErr_Occurred()) SWIG_fail;
9055 }
9056 {
9057 #if wxUSE_UNICODE
9058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9059 #else
9060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9061 #endif
9062 }
9063 return resultobj;
9064 fail:
9065 return NULL;
9066 }
9067
9068
9069 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9070 PyObject *resultobj = NULL;
9071 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9072 wxString *arg2 = 0 ;
9073 wxFSFile *result;
9074 bool temp2 = false ;
9075 PyObject * obj0 = 0 ;
9076 PyObject * obj1 = 0 ;
9077 char *kwnames[] = {
9078 (char *) "self",(char *) "location", NULL
9079 };
9080
9081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9083 if (SWIG_arg_fail(1)) SWIG_fail;
9084 {
9085 arg2 = wxString_in_helper(obj1);
9086 if (arg2 == NULL) SWIG_fail;
9087 temp2 = true;
9088 }
9089 {
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9092
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 {
9097 resultobj = wxPyMake_wxObject(result, (bool)1);
9098 }
9099 {
9100 if (temp2)
9101 delete arg2;
9102 }
9103 return resultobj;
9104 fail:
9105 {
9106 if (temp2)
9107 delete arg2;
9108 }
9109 return NULL;
9110 }
9111
9112
9113 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj = NULL;
9115 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9116 wxString *arg2 = 0 ;
9117 int arg3 = (int) 0 ;
9118 wxString result;
9119 bool temp2 = false ;
9120 PyObject * obj0 = 0 ;
9121 PyObject * obj1 = 0 ;
9122 PyObject * obj2 = 0 ;
9123 char *kwnames[] = {
9124 (char *) "self",(char *) "spec",(char *) "flags", NULL
9125 };
9126
9127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9129 if (SWIG_arg_fail(1)) SWIG_fail;
9130 {
9131 arg2 = wxString_in_helper(obj1);
9132 if (arg2 == NULL) SWIG_fail;
9133 temp2 = true;
9134 }
9135 if (obj2) {
9136 {
9137 arg3 = static_cast<int >(SWIG_As_int(obj2));
9138 if (SWIG_arg_fail(3)) SWIG_fail;
9139 }
9140 }
9141 {
9142 PyThreadState* __tstate = wxPyBeginAllowThreads();
9143 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9144
9145 wxPyEndAllowThreads(__tstate);
9146 if (PyErr_Occurred()) SWIG_fail;
9147 }
9148 {
9149 #if wxUSE_UNICODE
9150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9151 #else
9152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9153 #endif
9154 }
9155 {
9156 if (temp2)
9157 delete arg2;
9158 }
9159 return resultobj;
9160 fail:
9161 {
9162 if (temp2)
9163 delete arg2;
9164 }
9165 return NULL;
9166 }
9167
9168
9169 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj = NULL;
9171 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9172 wxString result;
9173 PyObject * obj0 = 0 ;
9174 char *kwnames[] = {
9175 (char *) "self", NULL
9176 };
9177
9178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9180 if (SWIG_arg_fail(1)) SWIG_fail;
9181 {
9182 PyThreadState* __tstate = wxPyBeginAllowThreads();
9183 result = (arg1)->FindNext();
9184
9185 wxPyEndAllowThreads(__tstate);
9186 if (PyErr_Occurred()) SWIG_fail;
9187 }
9188 {
9189 #if wxUSE_UNICODE
9190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9191 #else
9192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9193 #endif
9194 }
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = NULL;
9203 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9204 PyObject * obj0 = 0 ;
9205 char *kwnames[] = {
9206 (char *) "handler", NULL
9207 };
9208
9209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9211 if (SWIG_arg_fail(1)) SWIG_fail;
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 wxFileSystem::AddHandler(arg1);
9215
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 Py_INCREF(Py_None); resultobj = Py_None;
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj = NULL;
9228 char *kwnames[] = {
9229 NULL
9230 };
9231
9232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 wxFileSystem::CleanUpHandlers();
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 Py_INCREF(Py_None); resultobj = Py_None;
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9248 PyObject *resultobj = NULL;
9249 wxString *arg1 = 0 ;
9250 wxString result;
9251 bool temp1 = false ;
9252 PyObject * obj0 = 0 ;
9253 char *kwnames[] = {
9254 (char *) "filename", NULL
9255 };
9256
9257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9258 {
9259 arg1 = wxString_in_helper(obj0);
9260 if (arg1 == NULL) SWIG_fail;
9261 temp1 = true;
9262 }
9263 {
9264 PyThreadState* __tstate = wxPyBeginAllowThreads();
9265 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9266
9267 wxPyEndAllowThreads(__tstate);
9268 if (PyErr_Occurred()) SWIG_fail;
9269 }
9270 {
9271 #if wxUSE_UNICODE
9272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9273 #else
9274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9275 #endif
9276 }
9277 {
9278 if (temp1)
9279 delete arg1;
9280 }
9281 return resultobj;
9282 fail:
9283 {
9284 if (temp1)
9285 delete arg1;
9286 }
9287 return NULL;
9288 }
9289
9290
9291 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9292 PyObject *resultobj = NULL;
9293 wxString *arg1 = 0 ;
9294 wxString result;
9295 bool temp1 = false ;
9296 PyObject * obj0 = 0 ;
9297 char *kwnames[] = {
9298 (char *) "url", NULL
9299 };
9300
9301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9302 {
9303 arg1 = wxString_in_helper(obj0);
9304 if (arg1 == NULL) SWIG_fail;
9305 temp1 = true;
9306 }
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 {
9315 #if wxUSE_UNICODE
9316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9317 #else
9318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9319 #endif
9320 }
9321 {
9322 if (temp1)
9323 delete arg1;
9324 }
9325 return resultobj;
9326 fail:
9327 {
9328 if (temp1)
9329 delete arg1;
9330 }
9331 return NULL;
9332 }
9333
9334
9335 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9336 PyObject *obj;
9337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9338 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9339 Py_INCREF(obj);
9340 return Py_BuildValue((char *)"");
9341 }
9342 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9343 PyObject *resultobj = NULL;
9344 wxInternetFSHandler *result;
9345 char *kwnames[] = {
9346 NULL
9347 };
9348
9349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9353
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj = NULL;
9366 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9367 wxString *arg2 = 0 ;
9368 bool result;
9369 bool temp2 = false ;
9370 PyObject * obj0 = 0 ;
9371 PyObject * obj1 = 0 ;
9372 char *kwnames[] = {
9373 (char *) "self",(char *) "location", NULL
9374 };
9375
9376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9378 if (SWIG_arg_fail(1)) SWIG_fail;
9379 {
9380 arg2 = wxString_in_helper(obj1);
9381 if (arg2 == NULL) SWIG_fail;
9382 temp2 = true;
9383 }
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9387
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 {
9392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9393 }
9394 {
9395 if (temp2)
9396 delete arg2;
9397 }
9398 return resultobj;
9399 fail:
9400 {
9401 if (temp2)
9402 delete arg2;
9403 }
9404 return NULL;
9405 }
9406
9407
9408 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9409 PyObject *resultobj = NULL;
9410 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9411 wxFileSystem *arg2 = 0 ;
9412 wxString *arg3 = 0 ;
9413 wxFSFile *result;
9414 bool temp3 = false ;
9415 PyObject * obj0 = 0 ;
9416 PyObject * obj1 = 0 ;
9417 PyObject * obj2 = 0 ;
9418 char *kwnames[] = {
9419 (char *) "self",(char *) "fs",(char *) "location", NULL
9420 };
9421
9422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9424 if (SWIG_arg_fail(1)) SWIG_fail;
9425 {
9426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9427 if (SWIG_arg_fail(2)) SWIG_fail;
9428 if (arg2 == NULL) {
9429 SWIG_null_ref("wxFileSystem");
9430 }
9431 if (SWIG_arg_fail(2)) SWIG_fail;
9432 }
9433 {
9434 arg3 = wxString_in_helper(obj2);
9435 if (arg3 == NULL) SWIG_fail;
9436 temp3 = true;
9437 }
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9441
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 {
9446 resultobj = wxPyMake_wxObject(result, (bool)1);
9447 }
9448 {
9449 if (temp3)
9450 delete arg3;
9451 }
9452 return resultobj;
9453 fail:
9454 {
9455 if (temp3)
9456 delete arg3;
9457 }
9458 return NULL;
9459 }
9460
9461
9462 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9463 PyObject *obj;
9464 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9465 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9466 Py_INCREF(obj);
9467 return Py_BuildValue((char *)"");
9468 }
9469 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9470 PyObject *resultobj = NULL;
9471 wxZipFSHandler *result;
9472 char *kwnames[] = {
9473 NULL
9474 };
9475
9476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9477 {
9478 PyThreadState* __tstate = wxPyBeginAllowThreads();
9479 result = (wxZipFSHandler *)new wxZipFSHandler();
9480
9481 wxPyEndAllowThreads(__tstate);
9482 if (PyErr_Occurred()) SWIG_fail;
9483 }
9484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9485 return resultobj;
9486 fail:
9487 return NULL;
9488 }
9489
9490
9491 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj = NULL;
9493 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9494 wxString *arg2 = 0 ;
9495 bool result;
9496 bool temp2 = false ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char *kwnames[] = {
9500 (char *) "self",(char *) "location", NULL
9501 };
9502
9503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9505 if (SWIG_arg_fail(1)) SWIG_fail;
9506 {
9507 arg2 = wxString_in_helper(obj1);
9508 if (arg2 == NULL) SWIG_fail;
9509 temp2 = true;
9510 }
9511 {
9512 PyThreadState* __tstate = wxPyBeginAllowThreads();
9513 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9514
9515 wxPyEndAllowThreads(__tstate);
9516 if (PyErr_Occurred()) SWIG_fail;
9517 }
9518 {
9519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9520 }
9521 {
9522 if (temp2)
9523 delete arg2;
9524 }
9525 return resultobj;
9526 fail:
9527 {
9528 if (temp2)
9529 delete arg2;
9530 }
9531 return NULL;
9532 }
9533
9534
9535 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj = NULL;
9537 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9538 wxFileSystem *arg2 = 0 ;
9539 wxString *arg3 = 0 ;
9540 wxFSFile *result;
9541 bool temp3 = false ;
9542 PyObject * obj0 = 0 ;
9543 PyObject * obj1 = 0 ;
9544 PyObject * obj2 = 0 ;
9545 char *kwnames[] = {
9546 (char *) "self",(char *) "fs",(char *) "location", NULL
9547 };
9548
9549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9551 if (SWIG_arg_fail(1)) SWIG_fail;
9552 {
9553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9554 if (SWIG_arg_fail(2)) SWIG_fail;
9555 if (arg2 == NULL) {
9556 SWIG_null_ref("wxFileSystem");
9557 }
9558 if (SWIG_arg_fail(2)) SWIG_fail;
9559 }
9560 {
9561 arg3 = wxString_in_helper(obj2);
9562 if (arg3 == NULL) SWIG_fail;
9563 temp3 = true;
9564 }
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9568
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 {
9573 resultobj = wxPyMake_wxObject(result, (bool)1);
9574 }
9575 {
9576 if (temp3)
9577 delete arg3;
9578 }
9579 return resultobj;
9580 fail:
9581 {
9582 if (temp3)
9583 delete arg3;
9584 }
9585 return NULL;
9586 }
9587
9588
9589 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9590 PyObject *resultobj = NULL;
9591 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9592 wxString *arg2 = 0 ;
9593 int arg3 = (int) 0 ;
9594 wxString result;
9595 bool temp2 = false ;
9596 PyObject * obj0 = 0 ;
9597 PyObject * obj1 = 0 ;
9598 PyObject * obj2 = 0 ;
9599 char *kwnames[] = {
9600 (char *) "self",(char *) "spec",(char *) "flags", NULL
9601 };
9602
9603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9605 if (SWIG_arg_fail(1)) SWIG_fail;
9606 {
9607 arg2 = wxString_in_helper(obj1);
9608 if (arg2 == NULL) SWIG_fail;
9609 temp2 = true;
9610 }
9611 if (obj2) {
9612 {
9613 arg3 = static_cast<int >(SWIG_As_int(obj2));
9614 if (SWIG_arg_fail(3)) SWIG_fail;
9615 }
9616 }
9617 {
9618 PyThreadState* __tstate = wxPyBeginAllowThreads();
9619 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9620
9621 wxPyEndAllowThreads(__tstate);
9622 if (PyErr_Occurred()) SWIG_fail;
9623 }
9624 {
9625 #if wxUSE_UNICODE
9626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9627 #else
9628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9629 #endif
9630 }
9631 {
9632 if (temp2)
9633 delete arg2;
9634 }
9635 return resultobj;
9636 fail:
9637 {
9638 if (temp2)
9639 delete arg2;
9640 }
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj = NULL;
9647 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9648 wxString result;
9649 PyObject * obj0 = 0 ;
9650 char *kwnames[] = {
9651 (char *) "self", NULL
9652 };
9653
9654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9656 if (SWIG_arg_fail(1)) SWIG_fail;
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 result = (arg1)->FindNext();
9660
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 {
9665 #if wxUSE_UNICODE
9666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9667 #else
9668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9669 #endif
9670 }
9671 return resultobj;
9672 fail:
9673 return NULL;
9674 }
9675
9676
9677 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9678 PyObject *obj;
9679 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9680 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9681 Py_INCREF(obj);
9682 return Py_BuildValue((char *)"");
9683 }
9684 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj = NULL;
9686 wxString *arg1 = 0 ;
9687 wxImage *arg2 = 0 ;
9688 long arg3 ;
9689 bool temp1 = false ;
9690 PyObject * obj0 = 0 ;
9691 PyObject * obj1 = 0 ;
9692 PyObject * obj2 = 0 ;
9693 char *kwnames[] = {
9694 (char *) "filename",(char *) "image",(char *) "type", NULL
9695 };
9696
9697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9698 {
9699 arg1 = wxString_in_helper(obj0);
9700 if (arg1 == NULL) SWIG_fail;
9701 temp1 = true;
9702 }
9703 {
9704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9705 if (SWIG_arg_fail(2)) SWIG_fail;
9706 if (arg2 == NULL) {
9707 SWIG_null_ref("wxImage");
9708 }
9709 if (SWIG_arg_fail(2)) SWIG_fail;
9710 }
9711 {
9712 arg3 = static_cast<long >(SWIG_As_long(obj2));
9713 if (SWIG_arg_fail(3)) SWIG_fail;
9714 }
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 Py_INCREF(Py_None); resultobj = Py_None;
9723 {
9724 if (temp1)
9725 delete arg1;
9726 }
9727 return resultobj;
9728 fail:
9729 {
9730 if (temp1)
9731 delete arg1;
9732 }
9733 return NULL;
9734 }
9735
9736
9737 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9738 PyObject *resultobj = NULL;
9739 wxString *arg1 = 0 ;
9740 wxBitmap *arg2 = 0 ;
9741 long arg3 ;
9742 bool temp1 = false ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 PyObject * obj2 = 0 ;
9746 char *kwnames[] = {
9747 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9748 };
9749
9750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9751 {
9752 arg1 = wxString_in_helper(obj0);
9753 if (arg1 == NULL) SWIG_fail;
9754 temp1 = true;
9755 }
9756 {
9757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9758 if (SWIG_arg_fail(2)) SWIG_fail;
9759 if (arg2 == NULL) {
9760 SWIG_null_ref("wxBitmap");
9761 }
9762 if (SWIG_arg_fail(2)) SWIG_fail;
9763 }
9764 {
9765 arg3 = static_cast<long >(SWIG_As_long(obj2));
9766 if (SWIG_arg_fail(3)) SWIG_fail;
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 Py_INCREF(Py_None); resultobj = Py_None;
9776 {
9777 if (temp1)
9778 delete arg1;
9779 }
9780 return resultobj;
9781 fail:
9782 {
9783 if (temp1)
9784 delete arg1;
9785 }
9786 return NULL;
9787 }
9788
9789
9790 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9791 PyObject *resultobj = NULL;
9792 wxString *arg1 = 0 ;
9793 PyObject *arg2 = (PyObject *) 0 ;
9794 bool temp1 = false ;
9795 PyObject * obj0 = 0 ;
9796 PyObject * obj1 = 0 ;
9797 char *kwnames[] = {
9798 (char *) "filename",(char *) "data", NULL
9799 };
9800
9801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9802 {
9803 arg1 = wxString_in_helper(obj0);
9804 if (arg1 == NULL) SWIG_fail;
9805 temp1 = true;
9806 }
9807 arg2 = obj1;
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9811
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 Py_INCREF(Py_None); resultobj = Py_None;
9816 {
9817 if (temp1)
9818 delete arg1;
9819 }
9820 return resultobj;
9821 fail:
9822 {
9823 if (temp1)
9824 delete arg1;
9825 }
9826 return NULL;
9827 }
9828
9829
9830 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9831 PyObject *resultobj = NULL;
9832 wxMemoryFSHandler *result;
9833 char *kwnames[] = {
9834 NULL
9835 };
9836
9837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9841
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9853 PyObject *resultobj = NULL;
9854 wxString *arg1 = 0 ;
9855 bool temp1 = false ;
9856 PyObject * obj0 = 0 ;
9857 char *kwnames[] = {
9858 (char *) "filename", NULL
9859 };
9860
9861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9862 {
9863 arg1 = wxString_in_helper(obj0);
9864 if (arg1 == NULL) SWIG_fail;
9865 temp1 = true;
9866 }
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9870
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 Py_INCREF(Py_None); resultobj = Py_None;
9875 {
9876 if (temp1)
9877 delete arg1;
9878 }
9879 return resultobj;
9880 fail:
9881 {
9882 if (temp1)
9883 delete arg1;
9884 }
9885 return NULL;
9886 }
9887
9888
9889 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9890 PyObject *resultobj = NULL;
9891 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9892 wxString *arg2 = 0 ;
9893 bool result;
9894 bool temp2 = false ;
9895 PyObject * obj0 = 0 ;
9896 PyObject * obj1 = 0 ;
9897 char *kwnames[] = {
9898 (char *) "self",(char *) "location", NULL
9899 };
9900
9901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9903 if (SWIG_arg_fail(1)) SWIG_fail;
9904 {
9905 arg2 = wxString_in_helper(obj1);
9906 if (arg2 == NULL) SWIG_fail;
9907 temp2 = true;
9908 }
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9918 }
9919 {
9920 if (temp2)
9921 delete arg2;
9922 }
9923 return resultobj;
9924 fail:
9925 {
9926 if (temp2)
9927 delete arg2;
9928 }
9929 return NULL;
9930 }
9931
9932
9933 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9934 PyObject *resultobj = NULL;
9935 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9936 wxFileSystem *arg2 = 0 ;
9937 wxString *arg3 = 0 ;
9938 wxFSFile *result;
9939 bool temp3 = false ;
9940 PyObject * obj0 = 0 ;
9941 PyObject * obj1 = 0 ;
9942 PyObject * obj2 = 0 ;
9943 char *kwnames[] = {
9944 (char *) "self",(char *) "fs",(char *) "location", NULL
9945 };
9946
9947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9949 if (SWIG_arg_fail(1)) SWIG_fail;
9950 {
9951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9952 if (SWIG_arg_fail(2)) SWIG_fail;
9953 if (arg2 == NULL) {
9954 SWIG_null_ref("wxFileSystem");
9955 }
9956 if (SWIG_arg_fail(2)) SWIG_fail;
9957 }
9958 {
9959 arg3 = wxString_in_helper(obj2);
9960 if (arg3 == NULL) SWIG_fail;
9961 temp3 = true;
9962 }
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 {
9971 resultobj = wxPyMake_wxObject(result, (bool)1);
9972 }
9973 {
9974 if (temp3)
9975 delete arg3;
9976 }
9977 return resultobj;
9978 fail:
9979 {
9980 if (temp3)
9981 delete arg3;
9982 }
9983 return NULL;
9984 }
9985
9986
9987 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj = NULL;
9989 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9990 wxString *arg2 = 0 ;
9991 int arg3 = (int) 0 ;
9992 wxString result;
9993 bool temp2 = false ;
9994 PyObject * obj0 = 0 ;
9995 PyObject * obj1 = 0 ;
9996 PyObject * obj2 = 0 ;
9997 char *kwnames[] = {
9998 (char *) "self",(char *) "spec",(char *) "flags", NULL
9999 };
10000
10001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
10002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10003 if (SWIG_arg_fail(1)) SWIG_fail;
10004 {
10005 arg2 = wxString_in_helper(obj1);
10006 if (arg2 == NULL) SWIG_fail;
10007 temp2 = true;
10008 }
10009 if (obj2) {
10010 {
10011 arg3 = static_cast<int >(SWIG_As_int(obj2));
10012 if (SWIG_arg_fail(3)) SWIG_fail;
10013 }
10014 }
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 {
10023 #if wxUSE_UNICODE
10024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10025 #else
10026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10027 #endif
10028 }
10029 {
10030 if (temp2)
10031 delete arg2;
10032 }
10033 return resultobj;
10034 fail:
10035 {
10036 if (temp2)
10037 delete arg2;
10038 }
10039 return NULL;
10040 }
10041
10042
10043 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
10044 PyObject *resultobj = NULL;
10045 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
10046 wxString result;
10047 PyObject * obj0 = 0 ;
10048 char *kwnames[] = {
10049 (char *) "self", NULL
10050 };
10051
10052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
10053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10054 if (SWIG_arg_fail(1)) SWIG_fail;
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (arg1)->FindNext();
10058
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 {
10063 #if wxUSE_UNICODE
10064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10065 #else
10066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10067 #endif
10068 }
10069 return resultobj;
10070 fail:
10071 return NULL;
10072 }
10073
10074
10075 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10076 PyObject *obj;
10077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10078 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10079 Py_INCREF(obj);
10080 return Py_BuildValue((char *)"");
10081 }
10082 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10083 PyObject *resultobj = NULL;
10084 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10085 wxString result;
10086 PyObject * obj0 = 0 ;
10087 char *kwnames[] = {
10088 (char *) "self", NULL
10089 };
10090
10091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10093 if (SWIG_arg_fail(1)) SWIG_fail;
10094 {
10095 PyThreadState* __tstate = wxPyBeginAllowThreads();
10096 result = (arg1)->GetName();
10097
10098 wxPyEndAllowThreads(__tstate);
10099 if (PyErr_Occurred()) SWIG_fail;
10100 }
10101 {
10102 #if wxUSE_UNICODE
10103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10104 #else
10105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10106 #endif
10107 }
10108 return resultobj;
10109 fail:
10110 return NULL;
10111 }
10112
10113
10114 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10115 PyObject *resultobj = NULL;
10116 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10117 wxString result;
10118 PyObject * obj0 = 0 ;
10119 char *kwnames[] = {
10120 (char *) "self", NULL
10121 };
10122
10123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10125 if (SWIG_arg_fail(1)) SWIG_fail;
10126 {
10127 PyThreadState* __tstate = wxPyBeginAllowThreads();
10128 result = (arg1)->GetExtension();
10129
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 {
10134 #if wxUSE_UNICODE
10135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10136 #else
10137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10138 #endif
10139 }
10140 return resultobj;
10141 fail:
10142 return NULL;
10143 }
10144
10145
10146 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10147 PyObject *resultobj = NULL;
10148 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10149 long result;
10150 PyObject * obj0 = 0 ;
10151 char *kwnames[] = {
10152 (char *) "self", NULL
10153 };
10154
10155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10157 if (SWIG_arg_fail(1)) SWIG_fail;
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 result = (long)(arg1)->GetType();
10161
10162 wxPyEndAllowThreads(__tstate);
10163 if (PyErr_Occurred()) SWIG_fail;
10164 }
10165 {
10166 resultobj = SWIG_From_long(static_cast<long >(result));
10167 }
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj = NULL;
10176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10177 wxString result;
10178 PyObject * obj0 = 0 ;
10179 char *kwnames[] = {
10180 (char *) "self", NULL
10181 };
10182
10183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10185 if (SWIG_arg_fail(1)) SWIG_fail;
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 result = (arg1)->GetMimeType();
10189
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 {
10194 #if wxUSE_UNICODE
10195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10196 #else
10197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10198 #endif
10199 }
10200 return resultobj;
10201 fail:
10202 return NULL;
10203 }
10204
10205
10206 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj = NULL;
10208 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10209 wxString *arg2 = 0 ;
10210 bool result;
10211 bool temp2 = false ;
10212 PyObject * obj0 = 0 ;
10213 PyObject * obj1 = 0 ;
10214 char *kwnames[] = {
10215 (char *) "self",(char *) "name", NULL
10216 };
10217
10218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10220 if (SWIG_arg_fail(1)) SWIG_fail;
10221 {
10222 arg2 = wxString_in_helper(obj1);
10223 if (arg2 == NULL) SWIG_fail;
10224 temp2 = true;
10225 }
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10229
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 {
10234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10235 }
10236 {
10237 if (temp2)
10238 delete arg2;
10239 }
10240 return resultobj;
10241 fail:
10242 {
10243 if (temp2)
10244 delete arg2;
10245 }
10246 return NULL;
10247 }
10248
10249
10250 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = NULL;
10252 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10253 wxString *arg2 = 0 ;
10254 bool temp2 = false ;
10255 PyObject * obj0 = 0 ;
10256 PyObject * obj1 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "self",(char *) "name", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10263 if (SWIG_arg_fail(1)) SWIG_fail;
10264 {
10265 arg2 = wxString_in_helper(obj1);
10266 if (arg2 == NULL) SWIG_fail;
10267 temp2 = true;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 (arg1)->SetName((wxString const &)*arg2);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 Py_INCREF(Py_None); resultobj = Py_None;
10277 {
10278 if (temp2)
10279 delete arg2;
10280 }
10281 return resultobj;
10282 fail:
10283 {
10284 if (temp2)
10285 delete arg2;
10286 }
10287 return NULL;
10288 }
10289
10290
10291 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10292 PyObject *resultobj = NULL;
10293 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10294 wxString *arg2 = 0 ;
10295 bool temp2 = false ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 char *kwnames[] = {
10299 (char *) "self",(char *) "extension", NULL
10300 };
10301
10302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10304 if (SWIG_arg_fail(1)) SWIG_fail;
10305 {
10306 arg2 = wxString_in_helper(obj1);
10307 if (arg2 == NULL) SWIG_fail;
10308 temp2 = true;
10309 }
10310 {
10311 PyThreadState* __tstate = wxPyBeginAllowThreads();
10312 (arg1)->SetExtension((wxString const &)*arg2);
10313
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 Py_INCREF(Py_None); resultobj = Py_None;
10318 {
10319 if (temp2)
10320 delete arg2;
10321 }
10322 return resultobj;
10323 fail:
10324 {
10325 if (temp2)
10326 delete arg2;
10327 }
10328 return NULL;
10329 }
10330
10331
10332 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10333 PyObject *resultobj = NULL;
10334 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10335 long arg2 ;
10336 PyObject * obj0 = 0 ;
10337 PyObject * obj1 = 0 ;
10338 char *kwnames[] = {
10339 (char *) "self",(char *) "type", NULL
10340 };
10341
10342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10344 if (SWIG_arg_fail(1)) SWIG_fail;
10345 {
10346 arg2 = static_cast<long >(SWIG_As_long(obj1));
10347 if (SWIG_arg_fail(2)) SWIG_fail;
10348 }
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 (arg1)->SetType(arg2);
10352
10353 wxPyEndAllowThreads(__tstate);
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 Py_INCREF(Py_None); resultobj = Py_None;
10357 return resultobj;
10358 fail:
10359 return NULL;
10360 }
10361
10362
10363 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10364 PyObject *resultobj = NULL;
10365 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10366 wxString *arg2 = 0 ;
10367 bool temp2 = false ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char *kwnames[] = {
10371 (char *) "self",(char *) "mimetype", NULL
10372 };
10373
10374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10376 if (SWIG_arg_fail(1)) SWIG_fail;
10377 {
10378 arg2 = wxString_in_helper(obj1);
10379 if (arg2 == NULL) SWIG_fail;
10380 temp2 = true;
10381 }
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 (arg1)->SetMimeType((wxString const &)*arg2);
10385
10386 wxPyEndAllowThreads(__tstate);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 Py_INCREF(Py_None); resultobj = Py_None;
10390 {
10391 if (temp2)
10392 delete arg2;
10393 }
10394 return resultobj;
10395 fail:
10396 {
10397 if (temp2)
10398 delete arg2;
10399 }
10400 return NULL;
10401 }
10402
10403
10404 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10405 PyObject *obj;
10406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10407 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10408 Py_INCREF(obj);
10409 return Py_BuildValue((char *)"");
10410 }
10411 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10412 PyObject *resultobj = NULL;
10413 wxPyImageHandler *result;
10414 char *kwnames[] = {
10415 NULL
10416 };
10417
10418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 result = (wxPyImageHandler *)new wxPyImageHandler();
10422
10423 wxPyEndAllowThreads(__tstate);
10424 if (PyErr_Occurred()) SWIG_fail;
10425 }
10426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10427 return resultobj;
10428 fail:
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10434 PyObject *resultobj = NULL;
10435 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10436 PyObject *arg2 = (PyObject *) 0 ;
10437 PyObject * obj0 = 0 ;
10438 PyObject * obj1 = 0 ;
10439 char *kwnames[] = {
10440 (char *) "self",(char *) "self", NULL
10441 };
10442
10443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10445 if (SWIG_arg_fail(1)) SWIG_fail;
10446 arg2 = obj1;
10447 {
10448 PyThreadState* __tstate = wxPyBeginAllowThreads();
10449 (arg1)->_SetSelf(arg2);
10450
10451 wxPyEndAllowThreads(__tstate);
10452 if (PyErr_Occurred()) SWIG_fail;
10453 }
10454 Py_INCREF(Py_None); resultobj = Py_None;
10455 return resultobj;
10456 fail:
10457 return NULL;
10458 }
10459
10460
10461 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10462 PyObject *obj;
10463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10464 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10465 Py_INCREF(obj);
10466 return Py_BuildValue((char *)"");
10467 }
10468 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10469 PyObject *resultobj = NULL;
10470 wxImageHistogram *result;
10471 char *kwnames[] = {
10472 NULL
10473 };
10474
10475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10476 {
10477 PyThreadState* __tstate = wxPyBeginAllowThreads();
10478 result = (wxImageHistogram *)new wxImageHistogram();
10479
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10484 return resultobj;
10485 fail:
10486 return NULL;
10487 }
10488
10489
10490 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = NULL;
10492 byte arg1 ;
10493 byte arg2 ;
10494 byte arg3 ;
10495 unsigned long result;
10496 PyObject * obj0 = 0 ;
10497 PyObject * obj1 = 0 ;
10498 PyObject * obj2 = 0 ;
10499 char *kwnames[] = {
10500 (char *) "r",(char *) "g",(char *) "b", NULL
10501 };
10502
10503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10504 {
10505 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10506 if (SWIG_arg_fail(1)) SWIG_fail;
10507 }
10508 {
10509 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10510 if (SWIG_arg_fail(2)) SWIG_fail;
10511 }
10512 {
10513 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10514 if (SWIG_arg_fail(3)) SWIG_fail;
10515 }
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10519
10520 wxPyEndAllowThreads(__tstate);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 {
10524 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10525 }
10526 return resultobj;
10527 fail:
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj = NULL;
10534 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10535 byte *arg2 = (byte *) 0 ;
10536 byte *arg3 = (byte *) 0 ;
10537 byte *arg4 = (byte *) 0 ;
10538 byte arg5 = (byte) 1 ;
10539 byte arg6 = (byte) 0 ;
10540 byte arg7 = (byte) 0 ;
10541 bool result;
10542 byte temp2 ;
10543 int res2 = 0 ;
10544 byte temp3 ;
10545 int res3 = 0 ;
10546 byte temp4 ;
10547 int res4 = 0 ;
10548 PyObject * obj0 = 0 ;
10549 PyObject * obj1 = 0 ;
10550 PyObject * obj2 = 0 ;
10551 PyObject * obj3 = 0 ;
10552 char *kwnames[] = {
10553 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10554 };
10555
10556 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10557 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10558 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10561 if (SWIG_arg_fail(1)) SWIG_fail;
10562 if (obj1) {
10563 {
10564 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10565 if (SWIG_arg_fail(5)) SWIG_fail;
10566 }
10567 }
10568 if (obj2) {
10569 {
10570 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10571 if (SWIG_arg_fail(6)) SWIG_fail;
10572 }
10573 }
10574 if (obj3) {
10575 {
10576 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10577 if (SWIG_arg_fail(7)) SWIG_fail;
10578 }
10579 }
10580 {
10581 PyThreadState* __tstate = wxPyBeginAllowThreads();
10582 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10583
10584 wxPyEndAllowThreads(__tstate);
10585 if (PyErr_Occurred()) SWIG_fail;
10586 }
10587 {
10588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10589 }
10590 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10591 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10592 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10593 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10594 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10595 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10603 PyObject *resultobj = NULL;
10604 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10605 unsigned long arg2 ;
10606 unsigned long result;
10607 PyObject * obj0 = 0 ;
10608 PyObject * obj1 = 0 ;
10609 char *kwnames[] = {
10610 (char *) "self",(char *) "key", NULL
10611 };
10612
10613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10615 if (SWIG_arg_fail(1)) SWIG_fail;
10616 {
10617 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10618 if (SWIG_arg_fail(2)) SWIG_fail;
10619 }
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10623
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 {
10628 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10629 }
10630 return resultobj;
10631 fail:
10632 return NULL;
10633 }
10634
10635
10636 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10637 PyObject *resultobj = NULL;
10638 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10639 byte arg2 ;
10640 byte arg3 ;
10641 byte arg4 ;
10642 unsigned long result;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 PyObject * obj2 = 0 ;
10646 PyObject * obj3 = 0 ;
10647 char *kwnames[] = {
10648 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10649 };
10650
10651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10653 if (SWIG_arg_fail(1)) SWIG_fail;
10654 {
10655 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10656 if (SWIG_arg_fail(2)) SWIG_fail;
10657 }
10658 {
10659 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10660 if (SWIG_arg_fail(3)) SWIG_fail;
10661 }
10662 {
10663 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10664 if (SWIG_arg_fail(4)) SWIG_fail;
10665 }
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10669
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 {
10674 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10675 }
10676 return resultobj;
10677 fail:
10678 return NULL;
10679 }
10680
10681
10682 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10683 PyObject *resultobj = NULL;
10684 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10685 wxColour *arg2 = 0 ;
10686 unsigned long result;
10687 wxColour temp2 ;
10688 PyObject * obj0 = 0 ;
10689 PyObject * obj1 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self",(char *) "colour", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 {
10698 arg2 = &temp2;
10699 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10700 }
10701 {
10702 PyThreadState* __tstate = wxPyBeginAllowThreads();
10703 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10704
10705 wxPyEndAllowThreads(__tstate);
10706 if (PyErr_Occurred()) SWIG_fail;
10707 }
10708 {
10709 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10710 }
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10718 PyObject *obj;
10719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10720 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10721 Py_INCREF(obj);
10722 return Py_BuildValue((char *)"");
10723 }
10724 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10725 PyObject *resultobj = NULL;
10726 byte arg1 = (byte) 0 ;
10727 byte arg2 = (byte) 0 ;
10728 byte arg3 = (byte) 0 ;
10729 wxImage_RGBValue *result;
10730 PyObject * obj0 = 0 ;
10731 PyObject * obj1 = 0 ;
10732 PyObject * obj2 = 0 ;
10733 char *kwnames[] = {
10734 (char *) "r",(char *) "g",(char *) "b", NULL
10735 };
10736
10737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10738 if (obj0) {
10739 {
10740 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10741 if (SWIG_arg_fail(1)) SWIG_fail;
10742 }
10743 }
10744 if (obj1) {
10745 {
10746 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10747 if (SWIG_arg_fail(2)) SWIG_fail;
10748 }
10749 }
10750 if (obj2) {
10751 {
10752 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10753 if (SWIG_arg_fail(3)) SWIG_fail;
10754 }
10755 }
10756 {
10757 PyThreadState* __tstate = wxPyBeginAllowThreads();
10758 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10759
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj = NULL;
10772 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10773 byte arg2 ;
10774 PyObject * obj0 = 0 ;
10775 PyObject * obj1 = 0 ;
10776 char *kwnames[] = {
10777 (char *) "self",(char *) "red", NULL
10778 };
10779
10780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10782 if (SWIG_arg_fail(1)) SWIG_fail;
10783 {
10784 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10785 if (SWIG_arg_fail(2)) SWIG_fail;
10786 }
10787 if (arg1) (arg1)->red = arg2;
10788
10789 Py_INCREF(Py_None); resultobj = Py_None;
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj = NULL;
10798 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10799 byte result;
10800 PyObject * obj0 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "self", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 result = (byte) ((arg1)->red);
10809
10810 {
10811 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10812 }
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = NULL;
10821 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10822 byte arg2 ;
10823 PyObject * obj0 = 0 ;
10824 PyObject * obj1 = 0 ;
10825 char *kwnames[] = {
10826 (char *) "self",(char *) "green", NULL
10827 };
10828
10829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10831 if (SWIG_arg_fail(1)) SWIG_fail;
10832 {
10833 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10834 if (SWIG_arg_fail(2)) SWIG_fail;
10835 }
10836 if (arg1) (arg1)->green = arg2;
10837
10838 Py_INCREF(Py_None); resultobj = Py_None;
10839 return resultobj;
10840 fail:
10841 return NULL;
10842 }
10843
10844
10845 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10846 PyObject *resultobj = NULL;
10847 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10848 byte result;
10849 PyObject * obj0 = 0 ;
10850 char *kwnames[] = {
10851 (char *) "self", NULL
10852 };
10853
10854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10856 if (SWIG_arg_fail(1)) SWIG_fail;
10857 result = (byte) ((arg1)->green);
10858
10859 {
10860 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10861 }
10862 return resultobj;
10863 fail:
10864 return NULL;
10865 }
10866
10867
10868 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10869 PyObject *resultobj = NULL;
10870 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10871 byte arg2 ;
10872 PyObject * obj0 = 0 ;
10873 PyObject * obj1 = 0 ;
10874 char *kwnames[] = {
10875 (char *) "self",(char *) "blue", NULL
10876 };
10877
10878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10880 if (SWIG_arg_fail(1)) SWIG_fail;
10881 {
10882 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10883 if (SWIG_arg_fail(2)) SWIG_fail;
10884 }
10885 if (arg1) (arg1)->blue = arg2;
10886
10887 Py_INCREF(Py_None); resultobj = Py_None;
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10895 PyObject *resultobj = NULL;
10896 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10897 byte result;
10898 PyObject * obj0 = 0 ;
10899 char *kwnames[] = {
10900 (char *) "self", NULL
10901 };
10902
10903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10905 if (SWIG_arg_fail(1)) SWIG_fail;
10906 result = (byte) ((arg1)->blue);
10907
10908 {
10909 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10910 }
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10918 PyObject *obj;
10919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10920 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10921 Py_INCREF(obj);
10922 return Py_BuildValue((char *)"");
10923 }
10924 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10925 PyObject *resultobj = NULL;
10926 double arg1 = (double) 0.0 ;
10927 double arg2 = (double) 0.0 ;
10928 double arg3 = (double) 0.0 ;
10929 wxImage_HSVValue *result;
10930 PyObject * obj0 = 0 ;
10931 PyObject * obj1 = 0 ;
10932 PyObject * obj2 = 0 ;
10933 char *kwnames[] = {
10934 (char *) "h",(char *) "s",(char *) "v", NULL
10935 };
10936
10937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10938 if (obj0) {
10939 {
10940 arg1 = static_cast<double >(SWIG_As_double(obj0));
10941 if (SWIG_arg_fail(1)) SWIG_fail;
10942 }
10943 }
10944 if (obj1) {
10945 {
10946 arg2 = static_cast<double >(SWIG_As_double(obj1));
10947 if (SWIG_arg_fail(2)) SWIG_fail;
10948 }
10949 }
10950 if (obj2) {
10951 {
10952 arg3 = static_cast<double >(SWIG_As_double(obj2));
10953 if (SWIG_arg_fail(3)) SWIG_fail;
10954 }
10955 }
10956 {
10957 PyThreadState* __tstate = wxPyBeginAllowThreads();
10958 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10959
10960 wxPyEndAllowThreads(__tstate);
10961 if (PyErr_Occurred()) SWIG_fail;
10962 }
10963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10971 PyObject *resultobj = NULL;
10972 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10973 double arg2 ;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 char *kwnames[] = {
10977 (char *) "self",(char *) "hue", NULL
10978 };
10979
10980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10982 if (SWIG_arg_fail(1)) SWIG_fail;
10983 {
10984 arg2 = static_cast<double >(SWIG_As_double(obj1));
10985 if (SWIG_arg_fail(2)) SWIG_fail;
10986 }
10987 if (arg1) (arg1)->hue = arg2;
10988
10989 Py_INCREF(Py_None); resultobj = Py_None;
10990 return resultobj;
10991 fail:
10992 return NULL;
10993 }
10994
10995
10996 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10997 PyObject *resultobj = NULL;
10998 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10999 double result;
11000 PyObject * obj0 = 0 ;
11001 char *kwnames[] = {
11002 (char *) "self", NULL
11003 };
11004
11005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
11006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11007 if (SWIG_arg_fail(1)) SWIG_fail;
11008 result = (double) ((arg1)->hue);
11009
11010 {
11011 resultobj = SWIG_From_double(static_cast<double >(result));
11012 }
11013 return resultobj;
11014 fail:
11015 return NULL;
11016 }
11017
11018
11019 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
11020 PyObject *resultobj = NULL;
11021 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11022 double arg2 ;
11023 PyObject * obj0 = 0 ;
11024 PyObject * obj1 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "self",(char *) "saturation", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
11030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11031 if (SWIG_arg_fail(1)) SWIG_fail;
11032 {
11033 arg2 = static_cast<double >(SWIG_As_double(obj1));
11034 if (SWIG_arg_fail(2)) SWIG_fail;
11035 }
11036 if (arg1) (arg1)->saturation = arg2;
11037
11038 Py_INCREF(Py_None); resultobj = Py_None;
11039 return resultobj;
11040 fail:
11041 return NULL;
11042 }
11043
11044
11045 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
11046 PyObject *resultobj = NULL;
11047 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11048 double result;
11049 PyObject * obj0 = 0 ;
11050 char *kwnames[] = {
11051 (char *) "self", NULL
11052 };
11053
11054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
11055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11056 if (SWIG_arg_fail(1)) SWIG_fail;
11057 result = (double) ((arg1)->saturation);
11058
11059 {
11060 resultobj = SWIG_From_double(static_cast<double >(result));
11061 }
11062 return resultobj;
11063 fail:
11064 return NULL;
11065 }
11066
11067
11068 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj = NULL;
11070 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11071 double arg2 ;
11072 PyObject * obj0 = 0 ;
11073 PyObject * obj1 = 0 ;
11074 char *kwnames[] = {
11075 (char *) "self",(char *) "value", NULL
11076 };
11077
11078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11080 if (SWIG_arg_fail(1)) SWIG_fail;
11081 {
11082 arg2 = static_cast<double >(SWIG_As_double(obj1));
11083 if (SWIG_arg_fail(2)) SWIG_fail;
11084 }
11085 if (arg1) (arg1)->value = arg2;
11086
11087 Py_INCREF(Py_None); resultobj = Py_None;
11088 return resultobj;
11089 fail:
11090 return NULL;
11091 }
11092
11093
11094 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11095 PyObject *resultobj = NULL;
11096 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11097 double result;
11098 PyObject * obj0 = 0 ;
11099 char *kwnames[] = {
11100 (char *) "self", NULL
11101 };
11102
11103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11105 if (SWIG_arg_fail(1)) SWIG_fail;
11106 result = (double) ((arg1)->value);
11107
11108 {
11109 resultobj = SWIG_From_double(static_cast<double >(result));
11110 }
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11118 PyObject *obj;
11119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11120 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11121 Py_INCREF(obj);
11122 return Py_BuildValue((char *)"");
11123 }
11124 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11125 PyObject *resultobj = NULL;
11126 wxString *arg1 = 0 ;
11127 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11128 int arg3 = (int) -1 ;
11129 wxImage *result;
11130 bool temp1 = false ;
11131 PyObject * obj0 = 0 ;
11132 PyObject * obj1 = 0 ;
11133 PyObject * obj2 = 0 ;
11134 char *kwnames[] = {
11135 (char *) "name",(char *) "type",(char *) "index", NULL
11136 };
11137
11138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11139 {
11140 arg1 = wxString_in_helper(obj0);
11141 if (arg1 == NULL) SWIG_fail;
11142 temp1 = true;
11143 }
11144 if (obj1) {
11145 {
11146 arg2 = static_cast<long >(SWIG_As_long(obj1));
11147 if (SWIG_arg_fail(2)) SWIG_fail;
11148 }
11149 }
11150 if (obj2) {
11151 {
11152 arg3 = static_cast<int >(SWIG_As_int(obj2));
11153 if (SWIG_arg_fail(3)) SWIG_fail;
11154 }
11155 }
11156 {
11157 PyThreadState* __tstate = wxPyBeginAllowThreads();
11158 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11159
11160 wxPyEndAllowThreads(__tstate);
11161 if (PyErr_Occurred()) SWIG_fail;
11162 }
11163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11164 {
11165 if (temp1)
11166 delete arg1;
11167 }
11168 return resultobj;
11169 fail:
11170 {
11171 if (temp1)
11172 delete arg1;
11173 }
11174 return NULL;
11175 }
11176
11177
11178 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11179 PyObject *resultobj = NULL;
11180 wxImage *arg1 = (wxImage *) 0 ;
11181 PyObject * obj0 = 0 ;
11182 char *kwnames[] = {
11183 (char *) "self", NULL
11184 };
11185
11186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11188 if (SWIG_arg_fail(1)) SWIG_fail;
11189 {
11190 PyThreadState* __tstate = wxPyBeginAllowThreads();
11191 delete arg1;
11192
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 Py_INCREF(Py_None); resultobj = Py_None;
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11204 PyObject *resultobj = NULL;
11205 wxString *arg1 = 0 ;
11206 wxString *arg2 = 0 ;
11207 int arg3 = (int) -1 ;
11208 wxImage *result;
11209 bool temp1 = false ;
11210 bool temp2 = false ;
11211 PyObject * obj0 = 0 ;
11212 PyObject * obj1 = 0 ;
11213 PyObject * obj2 = 0 ;
11214 char *kwnames[] = {
11215 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11216 };
11217
11218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11219 {
11220 arg1 = wxString_in_helper(obj0);
11221 if (arg1 == NULL) SWIG_fail;
11222 temp1 = true;
11223 }
11224 {
11225 arg2 = wxString_in_helper(obj1);
11226 if (arg2 == NULL) SWIG_fail;
11227 temp2 = true;
11228 }
11229 if (obj2) {
11230 {
11231 arg3 = static_cast<int >(SWIG_As_int(obj2));
11232 if (SWIG_arg_fail(3)) SWIG_fail;
11233 }
11234 }
11235 {
11236 PyThreadState* __tstate = wxPyBeginAllowThreads();
11237 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11238
11239 wxPyEndAllowThreads(__tstate);
11240 if (PyErr_Occurred()) SWIG_fail;
11241 }
11242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11243 {
11244 if (temp1)
11245 delete arg1;
11246 }
11247 {
11248 if (temp2)
11249 delete arg2;
11250 }
11251 return resultobj;
11252 fail:
11253 {
11254 if (temp1)
11255 delete arg1;
11256 }
11257 {
11258 if (temp2)
11259 delete arg2;
11260 }
11261 return NULL;
11262 }
11263
11264
11265 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11266 PyObject *resultobj = NULL;
11267 wxInputStream *arg1 = 0 ;
11268 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11269 int arg3 = (int) -1 ;
11270 wxImage *result;
11271 wxPyInputStream *temp1 ;
11272 bool created1 ;
11273 PyObject * obj0 = 0 ;
11274 PyObject * obj1 = 0 ;
11275 PyObject * obj2 = 0 ;
11276 char *kwnames[] = {
11277 (char *) "stream",(char *) "type",(char *) "index", NULL
11278 };
11279
11280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11281 {
11282 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11283 arg1 = temp1->m_wxis;
11284 created1 = false;
11285 } else {
11286 PyErr_Clear(); // clear the failure of the wxPyConvert above
11287 arg1 = wxPyCBInputStream_create(obj0, false);
11288 if (arg1 == NULL) {
11289 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11290 SWIG_fail;
11291 }
11292 created1 = true;
11293 }
11294 }
11295 if (obj1) {
11296 {
11297 arg2 = static_cast<long >(SWIG_As_long(obj1));
11298 if (SWIG_arg_fail(2)) SWIG_fail;
11299 }
11300 }
11301 if (obj2) {
11302 {
11303 arg3 = static_cast<int >(SWIG_As_int(obj2));
11304 if (SWIG_arg_fail(3)) SWIG_fail;
11305 }
11306 }
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11310
11311 wxPyEndAllowThreads(__tstate);
11312 if (PyErr_Occurred()) SWIG_fail;
11313 }
11314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11315 {
11316 if (created1) delete arg1;
11317 }
11318 return resultobj;
11319 fail:
11320 {
11321 if (created1) delete arg1;
11322 }
11323 return NULL;
11324 }
11325
11326
11327 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj = NULL;
11329 wxInputStream *arg1 = 0 ;
11330 wxString *arg2 = 0 ;
11331 int arg3 = (int) -1 ;
11332 wxImage *result;
11333 wxPyInputStream *temp1 ;
11334 bool created1 ;
11335 bool temp2 = false ;
11336 PyObject * obj0 = 0 ;
11337 PyObject * obj1 = 0 ;
11338 PyObject * obj2 = 0 ;
11339 char *kwnames[] = {
11340 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11341 };
11342
11343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11344 {
11345 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11346 arg1 = temp1->m_wxis;
11347 created1 = false;
11348 } else {
11349 PyErr_Clear(); // clear the failure of the wxPyConvert above
11350 arg1 = wxPyCBInputStream_create(obj0, false);
11351 if (arg1 == NULL) {
11352 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11353 SWIG_fail;
11354 }
11355 created1 = true;
11356 }
11357 }
11358 {
11359 arg2 = wxString_in_helper(obj1);
11360 if (arg2 == NULL) SWIG_fail;
11361 temp2 = true;
11362 }
11363 if (obj2) {
11364 {
11365 arg3 = static_cast<int >(SWIG_As_int(obj2));
11366 if (SWIG_arg_fail(3)) SWIG_fail;
11367 }
11368 }
11369 {
11370 PyThreadState* __tstate = wxPyBeginAllowThreads();
11371 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11372
11373 wxPyEndAllowThreads(__tstate);
11374 if (PyErr_Occurred()) SWIG_fail;
11375 }
11376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11377 {
11378 if (created1) delete arg1;
11379 }
11380 {
11381 if (temp2)
11382 delete arg2;
11383 }
11384 return resultobj;
11385 fail:
11386 {
11387 if (created1) delete arg1;
11388 }
11389 {
11390 if (temp2)
11391 delete arg2;
11392 }
11393 return NULL;
11394 }
11395
11396
11397 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11398 PyObject *resultobj = NULL;
11399 int arg1 = (int) 0 ;
11400 int arg2 = (int) 0 ;
11401 bool arg3 = (bool) true ;
11402 wxImage *result;
11403 PyObject * obj0 = 0 ;
11404 PyObject * obj1 = 0 ;
11405 PyObject * obj2 = 0 ;
11406 char *kwnames[] = {
11407 (char *) "width",(char *) "height",(char *) "clear", NULL
11408 };
11409
11410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11411 if (obj0) {
11412 {
11413 arg1 = static_cast<int >(SWIG_As_int(obj0));
11414 if (SWIG_arg_fail(1)) SWIG_fail;
11415 }
11416 }
11417 if (obj1) {
11418 {
11419 arg2 = static_cast<int >(SWIG_As_int(obj1));
11420 if (SWIG_arg_fail(2)) SWIG_fail;
11421 }
11422 }
11423 if (obj2) {
11424 {
11425 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11426 if (SWIG_arg_fail(3)) SWIG_fail;
11427 }
11428 }
11429 {
11430 PyThreadState* __tstate = wxPyBeginAllowThreads();
11431 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11432
11433 wxPyEndAllowThreads(__tstate);
11434 if (PyErr_Occurred()) SWIG_fail;
11435 }
11436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11437 return resultobj;
11438 fail:
11439 return NULL;
11440 }
11441
11442
11443 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11444 PyObject *resultobj = NULL;
11445 wxBitmap *arg1 = 0 ;
11446 wxImage *result;
11447 PyObject * obj0 = 0 ;
11448 char *kwnames[] = {
11449 (char *) "bitmap", NULL
11450 };
11451
11452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11453 {
11454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11455 if (SWIG_arg_fail(1)) SWIG_fail;
11456 if (arg1 == NULL) {
11457 SWIG_null_ref("wxBitmap");
11458 }
11459 if (SWIG_arg_fail(1)) SWIG_fail;
11460 }
11461 {
11462 if (!wxPyCheckForApp()) SWIG_fail;
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11465
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11470 return resultobj;
11471 fail:
11472 return NULL;
11473 }
11474
11475
11476 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11477 PyObject *resultobj = NULL;
11478 int arg1 ;
11479 int arg2 ;
11480 buffer arg3 ;
11481 int arg4 ;
11482 wxImage *result;
11483 PyObject * obj0 = 0 ;
11484 PyObject * obj1 = 0 ;
11485 PyObject * obj2 = 0 ;
11486 char *kwnames[] = {
11487 (char *) "width",(char *) "height",(char *) "data", NULL
11488 };
11489
11490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11491 {
11492 arg1 = static_cast<int >(SWIG_As_int(obj0));
11493 if (SWIG_arg_fail(1)) SWIG_fail;
11494 }
11495 {
11496 arg2 = static_cast<int >(SWIG_As_int(obj1));
11497 if (SWIG_arg_fail(2)) SWIG_fail;
11498 }
11499 {
11500 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11501 }
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11505
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11510 return resultobj;
11511 fail:
11512 return NULL;
11513 }
11514
11515
11516 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11517 PyObject *resultobj = NULL;
11518 int arg1 ;
11519 int arg2 ;
11520 buffer arg3 ;
11521 int arg4 ;
11522 buffer arg5 ;
11523 int arg6 ;
11524 wxImage *result;
11525 PyObject * obj0 = 0 ;
11526 PyObject * obj1 = 0 ;
11527 PyObject * obj2 = 0 ;
11528 PyObject * obj3 = 0 ;
11529 char *kwnames[] = {
11530 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11531 };
11532
11533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11534 {
11535 arg1 = static_cast<int >(SWIG_As_int(obj0));
11536 if (SWIG_arg_fail(1)) SWIG_fail;
11537 }
11538 {
11539 arg2 = static_cast<int >(SWIG_As_int(obj1));
11540 if (SWIG_arg_fail(2)) SWIG_fail;
11541 }
11542 {
11543 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11544 }
11545 {
11546 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11547 }
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11551
11552 wxPyEndAllowThreads(__tstate);
11553 if (PyErr_Occurred()) SWIG_fail;
11554 }
11555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11556 return resultobj;
11557 fail:
11558 return NULL;
11559 }
11560
11561
11562 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11563 PyObject *resultobj = NULL;
11564 wxImage *arg1 = (wxImage *) 0 ;
11565 int arg2 ;
11566 int arg3 ;
11567 bool arg4 = (bool) true ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 PyObject * obj3 = 0 ;
11572 char *kwnames[] = {
11573 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11574 };
11575
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 {
11580 arg2 = static_cast<int >(SWIG_As_int(obj1));
11581 if (SWIG_arg_fail(2)) SWIG_fail;
11582 }
11583 {
11584 arg3 = static_cast<int >(SWIG_As_int(obj2));
11585 if (SWIG_arg_fail(3)) SWIG_fail;
11586 }
11587 if (obj3) {
11588 {
11589 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11590 if (SWIG_arg_fail(4)) SWIG_fail;
11591 }
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 (arg1)->Create(arg2,arg3,arg4);
11596
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 Py_INCREF(Py_None); resultobj = Py_None;
11601 return resultobj;
11602 fail:
11603 return NULL;
11604 }
11605
11606
11607 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11608 PyObject *resultobj = NULL;
11609 wxImage *arg1 = (wxImage *) 0 ;
11610 PyObject * obj0 = 0 ;
11611 char *kwnames[] = {
11612 (char *) "self", NULL
11613 };
11614
11615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11617 if (SWIG_arg_fail(1)) SWIG_fail;
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 (arg1)->Destroy();
11621
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 Py_INCREF(Py_None); resultobj = Py_None;
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj = NULL;
11634 wxImage *arg1 = (wxImage *) 0 ;
11635 int arg2 ;
11636 int arg3 ;
11637 SwigValueWrapper<wxImage > result;
11638 PyObject * obj0 = 0 ;
11639 PyObject * obj1 = 0 ;
11640 PyObject * obj2 = 0 ;
11641 char *kwnames[] = {
11642 (char *) "self",(char *) "width",(char *) "height", NULL
11643 };
11644
11645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(1)) SWIG_fail;
11648 {
11649 arg2 = static_cast<int >(SWIG_As_int(obj1));
11650 if (SWIG_arg_fail(2)) SWIG_fail;
11651 }
11652 {
11653 arg3 = static_cast<int >(SWIG_As_int(obj2));
11654 if (SWIG_arg_fail(3)) SWIG_fail;
11655 }
11656 {
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 result = (arg1)->Scale(arg2,arg3);
11659
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 {
11664 wxImage * resultptr;
11665 resultptr = new wxImage(static_cast<wxImage & >(result));
11666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11667 }
11668 return resultobj;
11669 fail:
11670 return NULL;
11671 }
11672
11673
11674 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11675 PyObject *resultobj = NULL;
11676 wxImage *arg1 = (wxImage *) 0 ;
11677 int arg2 ;
11678 int arg3 ;
11679 SwigValueWrapper<wxImage > result;
11680 PyObject * obj0 = 0 ;
11681 PyObject * obj1 = 0 ;
11682 PyObject * obj2 = 0 ;
11683 char *kwnames[] = {
11684 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11685 };
11686
11687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11689 if (SWIG_arg_fail(1)) SWIG_fail;
11690 {
11691 arg2 = static_cast<int >(SWIG_As_int(obj1));
11692 if (SWIG_arg_fail(2)) SWIG_fail;
11693 }
11694 {
11695 arg3 = static_cast<int >(SWIG_As_int(obj2));
11696 if (SWIG_arg_fail(3)) SWIG_fail;
11697 }
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11701
11702 wxPyEndAllowThreads(__tstate);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 {
11706 wxImage * resultptr;
11707 resultptr = new wxImage(static_cast<wxImage & >(result));
11708 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11717 PyObject *resultobj = NULL;
11718 wxImage *arg1 = (wxImage *) 0 ;
11719 int arg2 ;
11720 int arg3 ;
11721 wxImage *result;
11722 PyObject * obj0 = 0 ;
11723 PyObject * obj1 = 0 ;
11724 PyObject * obj2 = 0 ;
11725 char *kwnames[] = {
11726 (char *) "self",(char *) "width",(char *) "height", NULL
11727 };
11728
11729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11731 if (SWIG_arg_fail(1)) SWIG_fail;
11732 {
11733 arg2 = static_cast<int >(SWIG_As_int(obj1));
11734 if (SWIG_arg_fail(2)) SWIG_fail;
11735 }
11736 {
11737 arg3 = static_cast<int >(SWIG_As_int(obj2));
11738 if (SWIG_arg_fail(3)) SWIG_fail;
11739 }
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 {
11743 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11744 result = (wxImage *) &_result_ref;
11745 }
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11751 return resultobj;
11752 fail:
11753 return NULL;
11754 }
11755
11756
11757 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11758 PyObject *resultobj = NULL;
11759 wxImage *arg1 = (wxImage *) 0 ;
11760 wxSize *arg2 = 0 ;
11761 wxPoint *arg3 = 0 ;
11762 int arg4 = (int) -1 ;
11763 int arg5 = (int) -1 ;
11764 int arg6 = (int) -1 ;
11765 wxImage *result;
11766 wxSize temp2 ;
11767 wxPoint temp3 ;
11768 PyObject * obj0 = 0 ;
11769 PyObject * obj1 = 0 ;
11770 PyObject * obj2 = 0 ;
11771 PyObject * obj3 = 0 ;
11772 PyObject * obj4 = 0 ;
11773 PyObject * obj5 = 0 ;
11774 char *kwnames[] = {
11775 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11776 };
11777
11778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11780 if (SWIG_arg_fail(1)) SWIG_fail;
11781 {
11782 arg2 = &temp2;
11783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11784 }
11785 {
11786 arg3 = &temp3;
11787 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11788 }
11789 if (obj3) {
11790 {
11791 arg4 = static_cast<int >(SWIG_As_int(obj3));
11792 if (SWIG_arg_fail(4)) SWIG_fail;
11793 }
11794 }
11795 if (obj4) {
11796 {
11797 arg5 = static_cast<int >(SWIG_As_int(obj4));
11798 if (SWIG_arg_fail(5)) SWIG_fail;
11799 }
11800 }
11801 if (obj5) {
11802 {
11803 arg6 = static_cast<int >(SWIG_As_int(obj5));
11804 if (SWIG_arg_fail(6)) SWIG_fail;
11805 }
11806 }
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 {
11810 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11811 result = (wxImage *) &_result_ref;
11812 }
11813
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11818 return resultobj;
11819 fail:
11820 return NULL;
11821 }
11822
11823
11824 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11825 PyObject *resultobj = NULL;
11826 wxImage *arg1 = (wxImage *) 0 ;
11827 int arg2 ;
11828 int arg3 ;
11829 byte arg4 ;
11830 byte arg5 ;
11831 byte arg6 ;
11832 PyObject * obj0 = 0 ;
11833 PyObject * obj1 = 0 ;
11834 PyObject * obj2 = 0 ;
11835 PyObject * obj3 = 0 ;
11836 PyObject * obj4 = 0 ;
11837 PyObject * obj5 = 0 ;
11838 char *kwnames[] = {
11839 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11840 };
11841
11842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11844 if (SWIG_arg_fail(1)) SWIG_fail;
11845 {
11846 arg2 = static_cast<int >(SWIG_As_int(obj1));
11847 if (SWIG_arg_fail(2)) SWIG_fail;
11848 }
11849 {
11850 arg3 = static_cast<int >(SWIG_As_int(obj2));
11851 if (SWIG_arg_fail(3)) SWIG_fail;
11852 }
11853 {
11854 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11855 if (SWIG_arg_fail(4)) SWIG_fail;
11856 }
11857 {
11858 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11859 if (SWIG_arg_fail(5)) SWIG_fail;
11860 }
11861 {
11862 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11863 if (SWIG_arg_fail(6)) SWIG_fail;
11864 }
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
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_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11880 PyObject *resultobj = NULL;
11881 wxImage *arg1 = (wxImage *) 0 ;
11882 wxRect *arg2 = 0 ;
11883 byte arg3 ;
11884 byte arg4 ;
11885 byte arg5 ;
11886 wxRect temp2 ;
11887 PyObject * obj0 = 0 ;
11888 PyObject * obj1 = 0 ;
11889 PyObject * obj2 = 0 ;
11890 PyObject * obj3 = 0 ;
11891 PyObject * obj4 = 0 ;
11892 char *kwnames[] = {
11893 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11894 };
11895
11896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11898 if (SWIG_arg_fail(1)) SWIG_fail;
11899 {
11900 arg2 = &temp2;
11901 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11902 }
11903 {
11904 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11905 if (SWIG_arg_fail(3)) SWIG_fail;
11906 }
11907 {
11908 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11909 if (SWIG_arg_fail(4)) SWIG_fail;
11910 }
11911 {
11912 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11913 if (SWIG_arg_fail(5)) SWIG_fail;
11914 }
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11918
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 Py_INCREF(Py_None); resultobj = Py_None;
11923 return resultobj;
11924 fail:
11925 return NULL;
11926 }
11927
11928
11929 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11930 PyObject *resultobj = NULL;
11931 wxImage *arg1 = (wxImage *) 0 ;
11932 int arg2 ;
11933 int arg3 ;
11934 byte result;
11935 PyObject * obj0 = 0 ;
11936 PyObject * obj1 = 0 ;
11937 PyObject * obj2 = 0 ;
11938 char *kwnames[] = {
11939 (char *) "self",(char *) "x",(char *) "y", NULL
11940 };
11941
11942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11944 if (SWIG_arg_fail(1)) SWIG_fail;
11945 {
11946 arg2 = static_cast<int >(SWIG_As_int(obj1));
11947 if (SWIG_arg_fail(2)) SWIG_fail;
11948 }
11949 {
11950 arg3 = static_cast<int >(SWIG_As_int(obj2));
11951 if (SWIG_arg_fail(3)) SWIG_fail;
11952 }
11953 {
11954 PyThreadState* __tstate = wxPyBeginAllowThreads();
11955 result = (byte)(arg1)->GetRed(arg2,arg3);
11956
11957 wxPyEndAllowThreads(__tstate);
11958 if (PyErr_Occurred()) SWIG_fail;
11959 }
11960 {
11961 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11962 }
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj = NULL;
11971 wxImage *arg1 = (wxImage *) 0 ;
11972 int arg2 ;
11973 int arg3 ;
11974 byte result;
11975 PyObject * obj0 = 0 ;
11976 PyObject * obj1 = 0 ;
11977 PyObject * obj2 = 0 ;
11978 char *kwnames[] = {
11979 (char *) "self",(char *) "x",(char *) "y", NULL
11980 };
11981
11982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11984 if (SWIG_arg_fail(1)) SWIG_fail;
11985 {
11986 arg2 = static_cast<int >(SWIG_As_int(obj1));
11987 if (SWIG_arg_fail(2)) SWIG_fail;
11988 }
11989 {
11990 arg3 = static_cast<int >(SWIG_As_int(obj2));
11991 if (SWIG_arg_fail(3)) SWIG_fail;
11992 }
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 result = (byte)(arg1)->GetGreen(arg2,arg3);
11996
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12002 }
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12010 PyObject *resultobj = NULL;
12011 wxImage *arg1 = (wxImage *) 0 ;
12012 int arg2 ;
12013 int arg3 ;
12014 byte result;
12015 PyObject * obj0 = 0 ;
12016 PyObject * obj1 = 0 ;
12017 PyObject * obj2 = 0 ;
12018 char *kwnames[] = {
12019 (char *) "self",(char *) "x",(char *) "y", NULL
12020 };
12021
12022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12024 if (SWIG_arg_fail(1)) SWIG_fail;
12025 {
12026 arg2 = static_cast<int >(SWIG_As_int(obj1));
12027 if (SWIG_arg_fail(2)) SWIG_fail;
12028 }
12029 {
12030 arg3 = static_cast<int >(SWIG_As_int(obj2));
12031 if (SWIG_arg_fail(3)) SWIG_fail;
12032 }
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (byte)(arg1)->GetBlue(arg2,arg3);
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj = NULL;
12051 wxImage *arg1 = (wxImage *) 0 ;
12052 int arg2 ;
12053 int arg3 ;
12054 byte arg4 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 PyObject * obj2 = 0 ;
12058 PyObject * obj3 = 0 ;
12059 char *kwnames[] = {
12060 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12061 };
12062
12063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12065 if (SWIG_arg_fail(1)) SWIG_fail;
12066 {
12067 arg2 = static_cast<int >(SWIG_As_int(obj1));
12068 if (SWIG_arg_fail(2)) SWIG_fail;
12069 }
12070 {
12071 arg3 = static_cast<int >(SWIG_As_int(obj2));
12072 if (SWIG_arg_fail(3)) SWIG_fail;
12073 }
12074 {
12075 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12076 if (SWIG_arg_fail(4)) SWIG_fail;
12077 }
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 (arg1)->SetAlpha(arg2,arg3,arg4);
12081
12082 wxPyEndAllowThreads(__tstate);
12083 if (PyErr_Occurred()) SWIG_fail;
12084 }
12085 Py_INCREF(Py_None); resultobj = Py_None;
12086 return resultobj;
12087 fail:
12088 return NULL;
12089 }
12090
12091
12092 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12093 PyObject *resultobj = NULL;
12094 wxImage *arg1 = (wxImage *) 0 ;
12095 int arg2 ;
12096 int arg3 ;
12097 byte result;
12098 PyObject * obj0 = 0 ;
12099 PyObject * obj1 = 0 ;
12100 PyObject * obj2 = 0 ;
12101 char *kwnames[] = {
12102 (char *) "self",(char *) "x",(char *) "y", NULL
12103 };
12104
12105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12107 if (SWIG_arg_fail(1)) SWIG_fail;
12108 {
12109 arg2 = static_cast<int >(SWIG_As_int(obj1));
12110 if (SWIG_arg_fail(2)) SWIG_fail;
12111 }
12112 {
12113 arg3 = static_cast<int >(SWIG_As_int(obj2));
12114 if (SWIG_arg_fail(3)) SWIG_fail;
12115 }
12116 {
12117 PyThreadState* __tstate = wxPyBeginAllowThreads();
12118 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12119
12120 wxPyEndAllowThreads(__tstate);
12121 if (PyErr_Occurred()) SWIG_fail;
12122 }
12123 {
12124 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12125 }
12126 return resultobj;
12127 fail:
12128 return NULL;
12129 }
12130
12131
12132 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12133 PyObject *resultobj = NULL;
12134 wxImage *arg1 = (wxImage *) 0 ;
12135 bool result;
12136 PyObject * obj0 = 0 ;
12137 char *kwnames[] = {
12138 (char *) "self", NULL
12139 };
12140
12141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12143 if (SWIG_arg_fail(1)) SWIG_fail;
12144 {
12145 PyThreadState* __tstate = wxPyBeginAllowThreads();
12146 result = (bool)(arg1)->HasAlpha();
12147
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 {
12152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12153 }
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12161 PyObject *resultobj = NULL;
12162 wxImage *arg1 = (wxImage *) 0 ;
12163 PyObject * obj0 = 0 ;
12164 char *kwnames[] = {
12165 (char *) "self", NULL
12166 };
12167
12168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12170 if (SWIG_arg_fail(1)) SWIG_fail;
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 (arg1)->InitAlpha();
12174
12175 wxPyEndAllowThreads(__tstate);
12176 if (PyErr_Occurred()) SWIG_fail;
12177 }
12178 Py_INCREF(Py_None); resultobj = Py_None;
12179 return resultobj;
12180 fail:
12181 return NULL;
12182 }
12183
12184
12185 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12186 PyObject *resultobj = NULL;
12187 wxImage *arg1 = (wxImage *) 0 ;
12188 int arg2 ;
12189 int arg3 ;
12190 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12191 bool result;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 PyObject * obj2 = 0 ;
12195 PyObject * obj3 = 0 ;
12196 char *kwnames[] = {
12197 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12198 };
12199
12200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12202 if (SWIG_arg_fail(1)) SWIG_fail;
12203 {
12204 arg2 = static_cast<int >(SWIG_As_int(obj1));
12205 if (SWIG_arg_fail(2)) SWIG_fail;
12206 }
12207 {
12208 arg3 = static_cast<int >(SWIG_As_int(obj2));
12209 if (SWIG_arg_fail(3)) SWIG_fail;
12210 }
12211 if (obj3) {
12212 {
12213 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12214 if (SWIG_arg_fail(4)) SWIG_fail;
12215 }
12216 }
12217 {
12218 PyThreadState* __tstate = wxPyBeginAllowThreads();
12219 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12220
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 {
12225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12226 }
12227 return resultobj;
12228 fail:
12229 return NULL;
12230 }
12231
12232
12233 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12234 PyObject *resultobj = NULL;
12235 wxImage *arg1 = (wxImage *) 0 ;
12236 byte *arg2 = (byte *) 0 ;
12237 byte *arg3 = (byte *) 0 ;
12238 byte *arg4 = (byte *) 0 ;
12239 byte arg5 = (byte) 0 ;
12240 byte arg6 = (byte) 0 ;
12241 byte arg7 = (byte) 0 ;
12242 bool result;
12243 byte temp2 ;
12244 int res2 = 0 ;
12245 byte temp3 ;
12246 int res3 = 0 ;
12247 byte temp4 ;
12248 int res4 = 0 ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 PyObject * obj2 = 0 ;
12252 PyObject * obj3 = 0 ;
12253 char *kwnames[] = {
12254 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12255 };
12256
12257 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12258 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12259 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12262 if (SWIG_arg_fail(1)) SWIG_fail;
12263 if (obj1) {
12264 {
12265 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12266 if (SWIG_arg_fail(5)) SWIG_fail;
12267 }
12268 }
12269 if (obj2) {
12270 {
12271 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12272 if (SWIG_arg_fail(6)) SWIG_fail;
12273 }
12274 }
12275 if (obj3) {
12276 {
12277 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12278 if (SWIG_arg_fail(7)) SWIG_fail;
12279 }
12280 }
12281 {
12282 PyThreadState* __tstate = wxPyBeginAllowThreads();
12283 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12284
12285 wxPyEndAllowThreads(__tstate);
12286 if (PyErr_Occurred()) SWIG_fail;
12287 }
12288 {
12289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12290 }
12291 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12292 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12293 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12294 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12295 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12296 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12304 PyObject *resultobj = NULL;
12305 wxImage *arg1 = (wxImage *) 0 ;
12306 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12307 bool result;
12308 PyObject * obj0 = 0 ;
12309 PyObject * obj1 = 0 ;
12310 char *kwnames[] = {
12311 (char *) "self",(char *) "threshold", NULL
12312 };
12313
12314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12316 if (SWIG_arg_fail(1)) SWIG_fail;
12317 if (obj1) {
12318 {
12319 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12320 if (SWIG_arg_fail(2)) SWIG_fail;
12321 }
12322 }
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12326
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 {
12331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12332 }
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj = NULL;
12341 wxImage *arg1 = (wxImage *) 0 ;
12342 byte arg2 ;
12343 byte arg3 ;
12344 byte arg4 ;
12345 bool result;
12346 PyObject * obj0 = 0 ;
12347 PyObject * obj1 = 0 ;
12348 PyObject * obj2 = 0 ;
12349 PyObject * obj3 = 0 ;
12350 char *kwnames[] = {
12351 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12352 };
12353
12354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12356 if (SWIG_arg_fail(1)) SWIG_fail;
12357 {
12358 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12359 if (SWIG_arg_fail(2)) SWIG_fail;
12360 }
12361 {
12362 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12363 if (SWIG_arg_fail(3)) SWIG_fail;
12364 }
12365 {
12366 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12367 if (SWIG_arg_fail(4)) SWIG_fail;
12368 }
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = NULL;
12387 wxImage *arg1 = (wxImage *) 0 ;
12388 wxImage *arg2 = 0 ;
12389 byte arg3 ;
12390 byte arg4 ;
12391 byte arg5 ;
12392 bool result;
12393 PyObject * obj0 = 0 ;
12394 PyObject * obj1 = 0 ;
12395 PyObject * obj2 = 0 ;
12396 PyObject * obj3 = 0 ;
12397 PyObject * obj4 = 0 ;
12398 char *kwnames[] = {
12399 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12400 };
12401
12402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12404 if (SWIG_arg_fail(1)) SWIG_fail;
12405 {
12406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12407 if (SWIG_arg_fail(2)) SWIG_fail;
12408 if (arg2 == NULL) {
12409 SWIG_null_ref("wxImage");
12410 }
12411 if (SWIG_arg_fail(2)) SWIG_fail;
12412 }
12413 {
12414 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12415 if (SWIG_arg_fail(3)) SWIG_fail;
12416 }
12417 {
12418 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12419 if (SWIG_arg_fail(4)) SWIG_fail;
12420 }
12421 {
12422 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12423 if (SWIG_arg_fail(5)) SWIG_fail;
12424 }
12425 {
12426 PyThreadState* __tstate = wxPyBeginAllowThreads();
12427 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12428
12429 wxPyEndAllowThreads(__tstate);
12430 if (PyErr_Occurred()) SWIG_fail;
12431 }
12432 {
12433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12434 }
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj = NULL;
12443 wxString *arg1 = 0 ;
12444 bool result;
12445 bool temp1 = false ;
12446 PyObject * obj0 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "filename", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12452 {
12453 arg1 = wxString_in_helper(obj0);
12454 if (arg1 == NULL) SWIG_fail;
12455 temp1 = true;
12456 }
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12460
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 {
12465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12466 }
12467 {
12468 if (temp1)
12469 delete arg1;
12470 }
12471 return resultobj;
12472 fail:
12473 {
12474 if (temp1)
12475 delete arg1;
12476 }
12477 return NULL;
12478 }
12479
12480
12481 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12482 PyObject *resultobj = NULL;
12483 wxString *arg1 = 0 ;
12484 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12485 int result;
12486 bool temp1 = false ;
12487 PyObject * obj0 = 0 ;
12488 PyObject * obj1 = 0 ;
12489 char *kwnames[] = {
12490 (char *) "filename",(char *) "type", NULL
12491 };
12492
12493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12494 {
12495 arg1 = wxString_in_helper(obj0);
12496 if (arg1 == NULL) SWIG_fail;
12497 temp1 = true;
12498 }
12499 if (obj1) {
12500 {
12501 arg2 = static_cast<long >(SWIG_As_long(obj1));
12502 if (SWIG_arg_fail(2)) SWIG_fail;
12503 }
12504 }
12505 {
12506 PyThreadState* __tstate = wxPyBeginAllowThreads();
12507 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12508
12509 wxPyEndAllowThreads(__tstate);
12510 if (PyErr_Occurred()) SWIG_fail;
12511 }
12512 {
12513 resultobj = SWIG_From_int(static_cast<int >(result));
12514 }
12515 {
12516 if (temp1)
12517 delete arg1;
12518 }
12519 return resultobj;
12520 fail:
12521 {
12522 if (temp1)
12523 delete arg1;
12524 }
12525 return NULL;
12526 }
12527
12528
12529 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = NULL;
12531 wxImage *arg1 = (wxImage *) 0 ;
12532 wxString *arg2 = 0 ;
12533 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12534 int arg4 = (int) -1 ;
12535 bool result;
12536 bool temp2 = false ;
12537 PyObject * obj0 = 0 ;
12538 PyObject * obj1 = 0 ;
12539 PyObject * obj2 = 0 ;
12540 PyObject * obj3 = 0 ;
12541 char *kwnames[] = {
12542 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12543 };
12544
12545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12547 if (SWIG_arg_fail(1)) SWIG_fail;
12548 {
12549 arg2 = wxString_in_helper(obj1);
12550 if (arg2 == NULL) SWIG_fail;
12551 temp2 = true;
12552 }
12553 if (obj2) {
12554 {
12555 arg3 = static_cast<long >(SWIG_As_long(obj2));
12556 if (SWIG_arg_fail(3)) SWIG_fail;
12557 }
12558 }
12559 if (obj3) {
12560 {
12561 arg4 = static_cast<int >(SWIG_As_int(obj3));
12562 if (SWIG_arg_fail(4)) SWIG_fail;
12563 }
12564 }
12565 {
12566 PyThreadState* __tstate = wxPyBeginAllowThreads();
12567 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12568
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 {
12573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12574 }
12575 {
12576 if (temp2)
12577 delete arg2;
12578 }
12579 return resultobj;
12580 fail:
12581 {
12582 if (temp2)
12583 delete arg2;
12584 }
12585 return NULL;
12586 }
12587
12588
12589 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12590 PyObject *resultobj = NULL;
12591 wxImage *arg1 = (wxImage *) 0 ;
12592 wxString *arg2 = 0 ;
12593 wxString *arg3 = 0 ;
12594 int arg4 = (int) -1 ;
12595 bool result;
12596 bool temp2 = false ;
12597 bool temp3 = false ;
12598 PyObject * obj0 = 0 ;
12599 PyObject * obj1 = 0 ;
12600 PyObject * obj2 = 0 ;
12601 PyObject * obj3 = 0 ;
12602 char *kwnames[] = {
12603 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12604 };
12605
12606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12608 if (SWIG_arg_fail(1)) SWIG_fail;
12609 {
12610 arg2 = wxString_in_helper(obj1);
12611 if (arg2 == NULL) SWIG_fail;
12612 temp2 = true;
12613 }
12614 {
12615 arg3 = wxString_in_helper(obj2);
12616 if (arg3 == NULL) SWIG_fail;
12617 temp3 = true;
12618 }
12619 if (obj3) {
12620 {
12621 arg4 = static_cast<int >(SWIG_As_int(obj3));
12622 if (SWIG_arg_fail(4)) SWIG_fail;
12623 }
12624 }
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12628
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 {
12633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12634 }
12635 {
12636 if (temp2)
12637 delete arg2;
12638 }
12639 {
12640 if (temp3)
12641 delete arg3;
12642 }
12643 return resultobj;
12644 fail:
12645 {
12646 if (temp2)
12647 delete arg2;
12648 }
12649 {
12650 if (temp3)
12651 delete arg3;
12652 }
12653 return NULL;
12654 }
12655
12656
12657 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj = NULL;
12659 wxImage *arg1 = (wxImage *) 0 ;
12660 wxString *arg2 = 0 ;
12661 int arg3 ;
12662 bool result;
12663 bool temp2 = false ;
12664 PyObject * obj0 = 0 ;
12665 PyObject * obj1 = 0 ;
12666 PyObject * obj2 = 0 ;
12667 char *kwnames[] = {
12668 (char *) "self",(char *) "name",(char *) "type", NULL
12669 };
12670
12671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12673 if (SWIG_arg_fail(1)) SWIG_fail;
12674 {
12675 arg2 = wxString_in_helper(obj1);
12676 if (arg2 == NULL) SWIG_fail;
12677 temp2 = true;
12678 }
12679 {
12680 arg3 = static_cast<int >(SWIG_As_int(obj2));
12681 if (SWIG_arg_fail(3)) SWIG_fail;
12682 }
12683 {
12684 PyThreadState* __tstate = wxPyBeginAllowThreads();
12685 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12686
12687 wxPyEndAllowThreads(__tstate);
12688 if (PyErr_Occurred()) SWIG_fail;
12689 }
12690 {
12691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12692 }
12693 {
12694 if (temp2)
12695 delete arg2;
12696 }
12697 return resultobj;
12698 fail:
12699 {
12700 if (temp2)
12701 delete arg2;
12702 }
12703 return NULL;
12704 }
12705
12706
12707 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12708 PyObject *resultobj = NULL;
12709 wxImage *arg1 = (wxImage *) 0 ;
12710 wxString *arg2 = 0 ;
12711 wxString *arg3 = 0 ;
12712 bool result;
12713 bool temp2 = false ;
12714 bool temp3 = false ;
12715 PyObject * obj0 = 0 ;
12716 PyObject * obj1 = 0 ;
12717 PyObject * obj2 = 0 ;
12718 char *kwnames[] = {
12719 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12720 };
12721
12722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12724 if (SWIG_arg_fail(1)) SWIG_fail;
12725 {
12726 arg2 = wxString_in_helper(obj1);
12727 if (arg2 == NULL) SWIG_fail;
12728 temp2 = true;
12729 }
12730 {
12731 arg3 = wxString_in_helper(obj2);
12732 if (arg3 == NULL) SWIG_fail;
12733 temp3 = true;
12734 }
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12738
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 {
12743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12744 }
12745 {
12746 if (temp2)
12747 delete arg2;
12748 }
12749 {
12750 if (temp3)
12751 delete arg3;
12752 }
12753 return resultobj;
12754 fail:
12755 {
12756 if (temp2)
12757 delete arg2;
12758 }
12759 {
12760 if (temp3)
12761 delete arg3;
12762 }
12763 return NULL;
12764 }
12765
12766
12767 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12768 PyObject *resultobj = NULL;
12769 wxInputStream *arg1 = 0 ;
12770 bool result;
12771 wxPyInputStream *temp1 ;
12772 bool created1 ;
12773 PyObject * obj0 = 0 ;
12774 char *kwnames[] = {
12775 (char *) "stream", NULL
12776 };
12777
12778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12779 {
12780 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12781 arg1 = temp1->m_wxis;
12782 created1 = false;
12783 } else {
12784 PyErr_Clear(); // clear the failure of the wxPyConvert above
12785 arg1 = wxPyCBInputStream_create(obj0, false);
12786 if (arg1 == NULL) {
12787 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12788 SWIG_fail;
12789 }
12790 created1 = true;
12791 }
12792 }
12793 {
12794 PyThreadState* __tstate = wxPyBeginAllowThreads();
12795 result = (bool)wxImage::CanRead(*arg1);
12796
12797 wxPyEndAllowThreads(__tstate);
12798 if (PyErr_Occurred()) SWIG_fail;
12799 }
12800 {
12801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12802 }
12803 {
12804 if (created1) delete arg1;
12805 }
12806 return resultobj;
12807 fail:
12808 {
12809 if (created1) delete arg1;
12810 }
12811 return NULL;
12812 }
12813
12814
12815 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12816 PyObject *resultobj = NULL;
12817 wxImage *arg1 = (wxImage *) 0 ;
12818 wxInputStream *arg2 = 0 ;
12819 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12820 int arg4 = (int) -1 ;
12821 bool result;
12822 wxPyInputStream *temp2 ;
12823 bool created2 ;
12824 PyObject * obj0 = 0 ;
12825 PyObject * obj1 = 0 ;
12826 PyObject * obj2 = 0 ;
12827 PyObject * obj3 = 0 ;
12828 char *kwnames[] = {
12829 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12830 };
12831
12832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12834 if (SWIG_arg_fail(1)) SWIG_fail;
12835 {
12836 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12837 arg2 = temp2->m_wxis;
12838 created2 = false;
12839 } else {
12840 PyErr_Clear(); // clear the failure of the wxPyConvert above
12841 arg2 = wxPyCBInputStream_create(obj1, false);
12842 if (arg2 == NULL) {
12843 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12844 SWIG_fail;
12845 }
12846 created2 = true;
12847 }
12848 }
12849 if (obj2) {
12850 {
12851 arg3 = static_cast<long >(SWIG_As_long(obj2));
12852 if (SWIG_arg_fail(3)) SWIG_fail;
12853 }
12854 }
12855 if (obj3) {
12856 {
12857 arg4 = static_cast<int >(SWIG_As_int(obj3));
12858 if (SWIG_arg_fail(4)) SWIG_fail;
12859 }
12860 }
12861 {
12862 PyThreadState* __tstate = wxPyBeginAllowThreads();
12863 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12864
12865 wxPyEndAllowThreads(__tstate);
12866 if (PyErr_Occurred()) SWIG_fail;
12867 }
12868 {
12869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12870 }
12871 {
12872 if (created2) delete arg2;
12873 }
12874 return resultobj;
12875 fail:
12876 {
12877 if (created2) delete arg2;
12878 }
12879 return NULL;
12880 }
12881
12882
12883 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12884 PyObject *resultobj = NULL;
12885 wxImage *arg1 = (wxImage *) 0 ;
12886 wxInputStream *arg2 = 0 ;
12887 wxString *arg3 = 0 ;
12888 int arg4 = (int) -1 ;
12889 bool result;
12890 wxPyInputStream *temp2 ;
12891 bool created2 ;
12892 bool temp3 = false ;
12893 PyObject * obj0 = 0 ;
12894 PyObject * obj1 = 0 ;
12895 PyObject * obj2 = 0 ;
12896 PyObject * obj3 = 0 ;
12897 char *kwnames[] = {
12898 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12899 };
12900
12901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12903 if (SWIG_arg_fail(1)) SWIG_fail;
12904 {
12905 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12906 arg2 = temp2->m_wxis;
12907 created2 = false;
12908 } else {
12909 PyErr_Clear(); // clear the failure of the wxPyConvert above
12910 arg2 = wxPyCBInputStream_create(obj1, false);
12911 if (arg2 == NULL) {
12912 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12913 SWIG_fail;
12914 }
12915 created2 = true;
12916 }
12917 }
12918 {
12919 arg3 = wxString_in_helper(obj2);
12920 if (arg3 == NULL) SWIG_fail;
12921 temp3 = true;
12922 }
12923 if (obj3) {
12924 {
12925 arg4 = static_cast<int >(SWIG_As_int(obj3));
12926 if (SWIG_arg_fail(4)) SWIG_fail;
12927 }
12928 }
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 {
12937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12938 }
12939 {
12940 if (created2) delete arg2;
12941 }
12942 {
12943 if (temp3)
12944 delete arg3;
12945 }
12946 return resultobj;
12947 fail:
12948 {
12949 if (created2) delete arg2;
12950 }
12951 {
12952 if (temp3)
12953 delete arg3;
12954 }
12955 return NULL;
12956 }
12957
12958
12959 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj = NULL;
12961 wxImage *arg1 = (wxImage *) 0 ;
12962 bool result;
12963 PyObject * obj0 = 0 ;
12964 char *kwnames[] = {
12965 (char *) "self", NULL
12966 };
12967
12968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12970 if (SWIG_arg_fail(1)) SWIG_fail;
12971 {
12972 PyThreadState* __tstate = wxPyBeginAllowThreads();
12973 result = (bool)(arg1)->Ok();
12974
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12980 }
12981 return resultobj;
12982 fail:
12983 return NULL;
12984 }
12985
12986
12987 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12988 PyObject *resultobj = NULL;
12989 wxImage *arg1 = (wxImage *) 0 ;
12990 int result;
12991 PyObject * obj0 = 0 ;
12992 char *kwnames[] = {
12993 (char *) "self", NULL
12994 };
12995
12996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12998 if (SWIG_arg_fail(1)) SWIG_fail;
12999 {
13000 PyThreadState* __tstate = wxPyBeginAllowThreads();
13001 result = (int)(arg1)->GetWidth();
13002
13003 wxPyEndAllowThreads(__tstate);
13004 if (PyErr_Occurred()) SWIG_fail;
13005 }
13006 {
13007 resultobj = SWIG_From_int(static_cast<int >(result));
13008 }
13009 return resultobj;
13010 fail:
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj = NULL;
13017 wxImage *arg1 = (wxImage *) 0 ;
13018 int result;
13019 PyObject * obj0 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 result = (int)(arg1)->GetHeight();
13030
13031 wxPyEndAllowThreads(__tstate);
13032 if (PyErr_Occurred()) SWIG_fail;
13033 }
13034 {
13035 resultobj = SWIG_From_int(static_cast<int >(result));
13036 }
13037 return resultobj;
13038 fail:
13039 return NULL;
13040 }
13041
13042
13043 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj = NULL;
13045 wxImage *arg1 = (wxImage *) 0 ;
13046 wxSize result;
13047 PyObject * obj0 = 0 ;
13048 char *kwnames[] = {
13049 (char *) "self", NULL
13050 };
13051
13052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
13053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13054 if (SWIG_arg_fail(1)) SWIG_fail;
13055 {
13056 PyThreadState* __tstate = wxPyBeginAllowThreads();
13057 result = wxImage_GetSize(arg1);
13058
13059 wxPyEndAllowThreads(__tstate);
13060 if (PyErr_Occurred()) SWIG_fail;
13061 }
13062 {
13063 wxSize * resultptr;
13064 resultptr = new wxSize(static_cast<wxSize & >(result));
13065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13066 }
13067 return resultobj;
13068 fail:
13069 return NULL;
13070 }
13071
13072
13073 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13074 PyObject *resultobj = NULL;
13075 wxImage *arg1 = (wxImage *) 0 ;
13076 wxRect *arg2 = 0 ;
13077 SwigValueWrapper<wxImage > result;
13078 wxRect temp2 ;
13079 PyObject * obj0 = 0 ;
13080 PyObject * obj1 = 0 ;
13081 char *kwnames[] = {
13082 (char *) "self",(char *) "rect", NULL
13083 };
13084
13085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13087 if (SWIG_arg_fail(1)) SWIG_fail;
13088 {
13089 arg2 = &temp2;
13090 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13095
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 {
13100 wxImage * resultptr;
13101 resultptr = new wxImage(static_cast<wxImage & >(result));
13102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13103 }
13104 return resultobj;
13105 fail:
13106 return NULL;
13107 }
13108
13109
13110 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13111 PyObject *resultobj = NULL;
13112 wxImage *arg1 = (wxImage *) 0 ;
13113 wxSize *arg2 = 0 ;
13114 wxPoint *arg3 = 0 ;
13115 int arg4 = (int) -1 ;
13116 int arg5 = (int) -1 ;
13117 int arg6 = (int) -1 ;
13118 SwigValueWrapper<wxImage > result;
13119 wxSize temp2 ;
13120 wxPoint temp3 ;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 PyObject * obj2 = 0 ;
13124 PyObject * obj3 = 0 ;
13125 PyObject * obj4 = 0 ;
13126 PyObject * obj5 = 0 ;
13127 char *kwnames[] = {
13128 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13129 };
13130
13131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13133 if (SWIG_arg_fail(1)) SWIG_fail;
13134 {
13135 arg2 = &temp2;
13136 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13137 }
13138 {
13139 arg3 = &temp3;
13140 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13141 }
13142 if (obj3) {
13143 {
13144 arg4 = static_cast<int >(SWIG_As_int(obj3));
13145 if (SWIG_arg_fail(4)) SWIG_fail;
13146 }
13147 }
13148 if (obj4) {
13149 {
13150 arg5 = static_cast<int >(SWIG_As_int(obj4));
13151 if (SWIG_arg_fail(5)) SWIG_fail;
13152 }
13153 }
13154 if (obj5) {
13155 {
13156 arg6 = static_cast<int >(SWIG_As_int(obj5));
13157 if (SWIG_arg_fail(6)) SWIG_fail;
13158 }
13159 }
13160 {
13161 PyThreadState* __tstate = wxPyBeginAllowThreads();
13162 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13163
13164 wxPyEndAllowThreads(__tstate);
13165 if (PyErr_Occurred()) SWIG_fail;
13166 }
13167 {
13168 wxImage * resultptr;
13169 resultptr = new wxImage(static_cast<wxImage & >(result));
13170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13171 }
13172 return resultobj;
13173 fail:
13174 return NULL;
13175 }
13176
13177
13178 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13179 PyObject *resultobj = NULL;
13180 wxImage *arg1 = (wxImage *) 0 ;
13181 SwigValueWrapper<wxImage > result;
13182 PyObject * obj0 = 0 ;
13183 char *kwnames[] = {
13184 (char *) "self", NULL
13185 };
13186
13187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13189 if (SWIG_arg_fail(1)) SWIG_fail;
13190 {
13191 PyThreadState* __tstate = wxPyBeginAllowThreads();
13192 result = (arg1)->Copy();
13193
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 {
13198 wxImage * resultptr;
13199 resultptr = new wxImage(static_cast<wxImage & >(result));
13200 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13201 }
13202 return resultobj;
13203 fail:
13204 return NULL;
13205 }
13206
13207
13208 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13209 PyObject *resultobj = NULL;
13210 wxImage *arg1 = (wxImage *) 0 ;
13211 wxImage *arg2 = 0 ;
13212 int arg3 ;
13213 int arg4 ;
13214 PyObject * obj0 = 0 ;
13215 PyObject * obj1 = 0 ;
13216 PyObject * obj2 = 0 ;
13217 PyObject * obj3 = 0 ;
13218 char *kwnames[] = {
13219 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13220 };
13221
13222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13224 if (SWIG_arg_fail(1)) SWIG_fail;
13225 {
13226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13227 if (SWIG_arg_fail(2)) SWIG_fail;
13228 if (arg2 == NULL) {
13229 SWIG_null_ref("wxImage");
13230 }
13231 if (SWIG_arg_fail(2)) SWIG_fail;
13232 }
13233 {
13234 arg3 = static_cast<int >(SWIG_As_int(obj2));
13235 if (SWIG_arg_fail(3)) SWIG_fail;
13236 }
13237 {
13238 arg4 = static_cast<int >(SWIG_As_int(obj3));
13239 if (SWIG_arg_fail(4)) SWIG_fail;
13240 }
13241 {
13242 PyThreadState* __tstate = wxPyBeginAllowThreads();
13243 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13244
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 Py_INCREF(Py_None); resultobj = Py_None;
13249 return resultobj;
13250 fail:
13251 return NULL;
13252 }
13253
13254
13255 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13256 PyObject *resultobj = NULL;
13257 wxImage *arg1 = (wxImage *) 0 ;
13258 PyObject *result;
13259 PyObject * obj0 = 0 ;
13260 char *kwnames[] = {
13261 (char *) "self", NULL
13262 };
13263
13264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13266 if (SWIG_arg_fail(1)) SWIG_fail;
13267 {
13268 PyThreadState* __tstate = wxPyBeginAllowThreads();
13269 result = (PyObject *)wxImage_GetData(arg1);
13270
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 resultobj = result;
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj = NULL;
13283 wxImage *arg1 = (wxImage *) 0 ;
13284 buffer arg2 ;
13285 int arg3 ;
13286 PyObject * obj0 = 0 ;
13287 PyObject * obj1 = 0 ;
13288 char *kwnames[] = {
13289 (char *) "self",(char *) "data", NULL
13290 };
13291
13292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13294 if (SWIG_arg_fail(1)) SWIG_fail;
13295 {
13296 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13297 }
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 wxImage_SetData(arg1,arg2,arg3);
13301
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 Py_INCREF(Py_None); resultobj = Py_None;
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13313 PyObject *resultobj = NULL;
13314 wxImage *arg1 = (wxImage *) 0 ;
13315 PyObject *result;
13316 PyObject * obj0 = 0 ;
13317 char *kwnames[] = {
13318 (char *) "self", NULL
13319 };
13320
13321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13323 if (SWIG_arg_fail(1)) SWIG_fail;
13324 {
13325 PyThreadState* __tstate = wxPyBeginAllowThreads();
13326 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13327
13328 wxPyEndAllowThreads(__tstate);
13329 if (PyErr_Occurred()) SWIG_fail;
13330 }
13331 resultobj = result;
13332 return resultobj;
13333 fail:
13334 return NULL;
13335 }
13336
13337
13338 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj = NULL;
13340 wxImage *arg1 = (wxImage *) 0 ;
13341 buffer arg2 ;
13342 int arg3 ;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 char *kwnames[] = {
13346 (char *) "self",(char *) "data", NULL
13347 };
13348
13349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13351 if (SWIG_arg_fail(1)) SWIG_fail;
13352 {
13353 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 wxImage_SetDataBuffer(arg1,arg2,arg3);
13358
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 Py_INCREF(Py_None); resultobj = Py_None;
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj = NULL;
13371 wxImage *arg1 = (wxImage *) 0 ;
13372 PyObject *result;
13373 PyObject * obj0 = 0 ;
13374 char *kwnames[] = {
13375 (char *) "self", NULL
13376 };
13377
13378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13380 if (SWIG_arg_fail(1)) SWIG_fail;
13381 {
13382 PyThreadState* __tstate = wxPyBeginAllowThreads();
13383 result = (PyObject *)wxImage_GetAlphaData(arg1);
13384
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 resultobj = result;
13389 return resultobj;
13390 fail:
13391 return NULL;
13392 }
13393
13394
13395 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13396 PyObject *resultobj = NULL;
13397 wxImage *arg1 = (wxImage *) 0 ;
13398 buffer arg2 ;
13399 int arg3 ;
13400 PyObject * obj0 = 0 ;
13401 PyObject * obj1 = 0 ;
13402 char *kwnames[] = {
13403 (char *) "self",(char *) "alpha", NULL
13404 };
13405
13406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13408 if (SWIG_arg_fail(1)) SWIG_fail;
13409 {
13410 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13411 }
13412 {
13413 PyThreadState* __tstate = wxPyBeginAllowThreads();
13414 wxImage_SetAlphaData(arg1,arg2,arg3);
13415
13416 wxPyEndAllowThreads(__tstate);
13417 if (PyErr_Occurred()) SWIG_fail;
13418 }
13419 Py_INCREF(Py_None); resultobj = Py_None;
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj = NULL;
13428 wxImage *arg1 = (wxImage *) 0 ;
13429 PyObject *result;
13430 PyObject * obj0 = 0 ;
13431 char *kwnames[] = {
13432 (char *) "self", NULL
13433 };
13434
13435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13437 if (SWIG_arg_fail(1)) SWIG_fail;
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13441
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 resultobj = result;
13446 return resultobj;
13447 fail:
13448 return NULL;
13449 }
13450
13451
13452 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj = NULL;
13454 wxImage *arg1 = (wxImage *) 0 ;
13455 buffer arg2 ;
13456 int arg3 ;
13457 PyObject * obj0 = 0 ;
13458 PyObject * obj1 = 0 ;
13459 char *kwnames[] = {
13460 (char *) "self",(char *) "alpha", NULL
13461 };
13462
13463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13465 if (SWIG_arg_fail(1)) SWIG_fail;
13466 {
13467 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13468 }
13469 {
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13472
13473 wxPyEndAllowThreads(__tstate);
13474 if (PyErr_Occurred()) SWIG_fail;
13475 }
13476 Py_INCREF(Py_None); resultobj = Py_None;
13477 return resultobj;
13478 fail:
13479 return NULL;
13480 }
13481
13482
13483 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13484 PyObject *resultobj = NULL;
13485 wxImage *arg1 = (wxImage *) 0 ;
13486 byte arg2 ;
13487 byte arg3 ;
13488 byte arg4 ;
13489 PyObject * obj0 = 0 ;
13490 PyObject * obj1 = 0 ;
13491 PyObject * obj2 = 0 ;
13492 PyObject * obj3 = 0 ;
13493 char *kwnames[] = {
13494 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13495 };
13496
13497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13499 if (SWIG_arg_fail(1)) SWIG_fail;
13500 {
13501 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13502 if (SWIG_arg_fail(2)) SWIG_fail;
13503 }
13504 {
13505 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13506 if (SWIG_arg_fail(3)) SWIG_fail;
13507 }
13508 {
13509 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13510 if (SWIG_arg_fail(4)) SWIG_fail;
13511 }
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 (arg1)->SetMaskColour(arg2,arg3,arg4);
13515
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 Py_INCREF(Py_None); resultobj = Py_None;
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj = NULL;
13528 wxImage *arg1 = (wxImage *) 0 ;
13529 byte *arg2 = (byte *) 0 ;
13530 byte *arg3 = (byte *) 0 ;
13531 byte *arg4 = (byte *) 0 ;
13532 byte temp2 ;
13533 int res2 = 0 ;
13534 byte temp3 ;
13535 int res3 = 0 ;
13536 byte temp4 ;
13537 int res4 = 0 ;
13538 PyObject * obj0 = 0 ;
13539 char *kwnames[] = {
13540 (char *) "self", NULL
13541 };
13542
13543 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13544 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13545 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13548 if (SWIG_arg_fail(1)) SWIG_fail;
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13552
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 Py_INCREF(Py_None); resultobj = Py_None;
13557 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13558 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13559 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13560 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13561 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13562 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13563 return resultobj;
13564 fail:
13565 return NULL;
13566 }
13567
13568
13569 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj = NULL;
13571 wxImage *arg1 = (wxImage *) 0 ;
13572 byte result;
13573 PyObject * obj0 = 0 ;
13574 char *kwnames[] = {
13575 (char *) "self", NULL
13576 };
13577
13578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13580 if (SWIG_arg_fail(1)) SWIG_fail;
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 result = (byte)(arg1)->GetMaskRed();
13584
13585 wxPyEndAllowThreads(__tstate);
13586 if (PyErr_Occurred()) SWIG_fail;
13587 }
13588 {
13589 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13590 }
13591 return resultobj;
13592 fail:
13593 return NULL;
13594 }
13595
13596
13597 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13598 PyObject *resultobj = NULL;
13599 wxImage *arg1 = (wxImage *) 0 ;
13600 byte result;
13601 PyObject * obj0 = 0 ;
13602 char *kwnames[] = {
13603 (char *) "self", NULL
13604 };
13605
13606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13608 if (SWIG_arg_fail(1)) SWIG_fail;
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = (byte)(arg1)->GetMaskGreen();
13612
13613 wxPyEndAllowThreads(__tstate);
13614 if (PyErr_Occurred()) SWIG_fail;
13615 }
13616 {
13617 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13618 }
13619 return resultobj;
13620 fail:
13621 return NULL;
13622 }
13623
13624
13625 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj = NULL;
13627 wxImage *arg1 = (wxImage *) 0 ;
13628 byte result;
13629 PyObject * obj0 = 0 ;
13630 char *kwnames[] = {
13631 (char *) "self", NULL
13632 };
13633
13634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13636 if (SWIG_arg_fail(1)) SWIG_fail;
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 result = (byte)(arg1)->GetMaskBlue();
13640
13641 wxPyEndAllowThreads(__tstate);
13642 if (PyErr_Occurred()) SWIG_fail;
13643 }
13644 {
13645 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13646 }
13647 return resultobj;
13648 fail:
13649 return NULL;
13650 }
13651
13652
13653 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj = NULL;
13655 wxImage *arg1 = (wxImage *) 0 ;
13656 bool arg2 = (bool) true ;
13657 PyObject * obj0 = 0 ;
13658 PyObject * obj1 = 0 ;
13659 char *kwnames[] = {
13660 (char *) "self",(char *) "mask", NULL
13661 };
13662
13663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13665 if (SWIG_arg_fail(1)) SWIG_fail;
13666 if (obj1) {
13667 {
13668 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13669 if (SWIG_arg_fail(2)) SWIG_fail;
13670 }
13671 }
13672 {
13673 PyThreadState* __tstate = wxPyBeginAllowThreads();
13674 (arg1)->SetMask(arg2);
13675
13676 wxPyEndAllowThreads(__tstate);
13677 if (PyErr_Occurred()) SWIG_fail;
13678 }
13679 Py_INCREF(Py_None); resultobj = Py_None;
13680 return resultobj;
13681 fail:
13682 return NULL;
13683 }
13684
13685
13686 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj = NULL;
13688 wxImage *arg1 = (wxImage *) 0 ;
13689 bool result;
13690 PyObject * obj0 = 0 ;
13691 char *kwnames[] = {
13692 (char *) "self", NULL
13693 };
13694
13695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13697 if (SWIG_arg_fail(1)) SWIG_fail;
13698 {
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 result = (bool)(arg1)->HasMask();
13701
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 {
13706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13707 }
13708 return resultobj;
13709 fail:
13710 return NULL;
13711 }
13712
13713
13714 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13715 PyObject *resultobj = NULL;
13716 wxImage *arg1 = (wxImage *) 0 ;
13717 double arg2 ;
13718 wxPoint *arg3 = 0 ;
13719 bool arg4 = (bool) true ;
13720 wxPoint *arg5 = (wxPoint *) NULL ;
13721 SwigValueWrapper<wxImage > result;
13722 wxPoint temp3 ;
13723 PyObject * obj0 = 0 ;
13724 PyObject * obj1 = 0 ;
13725 PyObject * obj2 = 0 ;
13726 PyObject * obj3 = 0 ;
13727 PyObject * obj4 = 0 ;
13728 char *kwnames[] = {
13729 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13730 };
13731
13732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 {
13736 arg2 = static_cast<double >(SWIG_As_double(obj1));
13737 if (SWIG_arg_fail(2)) SWIG_fail;
13738 }
13739 {
13740 arg3 = &temp3;
13741 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13742 }
13743 if (obj3) {
13744 {
13745 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13746 if (SWIG_arg_fail(4)) SWIG_fail;
13747 }
13748 }
13749 if (obj4) {
13750 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13751 if (SWIG_arg_fail(5)) SWIG_fail;
13752 }
13753 {
13754 PyThreadState* __tstate = wxPyBeginAllowThreads();
13755 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13756
13757 wxPyEndAllowThreads(__tstate);
13758 if (PyErr_Occurred()) SWIG_fail;
13759 }
13760 {
13761 wxImage * resultptr;
13762 resultptr = new wxImage(static_cast<wxImage & >(result));
13763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13764 }
13765 return resultobj;
13766 fail:
13767 return NULL;
13768 }
13769
13770
13771 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj = NULL;
13773 wxImage *arg1 = (wxImage *) 0 ;
13774 bool arg2 = (bool) true ;
13775 SwigValueWrapper<wxImage > result;
13776 PyObject * obj0 = 0 ;
13777 PyObject * obj1 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "self",(char *) "clockwise", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13784 if (SWIG_arg_fail(1)) SWIG_fail;
13785 if (obj1) {
13786 {
13787 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13788 if (SWIG_arg_fail(2)) SWIG_fail;
13789 }
13790 }
13791 {
13792 PyThreadState* __tstate = wxPyBeginAllowThreads();
13793 result = (arg1)->Rotate90(arg2);
13794
13795 wxPyEndAllowThreads(__tstate);
13796 if (PyErr_Occurred()) SWIG_fail;
13797 }
13798 {
13799 wxImage * resultptr;
13800 resultptr = new wxImage(static_cast<wxImage & >(result));
13801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13802 }
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj = NULL;
13811 wxImage *arg1 = (wxImage *) 0 ;
13812 bool arg2 = (bool) true ;
13813 SwigValueWrapper<wxImage > result;
13814 PyObject * obj0 = 0 ;
13815 PyObject * obj1 = 0 ;
13816 char *kwnames[] = {
13817 (char *) "self",(char *) "horizontally", NULL
13818 };
13819
13820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13822 if (SWIG_arg_fail(1)) SWIG_fail;
13823 if (obj1) {
13824 {
13825 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13826 if (SWIG_arg_fail(2)) SWIG_fail;
13827 }
13828 }
13829 {
13830 PyThreadState* __tstate = wxPyBeginAllowThreads();
13831 result = (arg1)->Mirror(arg2);
13832
13833 wxPyEndAllowThreads(__tstate);
13834 if (PyErr_Occurred()) SWIG_fail;
13835 }
13836 {
13837 wxImage * resultptr;
13838 resultptr = new wxImage(static_cast<wxImage & >(result));
13839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13840 }
13841 return resultobj;
13842 fail:
13843 return NULL;
13844 }
13845
13846
13847 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13848 PyObject *resultobj = NULL;
13849 wxImage *arg1 = (wxImage *) 0 ;
13850 byte arg2 ;
13851 byte arg3 ;
13852 byte arg4 ;
13853 byte arg5 ;
13854 byte arg6 ;
13855 byte arg7 ;
13856 PyObject * obj0 = 0 ;
13857 PyObject * obj1 = 0 ;
13858 PyObject * obj2 = 0 ;
13859 PyObject * obj3 = 0 ;
13860 PyObject * obj4 = 0 ;
13861 PyObject * obj5 = 0 ;
13862 PyObject * obj6 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13865 };
13866
13867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13869 if (SWIG_arg_fail(1)) SWIG_fail;
13870 {
13871 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13872 if (SWIG_arg_fail(2)) SWIG_fail;
13873 }
13874 {
13875 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13876 if (SWIG_arg_fail(3)) SWIG_fail;
13877 }
13878 {
13879 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13880 if (SWIG_arg_fail(4)) SWIG_fail;
13881 }
13882 {
13883 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13884 if (SWIG_arg_fail(5)) SWIG_fail;
13885 }
13886 {
13887 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13888 if (SWIG_arg_fail(6)) SWIG_fail;
13889 }
13890 {
13891 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13892 if (SWIG_arg_fail(7)) SWIG_fail;
13893 }
13894 {
13895 PyThreadState* __tstate = wxPyBeginAllowThreads();
13896 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13897
13898 wxPyEndAllowThreads(__tstate);
13899 if (PyErr_Occurred()) SWIG_fail;
13900 }
13901 Py_INCREF(Py_None); resultobj = Py_None;
13902 return resultobj;
13903 fail:
13904 return NULL;
13905 }
13906
13907
13908 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13909 PyObject *resultobj = NULL;
13910 wxImage *arg1 = (wxImage *) 0 ;
13911 double arg2 = (double) 0.299 ;
13912 double arg3 = (double) 0.587 ;
13913 double arg4 = (double) 0.114 ;
13914 SwigValueWrapper<wxImage > result;
13915 PyObject * obj0 = 0 ;
13916 PyObject * obj1 = 0 ;
13917 PyObject * obj2 = 0 ;
13918 PyObject * obj3 = 0 ;
13919 char *kwnames[] = {
13920 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13921 };
13922
13923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13925 if (SWIG_arg_fail(1)) SWIG_fail;
13926 if (obj1) {
13927 {
13928 arg2 = static_cast<double >(SWIG_As_double(obj1));
13929 if (SWIG_arg_fail(2)) SWIG_fail;
13930 }
13931 }
13932 if (obj2) {
13933 {
13934 arg3 = static_cast<double >(SWIG_As_double(obj2));
13935 if (SWIG_arg_fail(3)) SWIG_fail;
13936 }
13937 }
13938 if (obj3) {
13939 {
13940 arg4 = static_cast<double >(SWIG_As_double(obj3));
13941 if (SWIG_arg_fail(4)) SWIG_fail;
13942 }
13943 }
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 {
13952 wxImage * resultptr;
13953 resultptr = new wxImage(static_cast<wxImage & >(result));
13954 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13955 }
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13963 PyObject *resultobj = NULL;
13964 wxImage *arg1 = (wxImage *) 0 ;
13965 byte arg2 ;
13966 byte arg3 ;
13967 byte arg4 ;
13968 SwigValueWrapper<wxImage > result;
13969 PyObject * obj0 = 0 ;
13970 PyObject * obj1 = 0 ;
13971 PyObject * obj2 = 0 ;
13972 PyObject * obj3 = 0 ;
13973 char *kwnames[] = {
13974 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13975 };
13976
13977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13979 if (SWIG_arg_fail(1)) SWIG_fail;
13980 {
13981 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13982 if (SWIG_arg_fail(2)) SWIG_fail;
13983 }
13984 {
13985 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13986 if (SWIG_arg_fail(3)) SWIG_fail;
13987 }
13988 {
13989 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13990 if (SWIG_arg_fail(4)) SWIG_fail;
13991 }
13992 {
13993 PyThreadState* __tstate = wxPyBeginAllowThreads();
13994 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13995
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 {
14000 wxImage * resultptr;
14001 resultptr = new wxImage(static_cast<wxImage & >(result));
14002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
14003 }
14004 return resultobj;
14005 fail:
14006 return NULL;
14007 }
14008
14009
14010 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14011 PyObject *resultobj = NULL;
14012 wxImage *arg1 = (wxImage *) 0 ;
14013 wxString *arg2 = 0 ;
14014 wxString *arg3 = 0 ;
14015 bool temp2 = false ;
14016 bool temp3 = false ;
14017 PyObject * obj0 = 0 ;
14018 PyObject * obj1 = 0 ;
14019 PyObject * obj2 = 0 ;
14020 char *kwnames[] = {
14021 (char *) "self",(char *) "name",(char *) "value", NULL
14022 };
14023
14024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
14025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14026 if (SWIG_arg_fail(1)) SWIG_fail;
14027 {
14028 arg2 = wxString_in_helper(obj1);
14029 if (arg2 == NULL) SWIG_fail;
14030 temp2 = true;
14031 }
14032 {
14033 arg3 = wxString_in_helper(obj2);
14034 if (arg3 == NULL) SWIG_fail;
14035 temp3 = true;
14036 }
14037 {
14038 PyThreadState* __tstate = wxPyBeginAllowThreads();
14039 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
14040
14041 wxPyEndAllowThreads(__tstate);
14042 if (PyErr_Occurred()) SWIG_fail;
14043 }
14044 Py_INCREF(Py_None); resultobj = Py_None;
14045 {
14046 if (temp2)
14047 delete arg2;
14048 }
14049 {
14050 if (temp3)
14051 delete arg3;
14052 }
14053 return resultobj;
14054 fail:
14055 {
14056 if (temp2)
14057 delete arg2;
14058 }
14059 {
14060 if (temp3)
14061 delete arg3;
14062 }
14063 return NULL;
14064 }
14065
14066
14067 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14068 PyObject *resultobj = NULL;
14069 wxImage *arg1 = (wxImage *) 0 ;
14070 wxString *arg2 = 0 ;
14071 int arg3 ;
14072 bool temp2 = false ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 PyObject * obj2 = 0 ;
14076 char *kwnames[] = {
14077 (char *) "self",(char *) "name",(char *) "value", NULL
14078 };
14079
14080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14082 if (SWIG_arg_fail(1)) SWIG_fail;
14083 {
14084 arg2 = wxString_in_helper(obj1);
14085 if (arg2 == NULL) SWIG_fail;
14086 temp2 = true;
14087 }
14088 {
14089 arg3 = static_cast<int >(SWIG_As_int(obj2));
14090 if (SWIG_arg_fail(3)) SWIG_fail;
14091 }
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 (arg1)->SetOption((wxString const &)*arg2,arg3);
14095
14096 wxPyEndAllowThreads(__tstate);
14097 if (PyErr_Occurred()) SWIG_fail;
14098 }
14099 Py_INCREF(Py_None); resultobj = Py_None;
14100 {
14101 if (temp2)
14102 delete arg2;
14103 }
14104 return resultobj;
14105 fail:
14106 {
14107 if (temp2)
14108 delete arg2;
14109 }
14110 return NULL;
14111 }
14112
14113
14114 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14115 PyObject *resultobj = NULL;
14116 wxImage *arg1 = (wxImage *) 0 ;
14117 wxString *arg2 = 0 ;
14118 wxString result;
14119 bool temp2 = false ;
14120 PyObject * obj0 = 0 ;
14121 PyObject * obj1 = 0 ;
14122 char *kwnames[] = {
14123 (char *) "self",(char *) "name", NULL
14124 };
14125
14126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14128 if (SWIG_arg_fail(1)) SWIG_fail;
14129 {
14130 arg2 = wxString_in_helper(obj1);
14131 if (arg2 == NULL) SWIG_fail;
14132 temp2 = true;
14133 }
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 {
14142 #if wxUSE_UNICODE
14143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14144 #else
14145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14146 #endif
14147 }
14148 {
14149 if (temp2)
14150 delete arg2;
14151 }
14152 return resultobj;
14153 fail:
14154 {
14155 if (temp2)
14156 delete arg2;
14157 }
14158 return NULL;
14159 }
14160
14161
14162 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14163 PyObject *resultobj = NULL;
14164 wxImage *arg1 = (wxImage *) 0 ;
14165 wxString *arg2 = 0 ;
14166 int result;
14167 bool temp2 = false ;
14168 PyObject * obj0 = 0 ;
14169 PyObject * obj1 = 0 ;
14170 char *kwnames[] = {
14171 (char *) "self",(char *) "name", NULL
14172 };
14173
14174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14176 if (SWIG_arg_fail(1)) SWIG_fail;
14177 {
14178 arg2 = wxString_in_helper(obj1);
14179 if (arg2 == NULL) SWIG_fail;
14180 temp2 = true;
14181 }
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14185
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 {
14190 resultobj = SWIG_From_int(static_cast<int >(result));
14191 }
14192 {
14193 if (temp2)
14194 delete arg2;
14195 }
14196 return resultobj;
14197 fail:
14198 {
14199 if (temp2)
14200 delete arg2;
14201 }
14202 return NULL;
14203 }
14204
14205
14206 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14207 PyObject *resultobj = NULL;
14208 wxImage *arg1 = (wxImage *) 0 ;
14209 wxString *arg2 = 0 ;
14210 bool result;
14211 bool temp2 = false ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 char *kwnames[] = {
14215 (char *) "self",(char *) "name", NULL
14216 };
14217
14218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14220 if (SWIG_arg_fail(1)) SWIG_fail;
14221 {
14222 arg2 = wxString_in_helper(obj1);
14223 if (arg2 == NULL) SWIG_fail;
14224 temp2 = true;
14225 }
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14229
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 {
14234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14235 }
14236 {
14237 if (temp2)
14238 delete arg2;
14239 }
14240 return resultobj;
14241 fail:
14242 {
14243 if (temp2)
14244 delete arg2;
14245 }
14246 return NULL;
14247 }
14248
14249
14250 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14251 PyObject *resultobj = NULL;
14252 wxImage *arg1 = (wxImage *) 0 ;
14253 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14254 unsigned long result;
14255 PyObject * obj0 = 0 ;
14256 PyObject * obj1 = 0 ;
14257 char *kwnames[] = {
14258 (char *) "self",(char *) "stopafter", NULL
14259 };
14260
14261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14263 if (SWIG_arg_fail(1)) SWIG_fail;
14264 if (obj1) {
14265 {
14266 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14267 if (SWIG_arg_fail(2)) SWIG_fail;
14268 }
14269 }
14270 {
14271 PyThreadState* __tstate = wxPyBeginAllowThreads();
14272 result = (unsigned long)(arg1)->CountColours(arg2);
14273
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 {
14278 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14279 }
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14287 PyObject *resultobj = NULL;
14288 wxImage *arg1 = (wxImage *) 0 ;
14289 wxImageHistogram *arg2 = 0 ;
14290 unsigned long result;
14291 PyObject * obj0 = 0 ;
14292 PyObject * obj1 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self",(char *) "h", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14302 if (SWIG_arg_fail(2)) SWIG_fail;
14303 if (arg2 == NULL) {
14304 SWIG_null_ref("wxImageHistogram");
14305 }
14306 if (SWIG_arg_fail(2)) SWIG_fail;
14307 }
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 {
14316 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14317 }
14318 return resultobj;
14319 fail:
14320 return NULL;
14321 }
14322
14323
14324 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14325 PyObject *resultobj = NULL;
14326 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14327 PyObject * obj0 = 0 ;
14328 char *kwnames[] = {
14329 (char *) "handler", NULL
14330 };
14331
14332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14334 if (SWIG_arg_fail(1)) SWIG_fail;
14335 {
14336 PyThreadState* __tstate = wxPyBeginAllowThreads();
14337 wxImage::AddHandler(arg1);
14338
14339 wxPyEndAllowThreads(__tstate);
14340 if (PyErr_Occurred()) SWIG_fail;
14341 }
14342 Py_INCREF(Py_None); resultobj = Py_None;
14343 return resultobj;
14344 fail:
14345 return NULL;
14346 }
14347
14348
14349 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14350 PyObject *resultobj = NULL;
14351 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14352 PyObject * obj0 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "handler", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 wxImage::InsertHandler(arg1);
14363
14364 wxPyEndAllowThreads(__tstate);
14365 if (PyErr_Occurred()) SWIG_fail;
14366 }
14367 Py_INCREF(Py_None); resultobj = Py_None;
14368 return resultobj;
14369 fail:
14370 return NULL;
14371 }
14372
14373
14374 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14375 PyObject *resultobj = NULL;
14376 wxString *arg1 = 0 ;
14377 bool result;
14378 bool temp1 = false ;
14379 PyObject * obj0 = 0 ;
14380 char *kwnames[] = {
14381 (char *) "name", NULL
14382 };
14383
14384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14385 {
14386 arg1 = wxString_in_helper(obj0);
14387 if (arg1 == NULL) SWIG_fail;
14388 temp1 = true;
14389 }
14390 {
14391 PyThreadState* __tstate = wxPyBeginAllowThreads();
14392 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14393
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 {
14398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14399 }
14400 {
14401 if (temp1)
14402 delete arg1;
14403 }
14404 return resultobj;
14405 fail:
14406 {
14407 if (temp1)
14408 delete arg1;
14409 }
14410 return NULL;
14411 }
14412
14413
14414 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj = NULL;
14416 wxString result;
14417 char *kwnames[] = {
14418 NULL
14419 };
14420
14421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = wxImage::GetImageExtWildcard();
14425
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 {
14430 #if wxUSE_UNICODE
14431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14432 #else
14433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14434 #endif
14435 }
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14443 PyObject *resultobj = NULL;
14444 wxImage *arg1 = (wxImage *) 0 ;
14445 int arg2 = (int) -1 ;
14446 wxBitmap result;
14447 PyObject * obj0 = 0 ;
14448 PyObject * obj1 = 0 ;
14449 char *kwnames[] = {
14450 (char *) "self",(char *) "depth", NULL
14451 };
14452
14453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14455 if (SWIG_arg_fail(1)) SWIG_fail;
14456 if (obj1) {
14457 {
14458 arg2 = static_cast<int >(SWIG_As_int(obj1));
14459 if (SWIG_arg_fail(2)) SWIG_fail;
14460 }
14461 }
14462 {
14463 if (!wxPyCheckForApp()) SWIG_fail;
14464 PyThreadState* __tstate = wxPyBeginAllowThreads();
14465 result = wxImage_ConvertToBitmap(arg1,arg2);
14466
14467 wxPyEndAllowThreads(__tstate);
14468 if (PyErr_Occurred()) SWIG_fail;
14469 }
14470 {
14471 wxBitmap * resultptr;
14472 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14474 }
14475 return resultobj;
14476 fail:
14477 return NULL;
14478 }
14479
14480
14481 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14482 PyObject *resultobj = NULL;
14483 wxImage *arg1 = (wxImage *) 0 ;
14484 byte arg2 ;
14485 byte arg3 ;
14486 byte arg4 ;
14487 wxBitmap result;
14488 PyObject * obj0 = 0 ;
14489 PyObject * obj1 = 0 ;
14490 PyObject * obj2 = 0 ;
14491 PyObject * obj3 = 0 ;
14492 char *kwnames[] = {
14493 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14494 };
14495
14496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14498 if (SWIG_arg_fail(1)) SWIG_fail;
14499 {
14500 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14501 if (SWIG_arg_fail(2)) SWIG_fail;
14502 }
14503 {
14504 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14505 if (SWIG_arg_fail(3)) SWIG_fail;
14506 }
14507 {
14508 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14509 if (SWIG_arg_fail(4)) SWIG_fail;
14510 }
14511 {
14512 if (!wxPyCheckForApp()) SWIG_fail;
14513 PyThreadState* __tstate = wxPyBeginAllowThreads();
14514 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14515
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 {
14520 wxBitmap * resultptr;
14521 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14523 }
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14531 PyObject *resultobj = NULL;
14532 wxImage *arg1 = (wxImage *) 0 ;
14533 double arg2 ;
14534 PyObject * obj0 = 0 ;
14535 PyObject * obj1 = 0 ;
14536 char *kwnames[] = {
14537 (char *) "self",(char *) "angle", NULL
14538 };
14539
14540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14542 if (SWIG_arg_fail(1)) SWIG_fail;
14543 {
14544 arg2 = static_cast<double >(SWIG_As_double(obj1));
14545 if (SWIG_arg_fail(2)) SWIG_fail;
14546 }
14547 {
14548 PyThreadState* __tstate = wxPyBeginAllowThreads();
14549 (arg1)->RotateHue(arg2);
14550
14551 wxPyEndAllowThreads(__tstate);
14552 if (PyErr_Occurred()) SWIG_fail;
14553 }
14554 Py_INCREF(Py_None); resultobj = Py_None;
14555 return resultobj;
14556 fail:
14557 return NULL;
14558 }
14559
14560
14561 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14562 PyObject *resultobj = NULL;
14563 wxImage_RGBValue arg1 ;
14564 wxImage_HSVValue result;
14565 PyObject * obj0 = 0 ;
14566 char *kwnames[] = {
14567 (char *) "rgb", NULL
14568 };
14569
14570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14571 {
14572 wxImage_RGBValue * argp;
14573 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14574 if (SWIG_arg_fail(1)) SWIG_fail;
14575 if (argp == NULL) {
14576 SWIG_null_ref("wxImage_RGBValue");
14577 }
14578 if (SWIG_arg_fail(1)) SWIG_fail;
14579 arg1 = *argp;
14580 }
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 result = wxImage::RGBtoHSV(arg1);
14584
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 {
14589 wxImage_HSVValue * resultptr;
14590 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14592 }
14593 return resultobj;
14594 fail:
14595 return NULL;
14596 }
14597
14598
14599 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14600 PyObject *resultobj = NULL;
14601 wxImage_HSVValue arg1 ;
14602 wxImage_RGBValue result;
14603 PyObject * obj0 = 0 ;
14604 char *kwnames[] = {
14605 (char *) "hsv", NULL
14606 };
14607
14608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14609 {
14610 wxImage_HSVValue * argp;
14611 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14612 if (SWIG_arg_fail(1)) SWIG_fail;
14613 if (argp == NULL) {
14614 SWIG_null_ref("wxImage_HSVValue");
14615 }
14616 if (SWIG_arg_fail(1)) SWIG_fail;
14617 arg1 = *argp;
14618 }
14619 {
14620 PyThreadState* __tstate = wxPyBeginAllowThreads();
14621 result = wxImage::HSVtoRGB(arg1);
14622
14623 wxPyEndAllowThreads(__tstate);
14624 if (PyErr_Occurred()) SWIG_fail;
14625 }
14626 {
14627 wxImage_RGBValue * resultptr;
14628 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14630 }
14631 return resultobj;
14632 fail:
14633 return NULL;
14634 }
14635
14636
14637 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14638 PyObject *obj;
14639 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14640 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14641 Py_INCREF(obj);
14642 return Py_BuildValue((char *)"");
14643 }
14644 static int _wrap_NullImage_set(PyObject *) {
14645 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14646 return 1;
14647 }
14648
14649
14650 static PyObject *_wrap_NullImage_get(void) {
14651 PyObject *pyobj = NULL;
14652
14653 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14654 return pyobj;
14655 }
14656
14657
14658 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14659 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14660 return 1;
14661 }
14662
14663
14664 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14665 PyObject *pyobj = NULL;
14666
14667 {
14668 #if wxUSE_UNICODE
14669 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14670 #else
14671 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14672 #endif
14673 }
14674 return pyobj;
14675 }
14676
14677
14678 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14679 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14680 return 1;
14681 }
14682
14683
14684 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14685 PyObject *pyobj = NULL;
14686
14687 {
14688 #if wxUSE_UNICODE
14689 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14690 #else
14691 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14692 #endif
14693 }
14694 return pyobj;
14695 }
14696
14697
14698 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14699 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14700 return 1;
14701 }
14702
14703
14704 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14705 PyObject *pyobj = NULL;
14706
14707 {
14708 #if wxUSE_UNICODE
14709 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14710 #else
14711 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14712 #endif
14713 }
14714 return pyobj;
14715 }
14716
14717
14718 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14719 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14720 return 1;
14721 }
14722
14723
14724 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14725 PyObject *pyobj = NULL;
14726
14727 {
14728 #if wxUSE_UNICODE
14729 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14730 #else
14731 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14732 #endif
14733 }
14734 return pyobj;
14735 }
14736
14737
14738 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14739 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14740 return 1;
14741 }
14742
14743
14744 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14745 PyObject *pyobj = NULL;
14746
14747 {
14748 #if wxUSE_UNICODE
14749 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14750 #else
14751 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14752 #endif
14753 }
14754 return pyobj;
14755 }
14756
14757
14758 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14759 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14760 return 1;
14761 }
14762
14763
14764 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14765 PyObject *pyobj = NULL;
14766
14767 {
14768 #if wxUSE_UNICODE
14769 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14770 #else
14771 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14772 #endif
14773 }
14774 return pyobj;
14775 }
14776
14777
14778 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14779 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14780 return 1;
14781 }
14782
14783
14784 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14785 PyObject *pyobj = NULL;
14786
14787 {
14788 #if wxUSE_UNICODE
14789 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14790 #else
14791 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14792 #endif
14793 }
14794 return pyobj;
14795 }
14796
14797
14798 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14799 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14800 return 1;
14801 }
14802
14803
14804 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14805 PyObject *pyobj = NULL;
14806
14807 {
14808 #if wxUSE_UNICODE
14809 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14810 #else
14811 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14812 #endif
14813 }
14814 return pyobj;
14815 }
14816
14817
14818 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14819 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14820 return 1;
14821 }
14822
14823
14824 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14825 PyObject *pyobj = NULL;
14826
14827 {
14828 #if wxUSE_UNICODE
14829 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14830 #else
14831 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14832 #endif
14833 }
14834 return pyobj;
14835 }
14836
14837
14838 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14839 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14840 return 1;
14841 }
14842
14843
14844 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14845 PyObject *pyobj = NULL;
14846
14847 {
14848 #if wxUSE_UNICODE
14849 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14850 #else
14851 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14852 #endif
14853 }
14854 return pyobj;
14855 }
14856
14857
14858 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14859 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14860 return 1;
14861 }
14862
14863
14864 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14865 PyObject *pyobj = NULL;
14866
14867 {
14868 #if wxUSE_UNICODE
14869 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14870 #else
14871 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14872 #endif
14873 }
14874 return pyobj;
14875 }
14876
14877
14878 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14879 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14880 return 1;
14881 }
14882
14883
14884 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14885 PyObject *pyobj = NULL;
14886
14887 {
14888 #if wxUSE_UNICODE
14889 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14890 #else
14891 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14892 #endif
14893 }
14894 return pyobj;
14895 }
14896
14897
14898 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14899 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14900 return 1;
14901 }
14902
14903
14904 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14905 PyObject *pyobj = NULL;
14906
14907 {
14908 #if wxUSE_UNICODE
14909 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14910 #else
14911 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14912 #endif
14913 }
14914 return pyobj;
14915 }
14916
14917
14918 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14919 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14920 return 1;
14921 }
14922
14923
14924 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14925 PyObject *pyobj = NULL;
14926
14927 {
14928 #if wxUSE_UNICODE
14929 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14930 #else
14931 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14932 #endif
14933 }
14934 return pyobj;
14935 }
14936
14937
14938 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14939 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14940 return 1;
14941 }
14942
14943
14944 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14945 PyObject *pyobj = NULL;
14946
14947 {
14948 #if wxUSE_UNICODE
14949 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14950 #else
14951 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14952 #endif
14953 }
14954 return pyobj;
14955 }
14956
14957
14958 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj = NULL;
14960 wxBMPHandler *result;
14961 char *kwnames[] = {
14962 NULL
14963 };
14964
14965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14966 {
14967 PyThreadState* __tstate = wxPyBeginAllowThreads();
14968 result = (wxBMPHandler *)new wxBMPHandler();
14969
14970 wxPyEndAllowThreads(__tstate);
14971 if (PyErr_Occurred()) SWIG_fail;
14972 }
14973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14974 return resultobj;
14975 fail:
14976 return NULL;
14977 }
14978
14979
14980 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14981 PyObject *obj;
14982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14983 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14984 Py_INCREF(obj);
14985 return Py_BuildValue((char *)"");
14986 }
14987 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj = NULL;
14989 wxICOHandler *result;
14990 char *kwnames[] = {
14991 NULL
14992 };
14993
14994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 result = (wxICOHandler *)new wxICOHandler();
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
15010 PyObject *obj;
15011 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15012 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
15013 Py_INCREF(obj);
15014 return Py_BuildValue((char *)"");
15015 }
15016 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15017 PyObject *resultobj = NULL;
15018 wxCURHandler *result;
15019 char *kwnames[] = {
15020 NULL
15021 };
15022
15023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 result = (wxCURHandler *)new wxCURHandler();
15027
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
15032 return resultobj;
15033 fail:
15034 return NULL;
15035 }
15036
15037
15038 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
15039 PyObject *obj;
15040 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15041 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
15042 Py_INCREF(obj);
15043 return Py_BuildValue((char *)"");
15044 }
15045 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15046 PyObject *resultobj = NULL;
15047 wxANIHandler *result;
15048 char *kwnames[] = {
15049 NULL
15050 };
15051
15052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
15053 {
15054 PyThreadState* __tstate = wxPyBeginAllowThreads();
15055 result = (wxANIHandler *)new wxANIHandler();
15056
15057 wxPyEndAllowThreads(__tstate);
15058 if (PyErr_Occurred()) SWIG_fail;
15059 }
15060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15061 return resultobj;
15062 fail:
15063 return NULL;
15064 }
15065
15066
15067 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15068 PyObject *obj;
15069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15070 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15071 Py_INCREF(obj);
15072 return Py_BuildValue((char *)"");
15073 }
15074 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15075 PyObject *resultobj = NULL;
15076 wxPNGHandler *result;
15077 char *kwnames[] = {
15078 NULL
15079 };
15080
15081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15082 {
15083 PyThreadState* __tstate = wxPyBeginAllowThreads();
15084 result = (wxPNGHandler *)new wxPNGHandler();
15085
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15097 PyObject *obj;
15098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15099 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15100 Py_INCREF(obj);
15101 return Py_BuildValue((char *)"");
15102 }
15103 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15104 PyObject *resultobj = NULL;
15105 wxGIFHandler *result;
15106 char *kwnames[] = {
15107 NULL
15108 };
15109
15110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 result = (wxGIFHandler *)new wxGIFHandler();
15114
15115 wxPyEndAllowThreads(__tstate);
15116 if (PyErr_Occurred()) SWIG_fail;
15117 }
15118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15119 return resultobj;
15120 fail:
15121 return NULL;
15122 }
15123
15124
15125 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15126 PyObject *obj;
15127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15128 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15129 Py_INCREF(obj);
15130 return Py_BuildValue((char *)"");
15131 }
15132 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15133 PyObject *resultobj = NULL;
15134 wxPCXHandler *result;
15135 char *kwnames[] = {
15136 NULL
15137 };
15138
15139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15140 {
15141 PyThreadState* __tstate = wxPyBeginAllowThreads();
15142 result = (wxPCXHandler *)new wxPCXHandler();
15143
15144 wxPyEndAllowThreads(__tstate);
15145 if (PyErr_Occurred()) SWIG_fail;
15146 }
15147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15148 return resultobj;
15149 fail:
15150 return NULL;
15151 }
15152
15153
15154 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15155 PyObject *obj;
15156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15157 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15158 Py_INCREF(obj);
15159 return Py_BuildValue((char *)"");
15160 }
15161 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj = NULL;
15163 wxJPEGHandler *result;
15164 char *kwnames[] = {
15165 NULL
15166 };
15167
15168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = (wxJPEGHandler *)new wxJPEGHandler();
15172
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15184 PyObject *obj;
15185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15186 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15187 Py_INCREF(obj);
15188 return Py_BuildValue((char *)"");
15189 }
15190 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15191 PyObject *resultobj = NULL;
15192 wxPNMHandler *result;
15193 char *kwnames[] = {
15194 NULL
15195 };
15196
15197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = (wxPNMHandler *)new wxPNMHandler();
15201
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15213 PyObject *obj;
15214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15215 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15216 Py_INCREF(obj);
15217 return Py_BuildValue((char *)"");
15218 }
15219 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj = NULL;
15221 wxXPMHandler *result;
15222 char *kwnames[] = {
15223 NULL
15224 };
15225
15226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 result = (wxXPMHandler *)new wxXPMHandler();
15230
15231 wxPyEndAllowThreads(__tstate);
15232 if (PyErr_Occurred()) SWIG_fail;
15233 }
15234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15235 return resultobj;
15236 fail:
15237 return NULL;
15238 }
15239
15240
15241 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15242 PyObject *obj;
15243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15244 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15245 Py_INCREF(obj);
15246 return Py_BuildValue((char *)"");
15247 }
15248 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15249 PyObject *resultobj = NULL;
15250 wxTIFFHandler *result;
15251 char *kwnames[] = {
15252 NULL
15253 };
15254
15255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15256 {
15257 PyThreadState* __tstate = wxPyBeginAllowThreads();
15258 result = (wxTIFFHandler *)new wxTIFFHandler();
15259
15260 wxPyEndAllowThreads(__tstate);
15261 if (PyErr_Occurred()) SWIG_fail;
15262 }
15263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15264 return resultobj;
15265 fail:
15266 return NULL;
15267 }
15268
15269
15270 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15271 PyObject *obj;
15272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15273 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15274 Py_INCREF(obj);
15275 return Py_BuildValue((char *)"");
15276 }
15277 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj = NULL;
15279 wxImage *arg1 = 0 ;
15280 wxImage *arg2 = 0 ;
15281 int arg3 = (int) 236 ;
15282 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15283 bool result;
15284 PyObject * obj0 = 0 ;
15285 PyObject * obj1 = 0 ;
15286 PyObject * obj2 = 0 ;
15287 PyObject * obj3 = 0 ;
15288 char *kwnames[] = {
15289 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15290 };
15291
15292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15293 {
15294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15295 if (SWIG_arg_fail(1)) SWIG_fail;
15296 if (arg1 == NULL) {
15297 SWIG_null_ref("wxImage");
15298 }
15299 if (SWIG_arg_fail(1)) SWIG_fail;
15300 }
15301 {
15302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15303 if (SWIG_arg_fail(2)) SWIG_fail;
15304 if (arg2 == NULL) {
15305 SWIG_null_ref("wxImage");
15306 }
15307 if (SWIG_arg_fail(2)) SWIG_fail;
15308 }
15309 if (obj2) {
15310 {
15311 arg3 = static_cast<int >(SWIG_As_int(obj2));
15312 if (SWIG_arg_fail(3)) SWIG_fail;
15313 }
15314 }
15315 if (obj3) {
15316 {
15317 arg4 = static_cast<int >(SWIG_As_int(obj3));
15318 if (SWIG_arg_fail(4)) SWIG_fail;
15319 }
15320 }
15321 {
15322 PyThreadState* __tstate = wxPyBeginAllowThreads();
15323 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15324
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 {
15329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15330 }
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15338 PyObject *obj;
15339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15340 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15341 Py_INCREF(obj);
15342 return Py_BuildValue((char *)"");
15343 }
15344 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15345 PyObject *resultobj = NULL;
15346 wxEvtHandler *result;
15347 char *kwnames[] = {
15348 NULL
15349 };
15350
15351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 result = (wxEvtHandler *)new wxEvtHandler();
15355
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15367 PyObject *resultobj = NULL;
15368 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15369 wxEvtHandler *result;
15370 PyObject * obj0 = 0 ;
15371 char *kwnames[] = {
15372 (char *) "self", NULL
15373 };
15374
15375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15377 if (SWIG_arg_fail(1)) SWIG_fail;
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15381
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 {
15386 resultobj = wxPyMake_wxObject(result, 0);
15387 }
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15395 PyObject *resultobj = NULL;
15396 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15397 wxEvtHandler *result;
15398 PyObject * obj0 = 0 ;
15399 char *kwnames[] = {
15400 (char *) "self", NULL
15401 };
15402
15403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15405 if (SWIG_arg_fail(1)) SWIG_fail;
15406 {
15407 PyThreadState* __tstate = wxPyBeginAllowThreads();
15408 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15409
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 {
15414 resultobj = wxPyMake_wxObject(result, 0);
15415 }
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15423 PyObject *resultobj = NULL;
15424 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15425 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15426 PyObject * obj0 = 0 ;
15427 PyObject * obj1 = 0 ;
15428 char *kwnames[] = {
15429 (char *) "self",(char *) "handler", NULL
15430 };
15431
15432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15434 if (SWIG_arg_fail(1)) SWIG_fail;
15435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15436 if (SWIG_arg_fail(2)) SWIG_fail;
15437 {
15438 PyThreadState* __tstate = wxPyBeginAllowThreads();
15439 (arg1)->SetNextHandler(arg2);
15440
15441 wxPyEndAllowThreads(__tstate);
15442 if (PyErr_Occurred()) SWIG_fail;
15443 }
15444 Py_INCREF(Py_None); resultobj = Py_None;
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15452 PyObject *resultobj = NULL;
15453 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15454 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15455 PyObject * obj0 = 0 ;
15456 PyObject * obj1 = 0 ;
15457 char *kwnames[] = {
15458 (char *) "self",(char *) "handler", NULL
15459 };
15460
15461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15463 if (SWIG_arg_fail(1)) SWIG_fail;
15464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15465 if (SWIG_arg_fail(2)) SWIG_fail;
15466 {
15467 PyThreadState* __tstate = wxPyBeginAllowThreads();
15468 (arg1)->SetPreviousHandler(arg2);
15469
15470 wxPyEndAllowThreads(__tstate);
15471 if (PyErr_Occurred()) SWIG_fail;
15472 }
15473 Py_INCREF(Py_None); resultobj = Py_None;
15474 return resultobj;
15475 fail:
15476 return NULL;
15477 }
15478
15479
15480 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15481 PyObject *resultobj = NULL;
15482 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15483 bool result;
15484 PyObject * obj0 = 0 ;
15485 char *kwnames[] = {
15486 (char *) "self", NULL
15487 };
15488
15489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15491 if (SWIG_arg_fail(1)) SWIG_fail;
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (bool)(arg1)->GetEvtHandlerEnabled();
15495
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 {
15500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15501 }
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15509 PyObject *resultobj = NULL;
15510 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15511 bool arg2 ;
15512 PyObject * obj0 = 0 ;
15513 PyObject * obj1 = 0 ;
15514 char *kwnames[] = {
15515 (char *) "self",(char *) "enabled", NULL
15516 };
15517
15518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15520 if (SWIG_arg_fail(1)) SWIG_fail;
15521 {
15522 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15523 if (SWIG_arg_fail(2)) SWIG_fail;
15524 }
15525 {
15526 PyThreadState* __tstate = wxPyBeginAllowThreads();
15527 (arg1)->SetEvtHandlerEnabled(arg2);
15528
15529 wxPyEndAllowThreads(__tstate);
15530 if (PyErr_Occurred()) SWIG_fail;
15531 }
15532 Py_INCREF(Py_None); resultobj = Py_None;
15533 return resultobj;
15534 fail:
15535 return NULL;
15536 }
15537
15538
15539 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15540 PyObject *resultobj = NULL;
15541 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15542 wxEvent *arg2 = 0 ;
15543 bool result;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 char *kwnames[] = {
15547 (char *) "self",(char *) "event", NULL
15548 };
15549
15550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15552 if (SWIG_arg_fail(1)) SWIG_fail;
15553 {
15554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15555 if (SWIG_arg_fail(2)) SWIG_fail;
15556 if (arg2 == NULL) {
15557 SWIG_null_ref("wxEvent");
15558 }
15559 if (SWIG_arg_fail(2)) SWIG_fail;
15560 }
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 result = (bool)(arg1)->ProcessEvent(*arg2);
15564
15565 wxPyEndAllowThreads(__tstate);
15566 if (PyErr_Occurred()) SWIG_fail;
15567 }
15568 {
15569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15570 }
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15578 PyObject *resultobj = NULL;
15579 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15580 wxEvent *arg2 = 0 ;
15581 PyObject * obj0 = 0 ;
15582 PyObject * obj1 = 0 ;
15583 char *kwnames[] = {
15584 (char *) "self",(char *) "event", NULL
15585 };
15586
15587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15589 if (SWIG_arg_fail(1)) SWIG_fail;
15590 {
15591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15592 if (SWIG_arg_fail(2)) SWIG_fail;
15593 if (arg2 == NULL) {
15594 SWIG_null_ref("wxEvent");
15595 }
15596 if (SWIG_arg_fail(2)) SWIG_fail;
15597 }
15598 {
15599 PyThreadState* __tstate = wxPyBeginAllowThreads();
15600 (arg1)->AddPendingEvent(*arg2);
15601
15602 wxPyEndAllowThreads(__tstate);
15603 if (PyErr_Occurred()) SWIG_fail;
15604 }
15605 Py_INCREF(Py_None); resultobj = Py_None;
15606 return resultobj;
15607 fail:
15608 return NULL;
15609 }
15610
15611
15612 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15613 PyObject *resultobj = NULL;
15614 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15615 PyObject * obj0 = 0 ;
15616 char *kwnames[] = {
15617 (char *) "self", NULL
15618 };
15619
15620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15622 if (SWIG_arg_fail(1)) SWIG_fail;
15623 {
15624 PyThreadState* __tstate = wxPyBeginAllowThreads();
15625 (arg1)->ProcessPendingEvents();
15626
15627 wxPyEndAllowThreads(__tstate);
15628 if (PyErr_Occurred()) SWIG_fail;
15629 }
15630 Py_INCREF(Py_None); resultobj = Py_None;
15631 return resultobj;
15632 fail:
15633 return NULL;
15634 }
15635
15636
15637 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15638 PyObject *resultobj = NULL;
15639 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15640 int arg2 ;
15641 int arg3 ;
15642 int arg4 ;
15643 PyObject *arg5 = (PyObject *) 0 ;
15644 PyObject * obj0 = 0 ;
15645 PyObject * obj1 = 0 ;
15646 PyObject * obj2 = 0 ;
15647 PyObject * obj3 = 0 ;
15648 PyObject * obj4 = 0 ;
15649 char *kwnames[] = {
15650 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15651 };
15652
15653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15655 if (SWIG_arg_fail(1)) SWIG_fail;
15656 {
15657 arg2 = static_cast<int >(SWIG_As_int(obj1));
15658 if (SWIG_arg_fail(2)) SWIG_fail;
15659 }
15660 {
15661 arg3 = static_cast<int >(SWIG_As_int(obj2));
15662 if (SWIG_arg_fail(3)) SWIG_fail;
15663 }
15664 {
15665 arg4 = static_cast<int >(SWIG_As_int(obj3));
15666 if (SWIG_arg_fail(4)) SWIG_fail;
15667 }
15668 arg5 = obj4;
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15672
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 Py_INCREF(Py_None); resultobj = Py_None;
15677 return resultobj;
15678 fail:
15679 return NULL;
15680 }
15681
15682
15683 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15684 PyObject *resultobj = NULL;
15685 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15686 int arg2 ;
15687 int arg3 = (int) -1 ;
15688 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15689 bool result;
15690 PyObject * obj0 = 0 ;
15691 PyObject * obj1 = 0 ;
15692 PyObject * obj2 = 0 ;
15693 PyObject * obj3 = 0 ;
15694 char *kwnames[] = {
15695 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15696 };
15697
15698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15700 if (SWIG_arg_fail(1)) SWIG_fail;
15701 {
15702 arg2 = static_cast<int >(SWIG_As_int(obj1));
15703 if (SWIG_arg_fail(2)) SWIG_fail;
15704 }
15705 if (obj2) {
15706 {
15707 arg3 = static_cast<int >(SWIG_As_int(obj2));
15708 if (SWIG_arg_fail(3)) SWIG_fail;
15709 }
15710 }
15711 if (obj3) {
15712 {
15713 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15714 if (SWIG_arg_fail(4)) SWIG_fail;
15715 }
15716 }
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15720
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 {
15725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15726 }
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj = NULL;
15735 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15736 PyObject *arg2 = (PyObject *) 0 ;
15737 bool arg3 = (bool) true ;
15738 PyObject * obj0 = 0 ;
15739 PyObject * obj1 = 0 ;
15740 PyObject * obj2 = 0 ;
15741 char *kwnames[] = {
15742 (char *) "self",(char *) "_self",(char *) "incref", NULL
15743 };
15744
15745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15747 if (SWIG_arg_fail(1)) SWIG_fail;
15748 arg2 = obj1;
15749 if (obj2) {
15750 {
15751 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15752 if (SWIG_arg_fail(3)) SWIG_fail;
15753 }
15754 }
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15758
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 Py_INCREF(Py_None); resultobj = Py_None;
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15770 PyObject *obj;
15771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15772 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15773 Py_INCREF(obj);
15774 return Py_BuildValue((char *)"");
15775 }
15776 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj = NULL;
15778 wxEventType result;
15779 char *kwnames[] = {
15780 NULL
15781 };
15782
15783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15784 {
15785 PyThreadState* __tstate = wxPyBeginAllowThreads();
15786 result = (wxEventType)wxNewEventType();
15787
15788 wxPyEndAllowThreads(__tstate);
15789 if (PyErr_Occurred()) SWIG_fail;
15790 }
15791 {
15792 resultobj = SWIG_From_int(static_cast<int >(result));
15793 }
15794 return resultobj;
15795 fail:
15796 return NULL;
15797 }
15798
15799
15800 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15801 PyObject *resultobj = NULL;
15802 wxEvent *arg1 = (wxEvent *) 0 ;
15803 PyObject * obj0 = 0 ;
15804 char *kwnames[] = {
15805 (char *) "self", NULL
15806 };
15807
15808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15810 if (SWIG_arg_fail(1)) SWIG_fail;
15811 {
15812 PyThreadState* __tstate = wxPyBeginAllowThreads();
15813 delete arg1;
15814
15815 wxPyEndAllowThreads(__tstate);
15816 if (PyErr_Occurred()) SWIG_fail;
15817 }
15818 Py_INCREF(Py_None); resultobj = Py_None;
15819 return resultobj;
15820 fail:
15821 return NULL;
15822 }
15823
15824
15825 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15826 PyObject *resultobj = NULL;
15827 wxEvent *arg1 = (wxEvent *) 0 ;
15828 wxEventType arg2 ;
15829 PyObject * obj0 = 0 ;
15830 PyObject * obj1 = 0 ;
15831 char *kwnames[] = {
15832 (char *) "self",(char *) "typ", NULL
15833 };
15834
15835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15837 if (SWIG_arg_fail(1)) SWIG_fail;
15838 {
15839 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15840 if (SWIG_arg_fail(2)) SWIG_fail;
15841 }
15842 {
15843 PyThreadState* __tstate = wxPyBeginAllowThreads();
15844 (arg1)->SetEventType(arg2);
15845
15846 wxPyEndAllowThreads(__tstate);
15847 if (PyErr_Occurred()) SWIG_fail;
15848 }
15849 Py_INCREF(Py_None); resultobj = Py_None;
15850 return resultobj;
15851 fail:
15852 return NULL;
15853 }
15854
15855
15856 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15857 PyObject *resultobj = NULL;
15858 wxEvent *arg1 = (wxEvent *) 0 ;
15859 wxEventType result;
15860 PyObject * obj0 = 0 ;
15861 char *kwnames[] = {
15862 (char *) "self", NULL
15863 };
15864
15865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15867 if (SWIG_arg_fail(1)) SWIG_fail;
15868 {
15869 PyThreadState* __tstate = wxPyBeginAllowThreads();
15870 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15871
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 {
15876 resultobj = SWIG_From_int(static_cast<int >(result));
15877 }
15878 return resultobj;
15879 fail:
15880 return NULL;
15881 }
15882
15883
15884 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15885 PyObject *resultobj = NULL;
15886 wxEvent *arg1 = (wxEvent *) 0 ;
15887 wxObject *result;
15888 PyObject * obj0 = 0 ;
15889 char *kwnames[] = {
15890 (char *) "self", NULL
15891 };
15892
15893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15895 if (SWIG_arg_fail(1)) SWIG_fail;
15896 {
15897 PyThreadState* __tstate = wxPyBeginAllowThreads();
15898 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15899
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 {
15904 resultobj = wxPyMake_wxObject(result, (bool)0);
15905 }
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj = NULL;
15914 wxEvent *arg1 = (wxEvent *) 0 ;
15915 wxObject *arg2 = (wxObject *) 0 ;
15916 PyObject * obj0 = 0 ;
15917 PyObject * obj1 = 0 ;
15918 char *kwnames[] = {
15919 (char *) "self",(char *) "obj", NULL
15920 };
15921
15922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15924 if (SWIG_arg_fail(1)) SWIG_fail;
15925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15926 if (SWIG_arg_fail(2)) SWIG_fail;
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 (arg1)->SetEventObject(arg2);
15930
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 Py_INCREF(Py_None); resultobj = Py_None;
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15942 PyObject *resultobj = NULL;
15943 wxEvent *arg1 = (wxEvent *) 0 ;
15944 long result;
15945 PyObject * obj0 = 0 ;
15946 char *kwnames[] = {
15947 (char *) "self", NULL
15948 };
15949
15950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15952 if (SWIG_arg_fail(1)) SWIG_fail;
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15956
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 {
15961 resultobj = SWIG_From_long(static_cast<long >(result));
15962 }
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj = NULL;
15971 wxEvent *arg1 = (wxEvent *) 0 ;
15972 long arg2 = (long) 0 ;
15973 PyObject * obj0 = 0 ;
15974 PyObject * obj1 = 0 ;
15975 char *kwnames[] = {
15976 (char *) "self",(char *) "ts", NULL
15977 };
15978
15979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15981 if (SWIG_arg_fail(1)) SWIG_fail;
15982 if (obj1) {
15983 {
15984 arg2 = static_cast<long >(SWIG_As_long(obj1));
15985 if (SWIG_arg_fail(2)) SWIG_fail;
15986 }
15987 }
15988 {
15989 PyThreadState* __tstate = wxPyBeginAllowThreads();
15990 (arg1)->SetTimestamp(arg2);
15991
15992 wxPyEndAllowThreads(__tstate);
15993 if (PyErr_Occurred()) SWIG_fail;
15994 }
15995 Py_INCREF(Py_None); resultobj = Py_None;
15996 return resultobj;
15997 fail:
15998 return NULL;
15999 }
16000
16001
16002 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
16003 PyObject *resultobj = NULL;
16004 wxEvent *arg1 = (wxEvent *) 0 ;
16005 int result;
16006 PyObject * obj0 = 0 ;
16007 char *kwnames[] = {
16008 (char *) "self", NULL
16009 };
16010
16011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
16012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16013 if (SWIG_arg_fail(1)) SWIG_fail;
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 result = (int)((wxEvent const *)arg1)->GetId();
16017
16018 wxPyEndAllowThreads(__tstate);
16019 if (PyErr_Occurred()) SWIG_fail;
16020 }
16021 {
16022 resultobj = SWIG_From_int(static_cast<int >(result));
16023 }
16024 return resultobj;
16025 fail:
16026 return NULL;
16027 }
16028
16029
16030 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
16031 PyObject *resultobj = NULL;
16032 wxEvent *arg1 = (wxEvent *) 0 ;
16033 int arg2 ;
16034 PyObject * obj0 = 0 ;
16035 PyObject * obj1 = 0 ;
16036 char *kwnames[] = {
16037 (char *) "self",(char *) "Id", NULL
16038 };
16039
16040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
16041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16042 if (SWIG_arg_fail(1)) SWIG_fail;
16043 {
16044 arg2 = static_cast<int >(SWIG_As_int(obj1));
16045 if (SWIG_arg_fail(2)) SWIG_fail;
16046 }
16047 {
16048 PyThreadState* __tstate = wxPyBeginAllowThreads();
16049 (arg1)->SetId(arg2);
16050
16051 wxPyEndAllowThreads(__tstate);
16052 if (PyErr_Occurred()) SWIG_fail;
16053 }
16054 Py_INCREF(Py_None); resultobj = Py_None;
16055 return resultobj;
16056 fail:
16057 return NULL;
16058 }
16059
16060
16061 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16062 PyObject *resultobj = NULL;
16063 wxEvent *arg1 = (wxEvent *) 0 ;
16064 bool result;
16065 PyObject * obj0 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "self", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(1)) SWIG_fail;
16073 {
16074 PyThreadState* __tstate = wxPyBeginAllowThreads();
16075 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16076
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 {
16081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16082 }
16083 return resultobj;
16084 fail:
16085 return NULL;
16086 }
16087
16088
16089 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16090 PyObject *resultobj = NULL;
16091 wxEvent *arg1 = (wxEvent *) 0 ;
16092 bool arg2 = (bool) true ;
16093 PyObject * obj0 = 0 ;
16094 PyObject * obj1 = 0 ;
16095 char *kwnames[] = {
16096 (char *) "self",(char *) "skip", NULL
16097 };
16098
16099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16101 if (SWIG_arg_fail(1)) SWIG_fail;
16102 if (obj1) {
16103 {
16104 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16105 if (SWIG_arg_fail(2)) SWIG_fail;
16106 }
16107 }
16108 {
16109 PyThreadState* __tstate = wxPyBeginAllowThreads();
16110 (arg1)->Skip(arg2);
16111
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 Py_INCREF(Py_None); resultobj = Py_None;
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16123 PyObject *resultobj = NULL;
16124 wxEvent *arg1 = (wxEvent *) 0 ;
16125 bool result;
16126 PyObject * obj0 = 0 ;
16127 char *kwnames[] = {
16128 (char *) "self", NULL
16129 };
16130
16131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16133 if (SWIG_arg_fail(1)) SWIG_fail;
16134 {
16135 PyThreadState* __tstate = wxPyBeginAllowThreads();
16136 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16137
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 {
16142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16143 }
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj = NULL;
16152 wxEvent *arg1 = (wxEvent *) 0 ;
16153 bool result;
16154 PyObject * obj0 = 0 ;
16155 char *kwnames[] = {
16156 (char *) "self", NULL
16157 };
16158
16159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16161 if (SWIG_arg_fail(1)) SWIG_fail;
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16165
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 {
16170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16171 }
16172 return resultobj;
16173 fail:
16174 return NULL;
16175 }
16176
16177
16178 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16179 PyObject *resultobj = NULL;
16180 wxEvent *arg1 = (wxEvent *) 0 ;
16181 int result;
16182 PyObject * obj0 = 0 ;
16183 char *kwnames[] = {
16184 (char *) "self", NULL
16185 };
16186
16187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16189 if (SWIG_arg_fail(1)) SWIG_fail;
16190 {
16191 PyThreadState* __tstate = wxPyBeginAllowThreads();
16192 result = (int)(arg1)->StopPropagation();
16193
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 {
16198 resultobj = SWIG_From_int(static_cast<int >(result));
16199 }
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16207 PyObject *resultobj = NULL;
16208 wxEvent *arg1 = (wxEvent *) 0 ;
16209 int arg2 ;
16210 PyObject * obj0 = 0 ;
16211 PyObject * obj1 = 0 ;
16212 char *kwnames[] = {
16213 (char *) "self",(char *) "propagationLevel", NULL
16214 };
16215
16216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16218 if (SWIG_arg_fail(1)) SWIG_fail;
16219 {
16220 arg2 = static_cast<int >(SWIG_As_int(obj1));
16221 if (SWIG_arg_fail(2)) SWIG_fail;
16222 }
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 (arg1)->ResumePropagation(arg2);
16226
16227 wxPyEndAllowThreads(__tstate);
16228 if (PyErr_Occurred()) SWIG_fail;
16229 }
16230 Py_INCREF(Py_None); resultobj = Py_None;
16231 return resultobj;
16232 fail:
16233 return NULL;
16234 }
16235
16236
16237 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16238 PyObject *resultobj = NULL;
16239 wxEvent *arg1 = (wxEvent *) 0 ;
16240 wxEvent *result;
16241 PyObject * obj0 = 0 ;
16242 char *kwnames[] = {
16243 (char *) "self", NULL
16244 };
16245
16246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16248 if (SWIG_arg_fail(1)) SWIG_fail;
16249 {
16250 PyThreadState* __tstate = wxPyBeginAllowThreads();
16251 result = (wxEvent *)(arg1)->Clone();
16252
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16264 PyObject *obj;
16265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16266 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16267 Py_INCREF(obj);
16268 return Py_BuildValue((char *)"");
16269 }
16270 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16271 PyObject *resultobj = NULL;
16272 wxEvent *arg1 = 0 ;
16273 wxPropagationDisabler *result;
16274 PyObject * obj0 = 0 ;
16275 char *kwnames[] = {
16276 (char *) "event", NULL
16277 };
16278
16279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16280 {
16281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16282 if (SWIG_arg_fail(1)) SWIG_fail;
16283 if (arg1 == NULL) {
16284 SWIG_null_ref("wxEvent");
16285 }
16286 if (SWIG_arg_fail(1)) SWIG_fail;
16287 }
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16291
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16296 return resultobj;
16297 fail:
16298 return NULL;
16299 }
16300
16301
16302 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16303 PyObject *resultobj = NULL;
16304 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16305 PyObject * obj0 = 0 ;
16306 char *kwnames[] = {
16307 (char *) "self", NULL
16308 };
16309
16310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16312 if (SWIG_arg_fail(1)) SWIG_fail;
16313 {
16314 PyThreadState* __tstate = wxPyBeginAllowThreads();
16315 delete arg1;
16316
16317 wxPyEndAllowThreads(__tstate);
16318 if (PyErr_Occurred()) SWIG_fail;
16319 }
16320 Py_INCREF(Py_None); resultobj = Py_None;
16321 return resultobj;
16322 fail:
16323 return NULL;
16324 }
16325
16326
16327 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16328 PyObject *obj;
16329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16330 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16331 Py_INCREF(obj);
16332 return Py_BuildValue((char *)"");
16333 }
16334 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16335 PyObject *resultobj = NULL;
16336 wxEvent *arg1 = 0 ;
16337 wxPropagateOnce *result;
16338 PyObject * obj0 = 0 ;
16339 char *kwnames[] = {
16340 (char *) "event", NULL
16341 };
16342
16343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16344 {
16345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16346 if (SWIG_arg_fail(1)) SWIG_fail;
16347 if (arg1 == NULL) {
16348 SWIG_null_ref("wxEvent");
16349 }
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 }
16352 {
16353 PyThreadState* __tstate = wxPyBeginAllowThreads();
16354 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16355
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16367 PyObject *resultobj = NULL;
16368 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16369 PyObject * obj0 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 PyThreadState* __tstate = wxPyBeginAllowThreads();
16379 delete arg1;
16380
16381 wxPyEndAllowThreads(__tstate);
16382 if (PyErr_Occurred()) SWIG_fail;
16383 }
16384 Py_INCREF(Py_None); resultobj = Py_None;
16385 return resultobj;
16386 fail:
16387 return NULL;
16388 }
16389
16390
16391 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16392 PyObject *obj;
16393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16394 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16395 Py_INCREF(obj);
16396 return Py_BuildValue((char *)"");
16397 }
16398 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16399 PyObject *resultobj = NULL;
16400 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16401 int arg2 = (int) 0 ;
16402 wxCommandEvent *result;
16403 PyObject * obj0 = 0 ;
16404 PyObject * obj1 = 0 ;
16405 char *kwnames[] = {
16406 (char *) "commandType",(char *) "winid", NULL
16407 };
16408
16409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16410 if (obj0) {
16411 {
16412 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16413 if (SWIG_arg_fail(1)) SWIG_fail;
16414 }
16415 }
16416 if (obj1) {
16417 {
16418 arg2 = static_cast<int >(SWIG_As_int(obj1));
16419 if (SWIG_arg_fail(2)) SWIG_fail;
16420 }
16421 }
16422 {
16423 PyThreadState* __tstate = wxPyBeginAllowThreads();
16424 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16425
16426 wxPyEndAllowThreads(__tstate);
16427 if (PyErr_Occurred()) SWIG_fail;
16428 }
16429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16430 return resultobj;
16431 fail:
16432 return NULL;
16433 }
16434
16435
16436 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16437 PyObject *resultobj = NULL;
16438 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16439 int result;
16440 PyObject * obj0 = 0 ;
16441 char *kwnames[] = {
16442 (char *) "self", NULL
16443 };
16444
16445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16447 if (SWIG_arg_fail(1)) SWIG_fail;
16448 {
16449 PyThreadState* __tstate = wxPyBeginAllowThreads();
16450 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16451
16452 wxPyEndAllowThreads(__tstate);
16453 if (PyErr_Occurred()) SWIG_fail;
16454 }
16455 {
16456 resultobj = SWIG_From_int(static_cast<int >(result));
16457 }
16458 return resultobj;
16459 fail:
16460 return NULL;
16461 }
16462
16463
16464 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16465 PyObject *resultobj = NULL;
16466 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16467 wxString *arg2 = 0 ;
16468 bool temp2 = false ;
16469 PyObject * obj0 = 0 ;
16470 PyObject * obj1 = 0 ;
16471 char *kwnames[] = {
16472 (char *) "self",(char *) "s", NULL
16473 };
16474
16475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16477 if (SWIG_arg_fail(1)) SWIG_fail;
16478 {
16479 arg2 = wxString_in_helper(obj1);
16480 if (arg2 == NULL) SWIG_fail;
16481 temp2 = true;
16482 }
16483 {
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 (arg1)->SetString((wxString const &)*arg2);
16486
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 Py_INCREF(Py_None); resultobj = Py_None;
16491 {
16492 if (temp2)
16493 delete arg2;
16494 }
16495 return resultobj;
16496 fail:
16497 {
16498 if (temp2)
16499 delete arg2;
16500 }
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj = NULL;
16507 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16508 wxString result;
16509 PyObject * obj0 = 0 ;
16510 char *kwnames[] = {
16511 (char *) "self", NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16516 if (SWIG_arg_fail(1)) SWIG_fail;
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = ((wxCommandEvent const *)arg1)->GetString();
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 #if wxUSE_UNICODE
16526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16527 #else
16528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16529 #endif
16530 }
16531 return resultobj;
16532 fail:
16533 return NULL;
16534 }
16535
16536
16537 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16538 PyObject *resultobj = NULL;
16539 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16540 bool result;
16541 PyObject * obj0 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "self", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16552
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 {
16557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16558 }
16559 return resultobj;
16560 fail:
16561 return NULL;
16562 }
16563
16564
16565 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16566 PyObject *resultobj = NULL;
16567 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16568 bool result;
16569 PyObject * obj0 = 0 ;
16570 char *kwnames[] = {
16571 (char *) "self", NULL
16572 };
16573
16574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16576 if (SWIG_arg_fail(1)) SWIG_fail;
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16580
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 {
16585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16586 }
16587 return resultobj;
16588 fail:
16589 return NULL;
16590 }
16591
16592
16593 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj = NULL;
16595 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16596 long arg2 ;
16597 PyObject * obj0 = 0 ;
16598 PyObject * obj1 = 0 ;
16599 char *kwnames[] = {
16600 (char *) "self",(char *) "extraLong", NULL
16601 };
16602
16603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16605 if (SWIG_arg_fail(1)) SWIG_fail;
16606 {
16607 arg2 = static_cast<long >(SWIG_As_long(obj1));
16608 if (SWIG_arg_fail(2)) SWIG_fail;
16609 }
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 (arg1)->SetExtraLong(arg2);
16613
16614 wxPyEndAllowThreads(__tstate);
16615 if (PyErr_Occurred()) SWIG_fail;
16616 }
16617 Py_INCREF(Py_None); resultobj = Py_None;
16618 return resultobj;
16619 fail:
16620 return NULL;
16621 }
16622
16623
16624 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16625 PyObject *resultobj = NULL;
16626 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16627 long result;
16628 PyObject * obj0 = 0 ;
16629 char *kwnames[] = {
16630 (char *) "self", NULL
16631 };
16632
16633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16635 if (SWIG_arg_fail(1)) SWIG_fail;
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16639
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 {
16644 resultobj = SWIG_From_long(static_cast<long >(result));
16645 }
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = NULL;
16654 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16655 int arg2 ;
16656 PyObject * obj0 = 0 ;
16657 PyObject * obj1 = 0 ;
16658 char *kwnames[] = {
16659 (char *) "self",(char *) "i", NULL
16660 };
16661
16662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16664 if (SWIG_arg_fail(1)) SWIG_fail;
16665 {
16666 arg2 = static_cast<int >(SWIG_As_int(obj1));
16667 if (SWIG_arg_fail(2)) SWIG_fail;
16668 }
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 (arg1)->SetInt(arg2);
16672
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 Py_INCREF(Py_None); resultobj = Py_None;
16677 return resultobj;
16678 fail:
16679 return NULL;
16680 }
16681
16682
16683 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16684 PyObject *resultobj = NULL;
16685 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16686 long result;
16687 PyObject * obj0 = 0 ;
16688 char *kwnames[] = {
16689 (char *) "self", NULL
16690 };
16691
16692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16694 if (SWIG_arg_fail(1)) SWIG_fail;
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16698
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 {
16703 resultobj = SWIG_From_long(static_cast<long >(result));
16704 }
16705 return resultobj;
16706 fail:
16707 return NULL;
16708 }
16709
16710
16711 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16712 PyObject *resultobj = NULL;
16713 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16714 wxEvent *result;
16715 PyObject * obj0 = 0 ;
16716 char *kwnames[] = {
16717 (char *) "self", NULL
16718 };
16719
16720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16722 if (SWIG_arg_fail(1)) SWIG_fail;
16723 {
16724 PyThreadState* __tstate = wxPyBeginAllowThreads();
16725 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16726
16727 wxPyEndAllowThreads(__tstate);
16728 if (PyErr_Occurred()) SWIG_fail;
16729 }
16730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16731 return resultobj;
16732 fail:
16733 return NULL;
16734 }
16735
16736
16737 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16738 PyObject *obj;
16739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16740 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16741 Py_INCREF(obj);
16742 return Py_BuildValue((char *)"");
16743 }
16744 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16745 PyObject *resultobj = NULL;
16746 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16747 int arg2 = (int) 0 ;
16748 wxNotifyEvent *result;
16749 PyObject * obj0 = 0 ;
16750 PyObject * obj1 = 0 ;
16751 char *kwnames[] = {
16752 (char *) "commandType",(char *) "winid", NULL
16753 };
16754
16755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16756 if (obj0) {
16757 {
16758 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16759 if (SWIG_arg_fail(1)) SWIG_fail;
16760 }
16761 }
16762 if (obj1) {
16763 {
16764 arg2 = static_cast<int >(SWIG_As_int(obj1));
16765 if (SWIG_arg_fail(2)) SWIG_fail;
16766 }
16767 }
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj = NULL;
16784 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16785 PyObject * obj0 = 0 ;
16786 char *kwnames[] = {
16787 (char *) "self", NULL
16788 };
16789
16790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16792 if (SWIG_arg_fail(1)) SWIG_fail;
16793 {
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 (arg1)->Veto();
16796
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 Py_INCREF(Py_None); resultobj = Py_None;
16801 return resultobj;
16802 fail:
16803 return NULL;
16804 }
16805
16806
16807 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16808 PyObject *resultobj = NULL;
16809 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16810 PyObject * obj0 = 0 ;
16811 char *kwnames[] = {
16812 (char *) "self", NULL
16813 };
16814
16815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16817 if (SWIG_arg_fail(1)) SWIG_fail;
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 (arg1)->Allow();
16821
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 Py_INCREF(Py_None); resultobj = Py_None;
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj = NULL;
16834 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16835 bool result;
16836 PyObject * obj0 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "self", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16843 if (SWIG_arg_fail(1)) SWIG_fail;
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = (bool)(arg1)->IsAllowed();
16847
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 {
16852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16853 }
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16861 PyObject *obj;
16862 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16863 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16864 Py_INCREF(obj);
16865 return Py_BuildValue((char *)"");
16866 }
16867 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj = NULL;
16869 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16870 int arg2 = (int) 0 ;
16871 int arg3 = (int) 0 ;
16872 int arg4 = (int) 0 ;
16873 wxScrollEvent *result;
16874 PyObject * obj0 = 0 ;
16875 PyObject * obj1 = 0 ;
16876 PyObject * obj2 = 0 ;
16877 PyObject * obj3 = 0 ;
16878 char *kwnames[] = {
16879 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16880 };
16881
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16883 if (obj0) {
16884 {
16885 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16886 if (SWIG_arg_fail(1)) SWIG_fail;
16887 }
16888 }
16889 if (obj1) {
16890 {
16891 arg2 = static_cast<int >(SWIG_As_int(obj1));
16892 if (SWIG_arg_fail(2)) SWIG_fail;
16893 }
16894 }
16895 if (obj2) {
16896 {
16897 arg3 = static_cast<int >(SWIG_As_int(obj2));
16898 if (SWIG_arg_fail(3)) SWIG_fail;
16899 }
16900 }
16901 if (obj3) {
16902 {
16903 arg4 = static_cast<int >(SWIG_As_int(obj3));
16904 if (SWIG_arg_fail(4)) SWIG_fail;
16905 }
16906 }
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16910
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16915 return resultobj;
16916 fail:
16917 return NULL;
16918 }
16919
16920
16921 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16922 PyObject *resultobj = NULL;
16923 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16924 int result;
16925 PyObject * obj0 = 0 ;
16926 char *kwnames[] = {
16927 (char *) "self", NULL
16928 };
16929
16930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16932 if (SWIG_arg_fail(1)) SWIG_fail;
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16936
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 {
16941 resultobj = SWIG_From_int(static_cast<int >(result));
16942 }
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16950 PyObject *resultobj = NULL;
16951 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16952 int result;
16953 PyObject * obj0 = 0 ;
16954 char *kwnames[] = {
16955 (char *) "self", NULL
16956 };
16957
16958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16960 if (SWIG_arg_fail(1)) SWIG_fail;
16961 {
16962 PyThreadState* __tstate = wxPyBeginAllowThreads();
16963 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16964
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 {
16969 resultobj = SWIG_From_int(static_cast<int >(result));
16970 }
16971 return resultobj;
16972 fail:
16973 return NULL;
16974 }
16975
16976
16977 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16978 PyObject *resultobj = NULL;
16979 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16980 int arg2 ;
16981 PyObject * obj0 = 0 ;
16982 PyObject * obj1 = 0 ;
16983 char *kwnames[] = {
16984 (char *) "self",(char *) "orient", NULL
16985 };
16986
16987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16989 if (SWIG_arg_fail(1)) SWIG_fail;
16990 {
16991 arg2 = static_cast<int >(SWIG_As_int(obj1));
16992 if (SWIG_arg_fail(2)) SWIG_fail;
16993 }
16994 {
16995 PyThreadState* __tstate = wxPyBeginAllowThreads();
16996 (arg1)->SetOrientation(arg2);
16997
16998 wxPyEndAllowThreads(__tstate);
16999 if (PyErr_Occurred()) SWIG_fail;
17000 }
17001 Py_INCREF(Py_None); resultobj = Py_None;
17002 return resultobj;
17003 fail:
17004 return NULL;
17005 }
17006
17007
17008 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj = NULL;
17010 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
17011 int arg2 ;
17012 PyObject * obj0 = 0 ;
17013 PyObject * obj1 = 0 ;
17014 char *kwnames[] = {
17015 (char *) "self",(char *) "pos", NULL
17016 };
17017
17018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
17020 if (SWIG_arg_fail(1)) SWIG_fail;
17021 {
17022 arg2 = static_cast<int >(SWIG_As_int(obj1));
17023 if (SWIG_arg_fail(2)) SWIG_fail;
17024 }
17025 {
17026 PyThreadState* __tstate = wxPyBeginAllowThreads();
17027 (arg1)->SetPosition(arg2);
17028
17029 wxPyEndAllowThreads(__tstate);
17030 if (PyErr_Occurred()) SWIG_fail;
17031 }
17032 Py_INCREF(Py_None); resultobj = Py_None;
17033 return resultobj;
17034 fail:
17035 return NULL;
17036 }
17037
17038
17039 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
17040 PyObject *obj;
17041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17042 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
17043 Py_INCREF(obj);
17044 return Py_BuildValue((char *)"");
17045 }
17046 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17047 PyObject *resultobj = NULL;
17048 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17049 int arg2 = (int) 0 ;
17050 int arg3 = (int) 0 ;
17051 wxScrollWinEvent *result;
17052 PyObject * obj0 = 0 ;
17053 PyObject * obj1 = 0 ;
17054 PyObject * obj2 = 0 ;
17055 char *kwnames[] = {
17056 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17057 };
17058
17059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17060 if (obj0) {
17061 {
17062 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17063 if (SWIG_arg_fail(1)) SWIG_fail;
17064 }
17065 }
17066 if (obj1) {
17067 {
17068 arg2 = static_cast<int >(SWIG_As_int(obj1));
17069 if (SWIG_arg_fail(2)) SWIG_fail;
17070 }
17071 }
17072 if (obj2) {
17073 {
17074 arg3 = static_cast<int >(SWIG_As_int(obj2));
17075 if (SWIG_arg_fail(3)) SWIG_fail;
17076 }
17077 }
17078 {
17079 PyThreadState* __tstate = wxPyBeginAllowThreads();
17080 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17081
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17093 PyObject *resultobj = NULL;
17094 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17095 int result;
17096 PyObject * obj0 = 0 ;
17097 char *kwnames[] = {
17098 (char *) "self", NULL
17099 };
17100
17101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17103 if (SWIG_arg_fail(1)) SWIG_fail;
17104 {
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17107
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 {
17112 resultobj = SWIG_From_int(static_cast<int >(result));
17113 }
17114 return resultobj;
17115 fail:
17116 return NULL;
17117 }
17118
17119
17120 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17121 PyObject *resultobj = NULL;
17122 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17123 int result;
17124 PyObject * obj0 = 0 ;
17125 char *kwnames[] = {
17126 (char *) "self", NULL
17127 };
17128
17129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17131 if (SWIG_arg_fail(1)) SWIG_fail;
17132 {
17133 PyThreadState* __tstate = wxPyBeginAllowThreads();
17134 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17135
17136 wxPyEndAllowThreads(__tstate);
17137 if (PyErr_Occurred()) SWIG_fail;
17138 }
17139 {
17140 resultobj = SWIG_From_int(static_cast<int >(result));
17141 }
17142 return resultobj;
17143 fail:
17144 return NULL;
17145 }
17146
17147
17148 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17149 PyObject *resultobj = NULL;
17150 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17151 int arg2 ;
17152 PyObject * obj0 = 0 ;
17153 PyObject * obj1 = 0 ;
17154 char *kwnames[] = {
17155 (char *) "self",(char *) "orient", NULL
17156 };
17157
17158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17160 if (SWIG_arg_fail(1)) SWIG_fail;
17161 {
17162 arg2 = static_cast<int >(SWIG_As_int(obj1));
17163 if (SWIG_arg_fail(2)) SWIG_fail;
17164 }
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 (arg1)->SetOrientation(arg2);
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 Py_INCREF(Py_None); resultobj = Py_None;
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj = NULL;
17181 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17182 int arg2 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "pos", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 arg2 = static_cast<int >(SWIG_As_int(obj1));
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 }
17196 {
17197 PyThreadState* __tstate = wxPyBeginAllowThreads();
17198 (arg1)->SetPosition(arg2);
17199
17200 wxPyEndAllowThreads(__tstate);
17201 if (PyErr_Occurred()) SWIG_fail;
17202 }
17203 Py_INCREF(Py_None); resultobj = Py_None;
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17211 PyObject *obj;
17212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17213 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17214 Py_INCREF(obj);
17215 return Py_BuildValue((char *)"");
17216 }
17217 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17218 PyObject *resultobj = NULL;
17219 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17220 wxMouseEvent *result;
17221 PyObject * obj0 = 0 ;
17222 char *kwnames[] = {
17223 (char *) "mouseType", NULL
17224 };
17225
17226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17227 if (obj0) {
17228 {
17229 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17230 if (SWIG_arg_fail(1)) SWIG_fail;
17231 }
17232 }
17233 {
17234 PyThreadState* __tstate = wxPyBeginAllowThreads();
17235 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17236
17237 wxPyEndAllowThreads(__tstate);
17238 if (PyErr_Occurred()) SWIG_fail;
17239 }
17240 {
17241 resultobj = wxPyMake_wxObject(result, (bool)1);
17242 }
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj = NULL;
17251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17252 bool result;
17253 PyObject * obj0 = 0 ;
17254 char *kwnames[] = {
17255 (char *) "self", NULL
17256 };
17257
17258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17260 if (SWIG_arg_fail(1)) SWIG_fail;
17261 {
17262 PyThreadState* __tstate = wxPyBeginAllowThreads();
17263 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17264
17265 wxPyEndAllowThreads(__tstate);
17266 if (PyErr_Occurred()) SWIG_fail;
17267 }
17268 {
17269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17270 }
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj = NULL;
17279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17280 int arg2 = (int) wxMOUSE_BTN_ANY ;
17281 bool result;
17282 PyObject * obj0 = 0 ;
17283 PyObject * obj1 = 0 ;
17284 char *kwnames[] = {
17285 (char *) "self",(char *) "but", NULL
17286 };
17287
17288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17290 if (SWIG_arg_fail(1)) SWIG_fail;
17291 if (obj1) {
17292 {
17293 arg2 = static_cast<int >(SWIG_As_int(obj1));
17294 if (SWIG_arg_fail(2)) SWIG_fail;
17295 }
17296 }
17297 {
17298 PyThreadState* __tstate = wxPyBeginAllowThreads();
17299 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17300
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 {
17305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17306 }
17307 return resultobj;
17308 fail:
17309 return NULL;
17310 }
17311
17312
17313 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17314 PyObject *resultobj = NULL;
17315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17316 int arg2 = (int) wxMOUSE_BTN_ANY ;
17317 bool result;
17318 PyObject * obj0 = 0 ;
17319 PyObject * obj1 = 0 ;
17320 char *kwnames[] = {
17321 (char *) "self",(char *) "but", NULL
17322 };
17323
17324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17326 if (SWIG_arg_fail(1)) SWIG_fail;
17327 if (obj1) {
17328 {
17329 arg2 = static_cast<int >(SWIG_As_int(obj1));
17330 if (SWIG_arg_fail(2)) SWIG_fail;
17331 }
17332 }
17333 {
17334 PyThreadState* __tstate = wxPyBeginAllowThreads();
17335 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17336
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 {
17341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17342 }
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17350 PyObject *resultobj = NULL;
17351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17352 int arg2 = (int) wxMOUSE_BTN_ANY ;
17353 bool result;
17354 PyObject * obj0 = 0 ;
17355 PyObject * obj1 = 0 ;
17356 char *kwnames[] = {
17357 (char *) "self",(char *) "but", NULL
17358 };
17359
17360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17362 if (SWIG_arg_fail(1)) SWIG_fail;
17363 if (obj1) {
17364 {
17365 arg2 = static_cast<int >(SWIG_As_int(obj1));
17366 if (SWIG_arg_fail(2)) SWIG_fail;
17367 }
17368 }
17369 {
17370 PyThreadState* __tstate = wxPyBeginAllowThreads();
17371 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17372
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 {
17377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17378 }
17379 return resultobj;
17380 fail:
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj = NULL;
17387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17388 int arg2 ;
17389 bool result;
17390 PyObject * obj0 = 0 ;
17391 PyObject * obj1 = 0 ;
17392 char *kwnames[] = {
17393 (char *) "self",(char *) "button", NULL
17394 };
17395
17396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17398 if (SWIG_arg_fail(1)) SWIG_fail;
17399 {
17400 arg2 = static_cast<int >(SWIG_As_int(obj1));
17401 if (SWIG_arg_fail(2)) SWIG_fail;
17402 }
17403 {
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17406
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17412 }
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17420 PyObject *resultobj = NULL;
17421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17422 int arg2 ;
17423 bool result;
17424 PyObject * obj0 = 0 ;
17425 PyObject * obj1 = 0 ;
17426 char *kwnames[] = {
17427 (char *) "self",(char *) "but", NULL
17428 };
17429
17430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17432 if (SWIG_arg_fail(1)) SWIG_fail;
17433 {
17434 arg2 = static_cast<int >(SWIG_As_int(obj1));
17435 if (SWIG_arg_fail(2)) SWIG_fail;
17436 }
17437 {
17438 PyThreadState* __tstate = wxPyBeginAllowThreads();
17439 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17440
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 {
17445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17446 }
17447 return resultobj;
17448 fail:
17449 return NULL;
17450 }
17451
17452
17453 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17454 PyObject *resultobj = NULL;
17455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17456 int result;
17457 PyObject * obj0 = 0 ;
17458 char *kwnames[] = {
17459 (char *) "self", NULL
17460 };
17461
17462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17464 if (SWIG_arg_fail(1)) SWIG_fail;
17465 {
17466 PyThreadState* __tstate = wxPyBeginAllowThreads();
17467 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17468
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 {
17473 resultobj = SWIG_From_int(static_cast<int >(result));
17474 }
17475 return resultobj;
17476 fail:
17477 return NULL;
17478 }
17479
17480
17481 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17482 PyObject *resultobj = NULL;
17483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17484 bool result;
17485 PyObject * obj0 = 0 ;
17486 char *kwnames[] = {
17487 (char *) "self", NULL
17488 };
17489
17490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17492 if (SWIG_arg_fail(1)) SWIG_fail;
17493 {
17494 PyThreadState* __tstate = wxPyBeginAllowThreads();
17495 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17496
17497 wxPyEndAllowThreads(__tstate);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 }
17500 {
17501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17502 }
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17510 PyObject *resultobj = NULL;
17511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17512 bool result;
17513 PyObject * obj0 = 0 ;
17514 char *kwnames[] = {
17515 (char *) "self", NULL
17516 };
17517
17518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17520 if (SWIG_arg_fail(1)) SWIG_fail;
17521 {
17522 PyThreadState* __tstate = wxPyBeginAllowThreads();
17523 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17524
17525 wxPyEndAllowThreads(__tstate);
17526 if (PyErr_Occurred()) SWIG_fail;
17527 }
17528 {
17529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17530 }
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17538 PyObject *resultobj = NULL;
17539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17540 bool result;
17541 PyObject * obj0 = 0 ;
17542 char *kwnames[] = {
17543 (char *) "self", NULL
17544 };
17545
17546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17548 if (SWIG_arg_fail(1)) SWIG_fail;
17549 {
17550 PyThreadState* __tstate = wxPyBeginAllowThreads();
17551 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17552
17553 wxPyEndAllowThreads(__tstate);
17554 if (PyErr_Occurred()) SWIG_fail;
17555 }
17556 {
17557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17558 }
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj = NULL;
17567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17568 bool result;
17569 PyObject * obj0 = 0 ;
17570 char *kwnames[] = {
17571 (char *) "self", NULL
17572 };
17573
17574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17576 if (SWIG_arg_fail(1)) SWIG_fail;
17577 {
17578 PyThreadState* __tstate = wxPyBeginAllowThreads();
17579 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17580
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17586 }
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17594 PyObject *resultobj = NULL;
17595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17596 bool result;
17597 PyObject * obj0 = 0 ;
17598 char *kwnames[] = {
17599 (char *) "self", NULL
17600 };
17601
17602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17604 if (SWIG_arg_fail(1)) SWIG_fail;
17605 {
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17608
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17614 }
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj = NULL;
17623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17624 bool result;
17625 PyObject * obj0 = 0 ;
17626 char *kwnames[] = {
17627 (char *) "self", NULL
17628 };
17629
17630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17632 if (SWIG_arg_fail(1)) SWIG_fail;
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17636
17637 wxPyEndAllowThreads(__tstate);
17638 if (PyErr_Occurred()) SWIG_fail;
17639 }
17640 {
17641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17642 }
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17650 PyObject *resultobj = NULL;
17651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17652 bool result;
17653 PyObject * obj0 = 0 ;
17654 char *kwnames[] = {
17655 (char *) "self", NULL
17656 };
17657
17658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17660 if (SWIG_arg_fail(1)) SWIG_fail;
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17664
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 {
17669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17670 }
17671 return resultobj;
17672 fail:
17673 return NULL;
17674 }
17675
17676
17677 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj = NULL;
17679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17680 bool result;
17681 PyObject * obj0 = 0 ;
17682 char *kwnames[] = {
17683 (char *) "self", NULL
17684 };
17685
17686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17688 if (SWIG_arg_fail(1)) SWIG_fail;
17689 {
17690 PyThreadState* __tstate = wxPyBeginAllowThreads();
17691 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17692
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 {
17697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17698 }
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj = NULL;
17707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17708 bool result;
17709 PyObject * obj0 = 0 ;
17710 char *kwnames[] = {
17711 (char *) "self", NULL
17712 };
17713
17714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17716 if (SWIG_arg_fail(1)) SWIG_fail;
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17720
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 {
17725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17726 }
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17734 PyObject *resultobj = NULL;
17735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17736 bool result;
17737 PyObject * obj0 = 0 ;
17738 char *kwnames[] = {
17739 (char *) "self", NULL
17740 };
17741
17742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17744 if (SWIG_arg_fail(1)) SWIG_fail;
17745 {
17746 PyThreadState* __tstate = wxPyBeginAllowThreads();
17747 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17748
17749 wxPyEndAllowThreads(__tstate);
17750 if (PyErr_Occurred()) SWIG_fail;
17751 }
17752 {
17753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17754 }
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj = NULL;
17763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17764 bool result;
17765 PyObject * obj0 = 0 ;
17766 char *kwnames[] = {
17767 (char *) "self", NULL
17768 };
17769
17770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17772 if (SWIG_arg_fail(1)) SWIG_fail;
17773 {
17774 PyThreadState* __tstate = wxPyBeginAllowThreads();
17775 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17776
17777 wxPyEndAllowThreads(__tstate);
17778 if (PyErr_Occurred()) SWIG_fail;
17779 }
17780 {
17781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17782 }
17783 return resultobj;
17784 fail:
17785 return NULL;
17786 }
17787
17788
17789 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17790 PyObject *resultobj = NULL;
17791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17792 bool result;
17793 PyObject * obj0 = 0 ;
17794 char *kwnames[] = {
17795 (char *) "self", NULL
17796 };
17797
17798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17800 if (SWIG_arg_fail(1)) SWIG_fail;
17801 {
17802 PyThreadState* __tstate = wxPyBeginAllowThreads();
17803 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17804
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 {
17809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17810 }
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj = NULL;
17819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17820 bool result;
17821 PyObject * obj0 = 0 ;
17822 char *kwnames[] = {
17823 (char *) "self", NULL
17824 };
17825
17826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17828 if (SWIG_arg_fail(1)) SWIG_fail;
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17832
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 {
17837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17838 }
17839 return resultobj;
17840 fail:
17841 return NULL;
17842 }
17843
17844
17845 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17846 PyObject *resultobj = NULL;
17847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17848 bool result;
17849 PyObject * obj0 = 0 ;
17850 char *kwnames[] = {
17851 (char *) "self", NULL
17852 };
17853
17854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17856 if (SWIG_arg_fail(1)) SWIG_fail;
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17860
17861 wxPyEndAllowThreads(__tstate);
17862 if (PyErr_Occurred()) SWIG_fail;
17863 }
17864 {
17865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj = NULL;
17875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17876 bool result;
17877 PyObject * obj0 = 0 ;
17878 char *kwnames[] = {
17879 (char *) "self", NULL
17880 };
17881
17882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17884 if (SWIG_arg_fail(1)) SWIG_fail;
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 result = (bool)(arg1)->LeftIsDown();
17888
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 {
17893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17894 }
17895 return resultobj;
17896 fail:
17897 return NULL;
17898 }
17899
17900
17901 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17902 PyObject *resultobj = NULL;
17903 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17904 bool result;
17905 PyObject * obj0 = 0 ;
17906 char *kwnames[] = {
17907 (char *) "self", NULL
17908 };
17909
17910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17912 if (SWIG_arg_fail(1)) SWIG_fail;
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 result = (bool)(arg1)->MiddleIsDown();
17916
17917 wxPyEndAllowThreads(__tstate);
17918 if (PyErr_Occurred()) SWIG_fail;
17919 }
17920 {
17921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17922 }
17923 return resultobj;
17924 fail:
17925 return NULL;
17926 }
17927
17928
17929 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17930 PyObject *resultobj = NULL;
17931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17932 bool result;
17933 PyObject * obj0 = 0 ;
17934 char *kwnames[] = {
17935 (char *) "self", NULL
17936 };
17937
17938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17940 if (SWIG_arg_fail(1)) SWIG_fail;
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (bool)(arg1)->RightIsDown();
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 {
17949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17950 }
17951 return resultobj;
17952 fail:
17953 return NULL;
17954 }
17955
17956
17957 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17958 PyObject *resultobj = NULL;
17959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17960 bool result;
17961 PyObject * obj0 = 0 ;
17962 char *kwnames[] = {
17963 (char *) "self", NULL
17964 };
17965
17966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17968 if (SWIG_arg_fail(1)) SWIG_fail;
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17972
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 {
17977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17978 }
17979 return resultobj;
17980 fail:
17981 return NULL;
17982 }
17983
17984
17985 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17986 PyObject *resultobj = NULL;
17987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17988 bool result;
17989 PyObject * obj0 = 0 ;
17990 char *kwnames[] = {
17991 (char *) "self", NULL
17992 };
17993
17994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 {
17998 PyThreadState* __tstate = wxPyBeginAllowThreads();
17999 result = (bool)((wxMouseEvent const *)arg1)->Moving();
18000
18001 wxPyEndAllowThreads(__tstate);
18002 if (PyErr_Occurred()) SWIG_fail;
18003 }
18004 {
18005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18006 }
18007 return resultobj;
18008 fail:
18009 return NULL;
18010 }
18011
18012
18013 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
18014 PyObject *resultobj = NULL;
18015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18016 bool result;
18017 PyObject * obj0 = 0 ;
18018 char *kwnames[] = {
18019 (char *) "self", NULL
18020 };
18021
18022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
18023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18024 if (SWIG_arg_fail(1)) SWIG_fail;
18025 {
18026 PyThreadState* __tstate = wxPyBeginAllowThreads();
18027 result = (bool)((wxMouseEvent const *)arg1)->Entering();
18028
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 {
18033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18034 }
18035 return resultobj;
18036 fail:
18037 return NULL;
18038 }
18039
18040
18041 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
18042 PyObject *resultobj = NULL;
18043 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18044 bool result;
18045 PyObject * obj0 = 0 ;
18046 char *kwnames[] = {
18047 (char *) "self", NULL
18048 };
18049
18050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
18051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18052 if (SWIG_arg_fail(1)) SWIG_fail;
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18056
18057 wxPyEndAllowThreads(__tstate);
18058 if (PyErr_Occurred()) SWIG_fail;
18059 }
18060 {
18061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18062 }
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj = NULL;
18071 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18072 wxPoint result;
18073 PyObject * obj0 = 0 ;
18074 char *kwnames[] = {
18075 (char *) "self", NULL
18076 };
18077
18078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18080 if (SWIG_arg_fail(1)) SWIG_fail;
18081 {
18082 PyThreadState* __tstate = wxPyBeginAllowThreads();
18083 result = (arg1)->GetPosition();
18084
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 {
18089 wxPoint * resultptr;
18090 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18092 }
18093 return resultobj;
18094 fail:
18095 return NULL;
18096 }
18097
18098
18099 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18100 PyObject *resultobj = NULL;
18101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18102 long *arg2 = (long *) 0 ;
18103 long *arg3 = (long *) 0 ;
18104 long temp2 ;
18105 int res2 = 0 ;
18106 long temp3 ;
18107 int res3 = 0 ;
18108 PyObject * obj0 = 0 ;
18109 char *kwnames[] = {
18110 (char *) "self", NULL
18111 };
18112
18113 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18114 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18117 if (SWIG_arg_fail(1)) SWIG_fail;
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 (arg1)->GetPosition(arg2,arg3);
18121
18122 wxPyEndAllowThreads(__tstate);
18123 if (PyErr_Occurred()) SWIG_fail;
18124 }
18125 Py_INCREF(Py_None); resultobj = Py_None;
18126 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18127 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18128 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18129 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj = NULL;
18138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18139 wxDC *arg2 = 0 ;
18140 wxPoint result;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char *kwnames[] = {
18144 (char *) "self",(char *) "dc", NULL
18145 };
18146
18147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18149 if (SWIG_arg_fail(1)) SWIG_fail;
18150 {
18151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18152 if (SWIG_arg_fail(2)) SWIG_fail;
18153 if (arg2 == NULL) {
18154 SWIG_null_ref("wxDC");
18155 }
18156 if (SWIG_arg_fail(2)) SWIG_fail;
18157 }
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18161
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 {
18166 wxPoint * resultptr;
18167 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18169 }
18170 return resultobj;
18171 fail:
18172 return NULL;
18173 }
18174
18175
18176 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18177 PyObject *resultobj = NULL;
18178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18179 int result;
18180 PyObject * obj0 = 0 ;
18181 char *kwnames[] = {
18182 (char *) "self", NULL
18183 };
18184
18185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18187 if (SWIG_arg_fail(1)) SWIG_fail;
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (int)((wxMouseEvent const *)arg1)->GetX();
18191
18192 wxPyEndAllowThreads(__tstate);
18193 if (PyErr_Occurred()) SWIG_fail;
18194 }
18195 {
18196 resultobj = SWIG_From_int(static_cast<int >(result));
18197 }
18198 return resultobj;
18199 fail:
18200 return NULL;
18201 }
18202
18203
18204 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18205 PyObject *resultobj = NULL;
18206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18207 int result;
18208 PyObject * obj0 = 0 ;
18209 char *kwnames[] = {
18210 (char *) "self", NULL
18211 };
18212
18213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18215 if (SWIG_arg_fail(1)) SWIG_fail;
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (int)((wxMouseEvent const *)arg1)->GetY();
18219
18220 wxPyEndAllowThreads(__tstate);
18221 if (PyErr_Occurred()) SWIG_fail;
18222 }
18223 {
18224 resultobj = SWIG_From_int(static_cast<int >(result));
18225 }
18226 return resultobj;
18227 fail:
18228 return NULL;
18229 }
18230
18231
18232 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18233 PyObject *resultobj = NULL;
18234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18235 int result;
18236 PyObject * obj0 = 0 ;
18237 char *kwnames[] = {
18238 (char *) "self", NULL
18239 };
18240
18241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18243 if (SWIG_arg_fail(1)) SWIG_fail;
18244 {
18245 PyThreadState* __tstate = wxPyBeginAllowThreads();
18246 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18247
18248 wxPyEndAllowThreads(__tstate);
18249 if (PyErr_Occurred()) SWIG_fail;
18250 }
18251 {
18252 resultobj = SWIG_From_int(static_cast<int >(result));
18253 }
18254 return resultobj;
18255 fail:
18256 return NULL;
18257 }
18258
18259
18260 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18261 PyObject *resultobj = NULL;
18262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18263 int result;
18264 PyObject * obj0 = 0 ;
18265 char *kwnames[] = {
18266 (char *) "self", NULL
18267 };
18268
18269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18271 if (SWIG_arg_fail(1)) SWIG_fail;
18272 {
18273 PyThreadState* __tstate = wxPyBeginAllowThreads();
18274 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18275
18276 wxPyEndAllowThreads(__tstate);
18277 if (PyErr_Occurred()) SWIG_fail;
18278 }
18279 {
18280 resultobj = SWIG_From_int(static_cast<int >(result));
18281 }
18282 return resultobj;
18283 fail:
18284 return NULL;
18285 }
18286
18287
18288 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18289 PyObject *resultobj = NULL;
18290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18291 int result;
18292 PyObject * obj0 = 0 ;
18293 char *kwnames[] = {
18294 (char *) "self", NULL
18295 };
18296
18297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18299 if (SWIG_arg_fail(1)) SWIG_fail;
18300 {
18301 PyThreadState* __tstate = wxPyBeginAllowThreads();
18302 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18303
18304 wxPyEndAllowThreads(__tstate);
18305 if (PyErr_Occurred()) SWIG_fail;
18306 }
18307 {
18308 resultobj = SWIG_From_int(static_cast<int >(result));
18309 }
18310 return resultobj;
18311 fail:
18312 return NULL;
18313 }
18314
18315
18316 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18317 PyObject *resultobj = NULL;
18318 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18319 bool result;
18320 PyObject * obj0 = 0 ;
18321 char *kwnames[] = {
18322 (char *) "self", NULL
18323 };
18324
18325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18327 if (SWIG_arg_fail(1)) SWIG_fail;
18328 {
18329 PyThreadState* __tstate = wxPyBeginAllowThreads();
18330 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18331
18332 wxPyEndAllowThreads(__tstate);
18333 if (PyErr_Occurred()) SWIG_fail;
18334 }
18335 {
18336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18337 }
18338 return resultobj;
18339 fail:
18340 return NULL;
18341 }
18342
18343
18344 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18345 PyObject *resultobj = NULL;
18346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18347 int arg2 ;
18348 PyObject * obj0 = 0 ;
18349 PyObject * obj1 = 0 ;
18350 char *kwnames[] = {
18351 (char *) "self",(char *) "m_x", NULL
18352 };
18353
18354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18356 if (SWIG_arg_fail(1)) SWIG_fail;
18357 {
18358 arg2 = static_cast<int >(SWIG_As_int(obj1));
18359 if (SWIG_arg_fail(2)) SWIG_fail;
18360 }
18361 if (arg1) (arg1)->m_x = arg2;
18362
18363 Py_INCREF(Py_None); resultobj = Py_None;
18364 return resultobj;
18365 fail:
18366 return NULL;
18367 }
18368
18369
18370 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18371 PyObject *resultobj = NULL;
18372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18373 int result;
18374 PyObject * obj0 = 0 ;
18375 char *kwnames[] = {
18376 (char *) "self", NULL
18377 };
18378
18379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18381 if (SWIG_arg_fail(1)) SWIG_fail;
18382 result = (int) ((arg1)->m_x);
18383
18384 {
18385 resultobj = SWIG_From_int(static_cast<int >(result));
18386 }
18387 return resultobj;
18388 fail:
18389 return NULL;
18390 }
18391
18392
18393 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18394 PyObject *resultobj = NULL;
18395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18396 int arg2 ;
18397 PyObject * obj0 = 0 ;
18398 PyObject * obj1 = 0 ;
18399 char *kwnames[] = {
18400 (char *) "self",(char *) "m_y", NULL
18401 };
18402
18403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18405 if (SWIG_arg_fail(1)) SWIG_fail;
18406 {
18407 arg2 = static_cast<int >(SWIG_As_int(obj1));
18408 if (SWIG_arg_fail(2)) SWIG_fail;
18409 }
18410 if (arg1) (arg1)->m_y = arg2;
18411
18412 Py_INCREF(Py_None); resultobj = Py_None;
18413 return resultobj;
18414 fail:
18415 return NULL;
18416 }
18417
18418
18419 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj = NULL;
18421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18422 int result;
18423 PyObject * obj0 = 0 ;
18424 char *kwnames[] = {
18425 (char *) "self", NULL
18426 };
18427
18428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18430 if (SWIG_arg_fail(1)) SWIG_fail;
18431 result = (int) ((arg1)->m_y);
18432
18433 {
18434 resultobj = SWIG_From_int(static_cast<int >(result));
18435 }
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj = NULL;
18444 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18445 bool arg2 ;
18446 PyObject * obj0 = 0 ;
18447 PyObject * obj1 = 0 ;
18448 char *kwnames[] = {
18449 (char *) "self",(char *) "m_leftDown", NULL
18450 };
18451
18452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18454 if (SWIG_arg_fail(1)) SWIG_fail;
18455 {
18456 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18457 if (SWIG_arg_fail(2)) SWIG_fail;
18458 }
18459 if (arg1) (arg1)->m_leftDown = arg2;
18460
18461 Py_INCREF(Py_None); resultobj = Py_None;
18462 return resultobj;
18463 fail:
18464 return NULL;
18465 }
18466
18467
18468 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18469 PyObject *resultobj = NULL;
18470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18471 bool result;
18472 PyObject * obj0 = 0 ;
18473 char *kwnames[] = {
18474 (char *) "self", NULL
18475 };
18476
18477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18479 if (SWIG_arg_fail(1)) SWIG_fail;
18480 result = (bool) ((arg1)->m_leftDown);
18481
18482 {
18483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18484 }
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18492 PyObject *resultobj = NULL;
18493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18494 bool arg2 ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 char *kwnames[] = {
18498 (char *) "self",(char *) "m_middleDown", NULL
18499 };
18500
18501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18503 if (SWIG_arg_fail(1)) SWIG_fail;
18504 {
18505 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18506 if (SWIG_arg_fail(2)) SWIG_fail;
18507 }
18508 if (arg1) (arg1)->m_middleDown = arg2;
18509
18510 Py_INCREF(Py_None); resultobj = Py_None;
18511 return resultobj;
18512 fail:
18513 return NULL;
18514 }
18515
18516
18517 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18518 PyObject *resultobj = NULL;
18519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18520 bool result;
18521 PyObject * obj0 = 0 ;
18522 char *kwnames[] = {
18523 (char *) "self", NULL
18524 };
18525
18526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18528 if (SWIG_arg_fail(1)) SWIG_fail;
18529 result = (bool) ((arg1)->m_middleDown);
18530
18531 {
18532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18533 }
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18541 PyObject *resultobj = NULL;
18542 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18543 bool arg2 ;
18544 PyObject * obj0 = 0 ;
18545 PyObject * obj1 = 0 ;
18546 char *kwnames[] = {
18547 (char *) "self",(char *) "m_rightDown", NULL
18548 };
18549
18550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18552 if (SWIG_arg_fail(1)) SWIG_fail;
18553 {
18554 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18555 if (SWIG_arg_fail(2)) SWIG_fail;
18556 }
18557 if (arg1) (arg1)->m_rightDown = arg2;
18558
18559 Py_INCREF(Py_None); resultobj = Py_None;
18560 return resultobj;
18561 fail:
18562 return NULL;
18563 }
18564
18565
18566 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18567 PyObject *resultobj = NULL;
18568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18569 bool result;
18570 PyObject * obj0 = 0 ;
18571 char *kwnames[] = {
18572 (char *) "self", NULL
18573 };
18574
18575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18577 if (SWIG_arg_fail(1)) SWIG_fail;
18578 result = (bool) ((arg1)->m_rightDown);
18579
18580 {
18581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18582 }
18583 return resultobj;
18584 fail:
18585 return NULL;
18586 }
18587
18588
18589 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18590 PyObject *resultobj = NULL;
18591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18592 bool arg2 ;
18593 PyObject * obj0 = 0 ;
18594 PyObject * obj1 = 0 ;
18595 char *kwnames[] = {
18596 (char *) "self",(char *) "m_controlDown", NULL
18597 };
18598
18599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18601 if (SWIG_arg_fail(1)) SWIG_fail;
18602 {
18603 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18604 if (SWIG_arg_fail(2)) SWIG_fail;
18605 }
18606 if (arg1) (arg1)->m_controlDown = arg2;
18607
18608 Py_INCREF(Py_None); resultobj = Py_None;
18609 return resultobj;
18610 fail:
18611 return NULL;
18612 }
18613
18614
18615 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18616 PyObject *resultobj = NULL;
18617 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18618 bool result;
18619 PyObject * obj0 = 0 ;
18620 char *kwnames[] = {
18621 (char *) "self", NULL
18622 };
18623
18624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18626 if (SWIG_arg_fail(1)) SWIG_fail;
18627 result = (bool) ((arg1)->m_controlDown);
18628
18629 {
18630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18631 }
18632 return resultobj;
18633 fail:
18634 return NULL;
18635 }
18636
18637
18638 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18639 PyObject *resultobj = NULL;
18640 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18641 bool arg2 ;
18642 PyObject * obj0 = 0 ;
18643 PyObject * obj1 = 0 ;
18644 char *kwnames[] = {
18645 (char *) "self",(char *) "m_shiftDown", NULL
18646 };
18647
18648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18650 if (SWIG_arg_fail(1)) SWIG_fail;
18651 {
18652 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18653 if (SWIG_arg_fail(2)) SWIG_fail;
18654 }
18655 if (arg1) (arg1)->m_shiftDown = arg2;
18656
18657 Py_INCREF(Py_None); resultobj = Py_None;
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18665 PyObject *resultobj = NULL;
18666 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18667 bool result;
18668 PyObject * obj0 = 0 ;
18669 char *kwnames[] = {
18670 (char *) "self", NULL
18671 };
18672
18673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18675 if (SWIG_arg_fail(1)) SWIG_fail;
18676 result = (bool) ((arg1)->m_shiftDown);
18677
18678 {
18679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18680 }
18681 return resultobj;
18682 fail:
18683 return NULL;
18684 }
18685
18686
18687 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18688 PyObject *resultobj = NULL;
18689 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18690 bool arg2 ;
18691 PyObject * obj0 = 0 ;
18692 PyObject * obj1 = 0 ;
18693 char *kwnames[] = {
18694 (char *) "self",(char *) "m_altDown", NULL
18695 };
18696
18697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18699 if (SWIG_arg_fail(1)) SWIG_fail;
18700 {
18701 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18702 if (SWIG_arg_fail(2)) SWIG_fail;
18703 }
18704 if (arg1) (arg1)->m_altDown = arg2;
18705
18706 Py_INCREF(Py_None); resultobj = Py_None;
18707 return resultobj;
18708 fail:
18709 return NULL;
18710 }
18711
18712
18713 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18714 PyObject *resultobj = NULL;
18715 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18716 bool result;
18717 PyObject * obj0 = 0 ;
18718 char *kwnames[] = {
18719 (char *) "self", NULL
18720 };
18721
18722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18724 if (SWIG_arg_fail(1)) SWIG_fail;
18725 result = (bool) ((arg1)->m_altDown);
18726
18727 {
18728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18729 }
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18737 PyObject *resultobj = NULL;
18738 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18739 bool arg2 ;
18740 PyObject * obj0 = 0 ;
18741 PyObject * obj1 = 0 ;
18742 char *kwnames[] = {
18743 (char *) "self",(char *) "m_metaDown", NULL
18744 };
18745
18746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 {
18750 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18751 if (SWIG_arg_fail(2)) SWIG_fail;
18752 }
18753 if (arg1) (arg1)->m_metaDown = arg2;
18754
18755 Py_INCREF(Py_None); resultobj = Py_None;
18756 return resultobj;
18757 fail:
18758 return NULL;
18759 }
18760
18761
18762 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18763 PyObject *resultobj = NULL;
18764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18765 bool result;
18766 PyObject * obj0 = 0 ;
18767 char *kwnames[] = {
18768 (char *) "self", NULL
18769 };
18770
18771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18773 if (SWIG_arg_fail(1)) SWIG_fail;
18774 result = (bool) ((arg1)->m_metaDown);
18775
18776 {
18777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18778 }
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18786 PyObject *resultobj = NULL;
18787 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18788 int arg2 ;
18789 PyObject * obj0 = 0 ;
18790 PyObject * obj1 = 0 ;
18791 char *kwnames[] = {
18792 (char *) "self",(char *) "m_wheelRotation", NULL
18793 };
18794
18795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18797 if (SWIG_arg_fail(1)) SWIG_fail;
18798 {
18799 arg2 = static_cast<int >(SWIG_As_int(obj1));
18800 if (SWIG_arg_fail(2)) SWIG_fail;
18801 }
18802 if (arg1) (arg1)->m_wheelRotation = arg2;
18803
18804 Py_INCREF(Py_None); resultobj = Py_None;
18805 return resultobj;
18806 fail:
18807 return NULL;
18808 }
18809
18810
18811 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj = NULL;
18813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18814 int result;
18815 PyObject * obj0 = 0 ;
18816 char *kwnames[] = {
18817 (char *) "self", NULL
18818 };
18819
18820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18822 if (SWIG_arg_fail(1)) SWIG_fail;
18823 result = (int) ((arg1)->m_wheelRotation);
18824
18825 {
18826 resultobj = SWIG_From_int(static_cast<int >(result));
18827 }
18828 return resultobj;
18829 fail:
18830 return NULL;
18831 }
18832
18833
18834 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18835 PyObject *resultobj = NULL;
18836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18837 int arg2 ;
18838 PyObject * obj0 = 0 ;
18839 PyObject * obj1 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self",(char *) "m_wheelDelta", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 arg2 = static_cast<int >(SWIG_As_int(obj1));
18849 if (SWIG_arg_fail(2)) SWIG_fail;
18850 }
18851 if (arg1) (arg1)->m_wheelDelta = arg2;
18852
18853 Py_INCREF(Py_None); resultobj = Py_None;
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18861 PyObject *resultobj = NULL;
18862 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18863 int result;
18864 PyObject * obj0 = 0 ;
18865 char *kwnames[] = {
18866 (char *) "self", NULL
18867 };
18868
18869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18871 if (SWIG_arg_fail(1)) SWIG_fail;
18872 result = (int) ((arg1)->m_wheelDelta);
18873
18874 {
18875 resultobj = SWIG_From_int(static_cast<int >(result));
18876 }
18877 return resultobj;
18878 fail:
18879 return NULL;
18880 }
18881
18882
18883 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18884 PyObject *resultobj = NULL;
18885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18886 int arg2 ;
18887 PyObject * obj0 = 0 ;
18888 PyObject * obj1 = 0 ;
18889 char *kwnames[] = {
18890 (char *) "self",(char *) "m_linesPerAction", NULL
18891 };
18892
18893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18895 if (SWIG_arg_fail(1)) SWIG_fail;
18896 {
18897 arg2 = static_cast<int >(SWIG_As_int(obj1));
18898 if (SWIG_arg_fail(2)) SWIG_fail;
18899 }
18900 if (arg1) (arg1)->m_linesPerAction = arg2;
18901
18902 Py_INCREF(Py_None); resultobj = Py_None;
18903 return resultobj;
18904 fail:
18905 return NULL;
18906 }
18907
18908
18909 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18910 PyObject *resultobj = NULL;
18911 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18912 int result;
18913 PyObject * obj0 = 0 ;
18914 char *kwnames[] = {
18915 (char *) "self", NULL
18916 };
18917
18918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18920 if (SWIG_arg_fail(1)) SWIG_fail;
18921 result = (int) ((arg1)->m_linesPerAction);
18922
18923 {
18924 resultobj = SWIG_From_int(static_cast<int >(result));
18925 }
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18933 PyObject *obj;
18934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18935 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18936 Py_INCREF(obj);
18937 return Py_BuildValue((char *)"");
18938 }
18939 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18940 PyObject *resultobj = NULL;
18941 int arg1 = (int) 0 ;
18942 int arg2 = (int) 0 ;
18943 wxSetCursorEvent *result;
18944 PyObject * obj0 = 0 ;
18945 PyObject * obj1 = 0 ;
18946 char *kwnames[] = {
18947 (char *) "x",(char *) "y", NULL
18948 };
18949
18950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18951 if (obj0) {
18952 {
18953 arg1 = static_cast<int >(SWIG_As_int(obj0));
18954 if (SWIG_arg_fail(1)) SWIG_fail;
18955 }
18956 }
18957 if (obj1) {
18958 {
18959 arg2 = static_cast<int >(SWIG_As_int(obj1));
18960 if (SWIG_arg_fail(2)) SWIG_fail;
18961 }
18962 }
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18966
18967 wxPyEndAllowThreads(__tstate);
18968 if (PyErr_Occurred()) SWIG_fail;
18969 }
18970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18971 return resultobj;
18972 fail:
18973 return NULL;
18974 }
18975
18976
18977 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18978 PyObject *resultobj = NULL;
18979 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18980 int result;
18981 PyObject * obj0 = 0 ;
18982 char *kwnames[] = {
18983 (char *) "self", NULL
18984 };
18985
18986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18988 if (SWIG_arg_fail(1)) SWIG_fail;
18989 {
18990 PyThreadState* __tstate = wxPyBeginAllowThreads();
18991 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18992
18993 wxPyEndAllowThreads(__tstate);
18994 if (PyErr_Occurred()) SWIG_fail;
18995 }
18996 {
18997 resultobj = SWIG_From_int(static_cast<int >(result));
18998 }
18999 return resultobj;
19000 fail:
19001 return NULL;
19002 }
19003
19004
19005 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19006 PyObject *resultobj = NULL;
19007 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19008 int result;
19009 PyObject * obj0 = 0 ;
19010 char *kwnames[] = {
19011 (char *) "self", NULL
19012 };
19013
19014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
19015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19016 if (SWIG_arg_fail(1)) SWIG_fail;
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
19020
19021 wxPyEndAllowThreads(__tstate);
19022 if (PyErr_Occurred()) SWIG_fail;
19023 }
19024 {
19025 resultobj = SWIG_From_int(static_cast<int >(result));
19026 }
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19034 PyObject *resultobj = NULL;
19035 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19036 wxCursor *arg2 = 0 ;
19037 PyObject * obj0 = 0 ;
19038 PyObject * obj1 = 0 ;
19039 char *kwnames[] = {
19040 (char *) "self",(char *) "cursor", NULL
19041 };
19042
19043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
19044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19045 if (SWIG_arg_fail(1)) SWIG_fail;
19046 {
19047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
19048 if (SWIG_arg_fail(2)) SWIG_fail;
19049 if (arg2 == NULL) {
19050 SWIG_null_ref("wxCursor");
19051 }
19052 if (SWIG_arg_fail(2)) SWIG_fail;
19053 }
19054 {
19055 PyThreadState* __tstate = wxPyBeginAllowThreads();
19056 (arg1)->SetCursor((wxCursor const &)*arg2);
19057
19058 wxPyEndAllowThreads(__tstate);
19059 if (PyErr_Occurred()) SWIG_fail;
19060 }
19061 Py_INCREF(Py_None); resultobj = Py_None;
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj = NULL;
19070 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19071 wxCursor *result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "self", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19079 if (SWIG_arg_fail(1)) SWIG_fail;
19080 {
19081 PyThreadState* __tstate = wxPyBeginAllowThreads();
19082 {
19083 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19084 result = (wxCursor *) &_result_ref;
19085 }
19086
19087 wxPyEndAllowThreads(__tstate);
19088 if (PyErr_Occurred()) SWIG_fail;
19089 }
19090 {
19091 wxCursor* resultptr = new wxCursor(*result);
19092 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19093 }
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19101 PyObject *resultobj = NULL;
19102 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19103 bool result;
19104 PyObject * obj0 = 0 ;
19105 char *kwnames[] = {
19106 (char *) "self", NULL
19107 };
19108
19109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19111 if (SWIG_arg_fail(1)) SWIG_fail;
19112 {
19113 PyThreadState* __tstate = wxPyBeginAllowThreads();
19114 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19115
19116 wxPyEndAllowThreads(__tstate);
19117 if (PyErr_Occurred()) SWIG_fail;
19118 }
19119 {
19120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19121 }
19122 return resultobj;
19123 fail:
19124 return NULL;
19125 }
19126
19127
19128 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19129 PyObject *obj;
19130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19131 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19132 Py_INCREF(obj);
19133 return Py_BuildValue((char *)"");
19134 }
19135 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19136 PyObject *resultobj = NULL;
19137 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19138 wxKeyEvent *result;
19139 PyObject * obj0 = 0 ;
19140 char *kwnames[] = {
19141 (char *) "eventType", NULL
19142 };
19143
19144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19145 if (obj0) {
19146 {
19147 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19148 if (SWIG_arg_fail(1)) SWIG_fail;
19149 }
19150 }
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19154
19155 wxPyEndAllowThreads(__tstate);
19156 if (PyErr_Occurred()) SWIG_fail;
19157 }
19158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19159 return resultobj;
19160 fail:
19161 return NULL;
19162 }
19163
19164
19165 static PyObject *_wrap_KeyEvent_GetModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19166 PyObject *resultobj = NULL;
19167 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19168 int result;
19169 PyObject * obj0 = 0 ;
19170 char *kwnames[] = {
19171 (char *) "self", NULL
19172 };
19173
19174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetModifiers",kwnames,&obj0)) goto fail;
19175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19176 if (SWIG_arg_fail(1)) SWIG_fail;
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
19180
19181 wxPyEndAllowThreads(__tstate);
19182 if (PyErr_Occurred()) SWIG_fail;
19183 }
19184 {
19185 resultobj = SWIG_From_int(static_cast<int >(result));
19186 }
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19194 PyObject *resultobj = NULL;
19195 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19196 bool result;
19197 PyObject * obj0 = 0 ;
19198 char *kwnames[] = {
19199 (char *) "self", NULL
19200 };
19201
19202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19204 if (SWIG_arg_fail(1)) SWIG_fail;
19205 {
19206 PyThreadState* __tstate = wxPyBeginAllowThreads();
19207 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19208
19209 wxPyEndAllowThreads(__tstate);
19210 if (PyErr_Occurred()) SWIG_fail;
19211 }
19212 {
19213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19214 }
19215 return resultobj;
19216 fail:
19217 return NULL;
19218 }
19219
19220
19221 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj = NULL;
19223 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19224 bool result;
19225 PyObject * obj0 = 0 ;
19226 char *kwnames[] = {
19227 (char *) "self", NULL
19228 };
19229
19230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19232 if (SWIG_arg_fail(1)) SWIG_fail;
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj = NULL;
19251 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19252 bool result;
19253 PyObject * obj0 = 0 ;
19254 char *kwnames[] = {
19255 (char *) "self", NULL
19256 };
19257
19258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19260 if (SWIG_arg_fail(1)) SWIG_fail;
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19264
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 {
19269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19270 }
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj = NULL;
19279 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19280 bool result;
19281 PyObject * obj0 = 0 ;
19282 char *kwnames[] = {
19283 (char *) "self", NULL
19284 };
19285
19286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19288 if (SWIG_arg_fail(1)) SWIG_fail;
19289 {
19290 PyThreadState* __tstate = wxPyBeginAllowThreads();
19291 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19292
19293 wxPyEndAllowThreads(__tstate);
19294 if (PyErr_Occurred()) SWIG_fail;
19295 }
19296 {
19297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19298 }
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19306 PyObject *resultobj = NULL;
19307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19308 bool result;
19309 PyObject * obj0 = 0 ;
19310 char *kwnames[] = {
19311 (char *) "self", NULL
19312 };
19313
19314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19316 if (SWIG_arg_fail(1)) SWIG_fail;
19317 {
19318 PyThreadState* __tstate = wxPyBeginAllowThreads();
19319 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19320
19321 wxPyEndAllowThreads(__tstate);
19322 if (PyErr_Occurred()) SWIG_fail;
19323 }
19324 {
19325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19326 }
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj = NULL;
19335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19336 bool result;
19337 PyObject * obj0 = 0 ;
19338 char *kwnames[] = {
19339 (char *) "self", NULL
19340 };
19341
19342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19344 if (SWIG_arg_fail(1)) SWIG_fail;
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19348
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 {
19353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19354 }
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19362 PyObject *resultobj = NULL;
19363 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19364 int result;
19365 PyObject * obj0 = 0 ;
19366 char *kwnames[] = {
19367 (char *) "self", NULL
19368 };
19369
19370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19372 if (SWIG_arg_fail(1)) SWIG_fail;
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19376
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 {
19381 resultobj = SWIG_From_int(static_cast<int >(result));
19382 }
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj = NULL;
19391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19392 int result;
19393 PyObject * obj0 = 0 ;
19394 char *kwnames[] = {
19395 (char *) "self", NULL
19396 };
19397
19398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19400 if (SWIG_arg_fail(1)) SWIG_fail;
19401 {
19402 PyThreadState* __tstate = wxPyBeginAllowThreads();
19403 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19404
19405 wxPyEndAllowThreads(__tstate);
19406 if (PyErr_Occurred()) SWIG_fail;
19407 }
19408 {
19409 resultobj = SWIG_From_int(static_cast<int >(result));
19410 }
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19418 PyObject *resultobj = NULL;
19419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19420 unsigned int result;
19421 PyObject * obj0 = 0 ;
19422 char *kwnames[] = {
19423 (char *) "self", NULL
19424 };
19425
19426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19428 if (SWIG_arg_fail(1)) SWIG_fail;
19429 {
19430 PyThreadState* __tstate = wxPyBeginAllowThreads();
19431 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19432
19433 wxPyEndAllowThreads(__tstate);
19434 if (PyErr_Occurred()) SWIG_fail;
19435 }
19436 {
19437 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19438 }
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19446 PyObject *resultobj = NULL;
19447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19448 unsigned int result;
19449 PyObject * obj0 = 0 ;
19450 char *kwnames[] = {
19451 (char *) "self", NULL
19452 };
19453
19454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19456 if (SWIG_arg_fail(1)) SWIG_fail;
19457 {
19458 PyThreadState* __tstate = wxPyBeginAllowThreads();
19459 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19460
19461 wxPyEndAllowThreads(__tstate);
19462 if (PyErr_Occurred()) SWIG_fail;
19463 }
19464 {
19465 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19466 }
19467 return resultobj;
19468 fail:
19469 return NULL;
19470 }
19471
19472
19473 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19474 PyObject *resultobj = NULL;
19475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19476 wxPoint result;
19477 PyObject * obj0 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "self", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19484 if (SWIG_arg_fail(1)) SWIG_fail;
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 result = (arg1)->GetPosition();
19488
19489 wxPyEndAllowThreads(__tstate);
19490 if (PyErr_Occurred()) SWIG_fail;
19491 }
19492 {
19493 wxPoint * resultptr;
19494 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19496 }
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj = NULL;
19505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19506 long *arg2 = (long *) 0 ;
19507 long *arg3 = (long *) 0 ;
19508 long temp2 ;
19509 int res2 = 0 ;
19510 long temp3 ;
19511 int res3 = 0 ;
19512 PyObject * obj0 = 0 ;
19513 char *kwnames[] = {
19514 (char *) "self", NULL
19515 };
19516
19517 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19518 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19521 if (SWIG_arg_fail(1)) SWIG_fail;
19522 {
19523 PyThreadState* __tstate = wxPyBeginAllowThreads();
19524 (arg1)->GetPosition(arg2,arg3);
19525
19526 wxPyEndAllowThreads(__tstate);
19527 if (PyErr_Occurred()) SWIG_fail;
19528 }
19529 Py_INCREF(Py_None); resultobj = Py_None;
19530 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19531 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19532 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19533 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19541 PyObject *resultobj = NULL;
19542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19543 int result;
19544 PyObject * obj0 = 0 ;
19545 char *kwnames[] = {
19546 (char *) "self", NULL
19547 };
19548
19549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19551 if (SWIG_arg_fail(1)) SWIG_fail;
19552 {
19553 PyThreadState* __tstate = wxPyBeginAllowThreads();
19554 result = (int)((wxKeyEvent const *)arg1)->GetX();
19555
19556 wxPyEndAllowThreads(__tstate);
19557 if (PyErr_Occurred()) SWIG_fail;
19558 }
19559 {
19560 resultobj = SWIG_From_int(static_cast<int >(result));
19561 }
19562 return resultobj;
19563 fail:
19564 return NULL;
19565 }
19566
19567
19568 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19569 PyObject *resultobj = NULL;
19570 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19571 int result;
19572 PyObject * obj0 = 0 ;
19573 char *kwnames[] = {
19574 (char *) "self", NULL
19575 };
19576
19577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = (int)((wxKeyEvent const *)arg1)->GetY();
19583
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 {
19588 resultobj = SWIG_From_int(static_cast<int >(result));
19589 }
19590 return resultobj;
19591 fail:
19592 return NULL;
19593 }
19594
19595
19596 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19597 PyObject *resultobj = NULL;
19598 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19599 int arg2 ;
19600 PyObject * obj0 = 0 ;
19601 PyObject * obj1 = 0 ;
19602 char *kwnames[] = {
19603 (char *) "self",(char *) "m_x", NULL
19604 };
19605
19606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19608 if (SWIG_arg_fail(1)) SWIG_fail;
19609 {
19610 arg2 = static_cast<int >(SWIG_As_int(obj1));
19611 if (SWIG_arg_fail(2)) SWIG_fail;
19612 }
19613 if (arg1) (arg1)->m_x = arg2;
19614
19615 Py_INCREF(Py_None); resultobj = Py_None;
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj = NULL;
19624 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19625 int result;
19626 PyObject * obj0 = 0 ;
19627 char *kwnames[] = {
19628 (char *) "self", NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19633 if (SWIG_arg_fail(1)) SWIG_fail;
19634 result = (int) ((arg1)->m_x);
19635
19636 {
19637 resultobj = SWIG_From_int(static_cast<int >(result));
19638 }
19639 return resultobj;
19640 fail:
19641 return NULL;
19642 }
19643
19644
19645 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19646 PyObject *resultobj = NULL;
19647 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19648 int arg2 ;
19649 PyObject * obj0 = 0 ;
19650 PyObject * obj1 = 0 ;
19651 char *kwnames[] = {
19652 (char *) "self",(char *) "m_y", NULL
19653 };
19654
19655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19657 if (SWIG_arg_fail(1)) SWIG_fail;
19658 {
19659 arg2 = static_cast<int >(SWIG_As_int(obj1));
19660 if (SWIG_arg_fail(2)) SWIG_fail;
19661 }
19662 if (arg1) (arg1)->m_y = arg2;
19663
19664 Py_INCREF(Py_None); resultobj = Py_None;
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj = NULL;
19673 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19674 int result;
19675 PyObject * obj0 = 0 ;
19676 char *kwnames[] = {
19677 (char *) "self", NULL
19678 };
19679
19680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19682 if (SWIG_arg_fail(1)) SWIG_fail;
19683 result = (int) ((arg1)->m_y);
19684
19685 {
19686 resultobj = SWIG_From_int(static_cast<int >(result));
19687 }
19688 return resultobj;
19689 fail:
19690 return NULL;
19691 }
19692
19693
19694 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19695 PyObject *resultobj = NULL;
19696 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19697 long arg2 ;
19698 PyObject * obj0 = 0 ;
19699 PyObject * obj1 = 0 ;
19700 char *kwnames[] = {
19701 (char *) "self",(char *) "m_keyCode", NULL
19702 };
19703
19704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19706 if (SWIG_arg_fail(1)) SWIG_fail;
19707 {
19708 arg2 = static_cast<long >(SWIG_As_long(obj1));
19709 if (SWIG_arg_fail(2)) SWIG_fail;
19710 }
19711 if (arg1) (arg1)->m_keyCode = arg2;
19712
19713 Py_INCREF(Py_None); resultobj = Py_None;
19714 return resultobj;
19715 fail:
19716 return NULL;
19717 }
19718
19719
19720 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19721 PyObject *resultobj = NULL;
19722 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19723 long result;
19724 PyObject * obj0 = 0 ;
19725 char *kwnames[] = {
19726 (char *) "self", NULL
19727 };
19728
19729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19731 if (SWIG_arg_fail(1)) SWIG_fail;
19732 result = (long) ((arg1)->m_keyCode);
19733
19734 {
19735 resultobj = SWIG_From_long(static_cast<long >(result));
19736 }
19737 return resultobj;
19738 fail:
19739 return NULL;
19740 }
19741
19742
19743 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19744 PyObject *resultobj = NULL;
19745 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19746 bool arg2 ;
19747 PyObject * obj0 = 0 ;
19748 PyObject * obj1 = 0 ;
19749 char *kwnames[] = {
19750 (char *) "self",(char *) "m_controlDown", NULL
19751 };
19752
19753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19755 if (SWIG_arg_fail(1)) SWIG_fail;
19756 {
19757 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19758 if (SWIG_arg_fail(2)) SWIG_fail;
19759 }
19760 if (arg1) (arg1)->m_controlDown = arg2;
19761
19762 Py_INCREF(Py_None); resultobj = Py_None;
19763 return resultobj;
19764 fail:
19765 return NULL;
19766 }
19767
19768
19769 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj = NULL;
19771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19772 bool result;
19773 PyObject * obj0 = 0 ;
19774 char *kwnames[] = {
19775 (char *) "self", NULL
19776 };
19777
19778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19780 if (SWIG_arg_fail(1)) SWIG_fail;
19781 result = (bool) ((arg1)->m_controlDown);
19782
19783 {
19784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19785 }
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19793 PyObject *resultobj = NULL;
19794 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19795 bool arg2 ;
19796 PyObject * obj0 = 0 ;
19797 PyObject * obj1 = 0 ;
19798 char *kwnames[] = {
19799 (char *) "self",(char *) "m_shiftDown", NULL
19800 };
19801
19802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19804 if (SWIG_arg_fail(1)) SWIG_fail;
19805 {
19806 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19807 if (SWIG_arg_fail(2)) SWIG_fail;
19808 }
19809 if (arg1) (arg1)->m_shiftDown = arg2;
19810
19811 Py_INCREF(Py_None); resultobj = Py_None;
19812 return resultobj;
19813 fail:
19814 return NULL;
19815 }
19816
19817
19818 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19819 PyObject *resultobj = NULL;
19820 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19821 bool result;
19822 PyObject * obj0 = 0 ;
19823 char *kwnames[] = {
19824 (char *) "self", NULL
19825 };
19826
19827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19829 if (SWIG_arg_fail(1)) SWIG_fail;
19830 result = (bool) ((arg1)->m_shiftDown);
19831
19832 {
19833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19834 }
19835 return resultobj;
19836 fail:
19837 return NULL;
19838 }
19839
19840
19841 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19842 PyObject *resultobj = NULL;
19843 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19844 bool arg2 ;
19845 PyObject * obj0 = 0 ;
19846 PyObject * obj1 = 0 ;
19847 char *kwnames[] = {
19848 (char *) "self",(char *) "m_altDown", NULL
19849 };
19850
19851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19853 if (SWIG_arg_fail(1)) SWIG_fail;
19854 {
19855 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19856 if (SWIG_arg_fail(2)) SWIG_fail;
19857 }
19858 if (arg1) (arg1)->m_altDown = arg2;
19859
19860 Py_INCREF(Py_None); resultobj = Py_None;
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj = NULL;
19869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19870 bool result;
19871 PyObject * obj0 = 0 ;
19872 char *kwnames[] = {
19873 (char *) "self", NULL
19874 };
19875
19876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19878 if (SWIG_arg_fail(1)) SWIG_fail;
19879 result = (bool) ((arg1)->m_altDown);
19880
19881 {
19882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19883 }
19884 return resultobj;
19885 fail:
19886 return NULL;
19887 }
19888
19889
19890 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19891 PyObject *resultobj = NULL;
19892 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19893 bool arg2 ;
19894 PyObject * obj0 = 0 ;
19895 PyObject * obj1 = 0 ;
19896 char *kwnames[] = {
19897 (char *) "self",(char *) "m_metaDown", NULL
19898 };
19899
19900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19902 if (SWIG_arg_fail(1)) SWIG_fail;
19903 {
19904 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19905 if (SWIG_arg_fail(2)) SWIG_fail;
19906 }
19907 if (arg1) (arg1)->m_metaDown = arg2;
19908
19909 Py_INCREF(Py_None); resultobj = Py_None;
19910 return resultobj;
19911 fail:
19912 return NULL;
19913 }
19914
19915
19916 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19917 PyObject *resultobj = NULL;
19918 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19919 bool result;
19920 PyObject * obj0 = 0 ;
19921 char *kwnames[] = {
19922 (char *) "self", NULL
19923 };
19924
19925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19927 if (SWIG_arg_fail(1)) SWIG_fail;
19928 result = (bool) ((arg1)->m_metaDown);
19929
19930 {
19931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19932 }
19933 return resultobj;
19934 fail:
19935 return NULL;
19936 }
19937
19938
19939 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19940 PyObject *resultobj = NULL;
19941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19942 bool arg2 ;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char *kwnames[] = {
19946 (char *) "self",(char *) "m_scanCode", NULL
19947 };
19948
19949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19951 if (SWIG_arg_fail(1)) SWIG_fail;
19952 {
19953 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19954 if (SWIG_arg_fail(2)) SWIG_fail;
19955 }
19956 if (arg1) (arg1)->m_scanCode = arg2;
19957
19958 Py_INCREF(Py_None); resultobj = Py_None;
19959 return resultobj;
19960 fail:
19961 return NULL;
19962 }
19963
19964
19965 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19966 PyObject *resultobj = NULL;
19967 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19968 bool result;
19969 PyObject * obj0 = 0 ;
19970 char *kwnames[] = {
19971 (char *) "self", NULL
19972 };
19973
19974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19976 if (SWIG_arg_fail(1)) SWIG_fail;
19977 result = (bool) ((arg1)->m_scanCode);
19978
19979 {
19980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19981 }
19982 return resultobj;
19983 fail:
19984 return NULL;
19985 }
19986
19987
19988 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19989 PyObject *resultobj = NULL;
19990 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19991 unsigned int arg2 ;
19992 PyObject * obj0 = 0 ;
19993 PyObject * obj1 = 0 ;
19994 char *kwnames[] = {
19995 (char *) "self",(char *) "m_rawCode", NULL
19996 };
19997
19998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20000 if (SWIG_arg_fail(1)) SWIG_fail;
20001 {
20002 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
20003 if (SWIG_arg_fail(2)) SWIG_fail;
20004 }
20005 if (arg1) (arg1)->m_rawCode = arg2;
20006
20007 Py_INCREF(Py_None); resultobj = Py_None;
20008 return resultobj;
20009 fail:
20010 return NULL;
20011 }
20012
20013
20014 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
20015 PyObject *resultobj = NULL;
20016 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20017 unsigned int result;
20018 PyObject * obj0 = 0 ;
20019 char *kwnames[] = {
20020 (char *) "self", NULL
20021 };
20022
20023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
20024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20025 if (SWIG_arg_fail(1)) SWIG_fail;
20026 result = (unsigned int) ((arg1)->m_rawCode);
20027
20028 {
20029 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20030 }
20031 return resultobj;
20032 fail:
20033 return NULL;
20034 }
20035
20036
20037 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
20038 PyObject *resultobj = NULL;
20039 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20040 unsigned int arg2 ;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 char *kwnames[] = {
20044 (char *) "self",(char *) "m_rawFlags", NULL
20045 };
20046
20047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
20048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20049 if (SWIG_arg_fail(1)) SWIG_fail;
20050 {
20051 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
20052 if (SWIG_arg_fail(2)) SWIG_fail;
20053 }
20054 if (arg1) (arg1)->m_rawFlags = arg2;
20055
20056 Py_INCREF(Py_None); resultobj = Py_None;
20057 return resultobj;
20058 fail:
20059 return NULL;
20060 }
20061
20062
20063 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
20064 PyObject *resultobj = NULL;
20065 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20066 unsigned int result;
20067 PyObject * obj0 = 0 ;
20068 char *kwnames[] = {
20069 (char *) "self", NULL
20070 };
20071
20072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
20073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20074 if (SWIG_arg_fail(1)) SWIG_fail;
20075 result = (unsigned int) ((arg1)->m_rawFlags);
20076
20077 {
20078 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20079 }
20080 return resultobj;
20081 fail:
20082 return NULL;
20083 }
20084
20085
20086 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20087 PyObject *obj;
20088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20089 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20090 Py_INCREF(obj);
20091 return Py_BuildValue((char *)"");
20092 }
20093 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20094 PyObject *resultobj = NULL;
20095 wxSize const &arg1_defvalue = wxDefaultSize ;
20096 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20097 int arg2 = (int) 0 ;
20098 wxSizeEvent *result;
20099 wxSize temp1 ;
20100 PyObject * obj0 = 0 ;
20101 PyObject * obj1 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "sz",(char *) "winid", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20107 if (obj0) {
20108 {
20109 arg1 = &temp1;
20110 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20111 }
20112 }
20113 if (obj1) {
20114 {
20115 arg2 = static_cast<int >(SWIG_As_int(obj1));
20116 if (SWIG_arg_fail(2)) SWIG_fail;
20117 }
20118 }
20119 {
20120 PyThreadState* __tstate = wxPyBeginAllowThreads();
20121 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20122
20123 wxPyEndAllowThreads(__tstate);
20124 if (PyErr_Occurred()) SWIG_fail;
20125 }
20126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20127 return resultobj;
20128 fail:
20129 return NULL;
20130 }
20131
20132
20133 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20134 PyObject *resultobj = NULL;
20135 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20136 wxSize result;
20137 PyObject * obj0 = 0 ;
20138 char *kwnames[] = {
20139 (char *) "self", NULL
20140 };
20141
20142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20144 if (SWIG_arg_fail(1)) SWIG_fail;
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = ((wxSizeEvent const *)arg1)->GetSize();
20148
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 {
20153 wxSize * resultptr;
20154 resultptr = new wxSize(static_cast<wxSize & >(result));
20155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20156 }
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj = NULL;
20165 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20166 wxRect result;
20167 PyObject * obj0 = 0 ;
20168 char *kwnames[] = {
20169 (char *) "self", NULL
20170 };
20171
20172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20174 if (SWIG_arg_fail(1)) SWIG_fail;
20175 {
20176 PyThreadState* __tstate = wxPyBeginAllowThreads();
20177 result = ((wxSizeEvent const *)arg1)->GetRect();
20178
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 {
20183 wxRect * resultptr;
20184 resultptr = new wxRect(static_cast<wxRect & >(result));
20185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20186 }
20187 return resultobj;
20188 fail:
20189 return NULL;
20190 }
20191
20192
20193 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20194 PyObject *resultobj = NULL;
20195 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20196 wxRect arg2 ;
20197 PyObject * obj0 = 0 ;
20198 PyObject * obj1 = 0 ;
20199 char *kwnames[] = {
20200 (char *) "self",(char *) "rect", NULL
20201 };
20202
20203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20205 if (SWIG_arg_fail(1)) SWIG_fail;
20206 {
20207 wxRect * argp;
20208 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20209 if (SWIG_arg_fail(2)) SWIG_fail;
20210 if (argp == NULL) {
20211 SWIG_null_ref("wxRect");
20212 }
20213 if (SWIG_arg_fail(2)) SWIG_fail;
20214 arg2 = *argp;
20215 }
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 (arg1)->SetRect(arg2);
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 Py_INCREF(Py_None); resultobj = Py_None;
20224 return resultobj;
20225 fail:
20226 return NULL;
20227 }
20228
20229
20230 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20231 PyObject *resultobj = NULL;
20232 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20233 wxSize arg2 ;
20234 PyObject * obj0 = 0 ;
20235 PyObject * obj1 = 0 ;
20236 char *kwnames[] = {
20237 (char *) "self",(char *) "size", NULL
20238 };
20239
20240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20242 if (SWIG_arg_fail(1)) SWIG_fail;
20243 {
20244 wxSize * argp;
20245 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20246 if (SWIG_arg_fail(2)) SWIG_fail;
20247 if (argp == NULL) {
20248 SWIG_null_ref("wxSize");
20249 }
20250 if (SWIG_arg_fail(2)) SWIG_fail;
20251 arg2 = *argp;
20252 }
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 wxSizeEvent_SetSize(arg1,arg2);
20256
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 Py_INCREF(Py_None); resultobj = Py_None;
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj = NULL;
20269 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20270 wxSize *arg2 = (wxSize *) 0 ;
20271 PyObject * obj0 = 0 ;
20272 PyObject * obj1 = 0 ;
20273 char *kwnames[] = {
20274 (char *) "self",(char *) "m_size", NULL
20275 };
20276
20277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20279 if (SWIG_arg_fail(1)) SWIG_fail;
20280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(2)) SWIG_fail;
20282 if (arg1) (arg1)->m_size = *arg2;
20283
20284 Py_INCREF(Py_None); resultobj = Py_None;
20285 return resultobj;
20286 fail:
20287 return NULL;
20288 }
20289
20290
20291 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20292 PyObject *resultobj = NULL;
20293 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20294 wxSize *result;
20295 PyObject * obj0 = 0 ;
20296 char *kwnames[] = {
20297 (char *) "self", NULL
20298 };
20299
20300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20302 if (SWIG_arg_fail(1)) SWIG_fail;
20303 result = (wxSize *)& ((arg1)->m_size);
20304
20305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20313 PyObject *resultobj = NULL;
20314 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20315 wxRect *arg2 = (wxRect *) 0 ;
20316 PyObject * obj0 = 0 ;
20317 PyObject * obj1 = 0 ;
20318 char *kwnames[] = {
20319 (char *) "self",(char *) "m_rect", NULL
20320 };
20321
20322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20324 if (SWIG_arg_fail(1)) SWIG_fail;
20325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20326 if (SWIG_arg_fail(2)) SWIG_fail;
20327 if (arg1) (arg1)->m_rect = *arg2;
20328
20329 Py_INCREF(Py_None); resultobj = Py_None;
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20337 PyObject *resultobj = NULL;
20338 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20339 wxRect *result;
20340 PyObject * obj0 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 result = (wxRect *)& ((arg1)->m_rect);
20349
20350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20358 PyObject *obj;
20359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20360 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20361 Py_INCREF(obj);
20362 return Py_BuildValue((char *)"");
20363 }
20364 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj = NULL;
20366 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20367 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20368 int arg2 = (int) 0 ;
20369 wxMoveEvent *result;
20370 wxPoint temp1 ;
20371 PyObject * obj0 = 0 ;
20372 PyObject * obj1 = 0 ;
20373 char *kwnames[] = {
20374 (char *) "pos",(char *) "winid", NULL
20375 };
20376
20377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20378 if (obj0) {
20379 {
20380 arg1 = &temp1;
20381 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20382 }
20383 }
20384 if (obj1) {
20385 {
20386 arg2 = static_cast<int >(SWIG_As_int(obj1));
20387 if (SWIG_arg_fail(2)) SWIG_fail;
20388 }
20389 }
20390 {
20391 PyThreadState* __tstate = wxPyBeginAllowThreads();
20392 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20393
20394 wxPyEndAllowThreads(__tstate);
20395 if (PyErr_Occurred()) SWIG_fail;
20396 }
20397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20398 return resultobj;
20399 fail:
20400 return NULL;
20401 }
20402
20403
20404 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20405 PyObject *resultobj = NULL;
20406 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20407 wxPoint result;
20408 PyObject * obj0 = 0 ;
20409 char *kwnames[] = {
20410 (char *) "self", NULL
20411 };
20412
20413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20415 if (SWIG_arg_fail(1)) SWIG_fail;
20416 {
20417 PyThreadState* __tstate = wxPyBeginAllowThreads();
20418 result = ((wxMoveEvent const *)arg1)->GetPosition();
20419
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 {
20424 wxPoint * resultptr;
20425 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20427 }
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20435 PyObject *resultobj = NULL;
20436 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20437 wxRect result;
20438 PyObject * obj0 = 0 ;
20439 char *kwnames[] = {
20440 (char *) "self", NULL
20441 };
20442
20443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20445 if (SWIG_arg_fail(1)) SWIG_fail;
20446 {
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 result = ((wxMoveEvent const *)arg1)->GetRect();
20449
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 {
20454 wxRect * resultptr;
20455 resultptr = new wxRect(static_cast<wxRect & >(result));
20456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20457 }
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20465 PyObject *resultobj = NULL;
20466 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20467 wxRect *arg2 = 0 ;
20468 wxRect temp2 ;
20469 PyObject * obj0 = 0 ;
20470 PyObject * obj1 = 0 ;
20471 char *kwnames[] = {
20472 (char *) "self",(char *) "rect", NULL
20473 };
20474
20475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20477 if (SWIG_arg_fail(1)) SWIG_fail;
20478 {
20479 arg2 = &temp2;
20480 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20481 }
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 (arg1)->SetRect((wxRect const &)*arg2);
20485
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 Py_INCREF(Py_None); resultobj = Py_None;
20490 return resultobj;
20491 fail:
20492 return NULL;
20493 }
20494
20495
20496 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj = NULL;
20498 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20499 wxPoint *arg2 = 0 ;
20500 wxPoint temp2 ;
20501 PyObject * obj0 = 0 ;
20502 PyObject * obj1 = 0 ;
20503 char *kwnames[] = {
20504 (char *) "self",(char *) "pos", NULL
20505 };
20506
20507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20509 if (SWIG_arg_fail(1)) SWIG_fail;
20510 {
20511 arg2 = &temp2;
20512 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20513 }
20514 {
20515 PyThreadState* __tstate = wxPyBeginAllowThreads();
20516 (arg1)->SetPosition((wxPoint const &)*arg2);
20517
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 Py_INCREF(Py_None); resultobj = Py_None;
20522 return resultobj;
20523 fail:
20524 return NULL;
20525 }
20526
20527
20528 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20529 PyObject *obj;
20530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20531 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20532 Py_INCREF(obj);
20533 return Py_BuildValue((char *)"");
20534 }
20535 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20536 PyObject *resultobj = NULL;
20537 int arg1 = (int) 0 ;
20538 wxPaintEvent *result;
20539 PyObject * obj0 = 0 ;
20540 char *kwnames[] = {
20541 (char *) "Id", NULL
20542 };
20543
20544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20545 if (obj0) {
20546 {
20547 arg1 = static_cast<int >(SWIG_As_int(obj0));
20548 if (SWIG_arg_fail(1)) SWIG_fail;
20549 }
20550 }
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20554
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20566 PyObject *obj;
20567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20568 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20569 Py_INCREF(obj);
20570 return Py_BuildValue((char *)"");
20571 }
20572 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20573 PyObject *resultobj = NULL;
20574 int arg1 = (int) 0 ;
20575 wxNcPaintEvent *result;
20576 PyObject * obj0 = 0 ;
20577 char *kwnames[] = {
20578 (char *) "winid", NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20582 if (obj0) {
20583 {
20584 arg1 = static_cast<int >(SWIG_As_int(obj0));
20585 if (SWIG_arg_fail(1)) SWIG_fail;
20586 }
20587 }
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20591
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20596 return resultobj;
20597 fail:
20598 return NULL;
20599 }
20600
20601
20602 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20603 PyObject *obj;
20604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20605 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20606 Py_INCREF(obj);
20607 return Py_BuildValue((char *)"");
20608 }
20609 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20610 PyObject *resultobj = NULL;
20611 int arg1 = (int) 0 ;
20612 wxDC *arg2 = (wxDC *) NULL ;
20613 wxEraseEvent *result;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 char *kwnames[] = {
20617 (char *) "Id",(char *) "dc", NULL
20618 };
20619
20620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20621 if (obj0) {
20622 {
20623 arg1 = static_cast<int >(SWIG_As_int(obj0));
20624 if (SWIG_arg_fail(1)) SWIG_fail;
20625 }
20626 }
20627 if (obj1) {
20628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20629 if (SWIG_arg_fail(2)) SWIG_fail;
20630 }
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20634
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20639 return resultobj;
20640 fail:
20641 return NULL;
20642 }
20643
20644
20645 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20646 PyObject *resultobj = NULL;
20647 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20648 wxDC *result;
20649 PyObject * obj0 = 0 ;
20650 char *kwnames[] = {
20651 (char *) "self", NULL
20652 };
20653
20654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20656 if (SWIG_arg_fail(1)) SWIG_fail;
20657 {
20658 PyThreadState* __tstate = wxPyBeginAllowThreads();
20659 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20660
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 {
20665 resultobj = wxPyMake_wxObject(result, (bool)0);
20666 }
20667 return resultobj;
20668 fail:
20669 return NULL;
20670 }
20671
20672
20673 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20674 PyObject *obj;
20675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20676 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20677 Py_INCREF(obj);
20678 return Py_BuildValue((char *)"");
20679 }
20680 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20681 PyObject *resultobj = NULL;
20682 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20683 int arg2 = (int) 0 ;
20684 wxFocusEvent *result;
20685 PyObject * obj0 = 0 ;
20686 PyObject * obj1 = 0 ;
20687 char *kwnames[] = {
20688 (char *) "type",(char *) "winid", NULL
20689 };
20690
20691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20692 if (obj0) {
20693 {
20694 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20695 if (SWIG_arg_fail(1)) SWIG_fail;
20696 }
20697 }
20698 if (obj1) {
20699 {
20700 arg2 = static_cast<int >(SWIG_As_int(obj1));
20701 if (SWIG_arg_fail(2)) SWIG_fail;
20702 }
20703 }
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20707
20708 wxPyEndAllowThreads(__tstate);
20709 if (PyErr_Occurred()) SWIG_fail;
20710 }
20711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20712 return resultobj;
20713 fail:
20714 return NULL;
20715 }
20716
20717
20718 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20719 PyObject *resultobj = NULL;
20720 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20721 wxWindow *result;
20722 PyObject * obj0 = 0 ;
20723 char *kwnames[] = {
20724 (char *) "self", NULL
20725 };
20726
20727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20729 if (SWIG_arg_fail(1)) SWIG_fail;
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20733
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = wxPyMake_wxObject(result, (bool)0);
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20747 PyObject *resultobj = NULL;
20748 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20749 wxWindow *arg2 = (wxWindow *) 0 ;
20750 PyObject * obj0 = 0 ;
20751 PyObject * obj1 = 0 ;
20752 char *kwnames[] = {
20753 (char *) "self",(char *) "win", NULL
20754 };
20755
20756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20758 if (SWIG_arg_fail(1)) SWIG_fail;
20759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20760 if (SWIG_arg_fail(2)) SWIG_fail;
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 (arg1)->SetWindow(arg2);
20764
20765 wxPyEndAllowThreads(__tstate);
20766 if (PyErr_Occurred()) SWIG_fail;
20767 }
20768 Py_INCREF(Py_None); resultobj = Py_None;
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20776 PyObject *obj;
20777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20778 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20779 Py_INCREF(obj);
20780 return Py_BuildValue((char *)"");
20781 }
20782 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20783 PyObject *resultobj = NULL;
20784 wxWindow *arg1 = (wxWindow *) NULL ;
20785 wxChildFocusEvent *result;
20786 PyObject * obj0 = 0 ;
20787 char *kwnames[] = {
20788 (char *) "win", NULL
20789 };
20790
20791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20792 if (obj0) {
20793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20794 if (SWIG_arg_fail(1)) SWIG_fail;
20795 }
20796 {
20797 PyThreadState* __tstate = wxPyBeginAllowThreads();
20798 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20799
20800 wxPyEndAllowThreads(__tstate);
20801 if (PyErr_Occurred()) SWIG_fail;
20802 }
20803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20804 return resultobj;
20805 fail:
20806 return NULL;
20807 }
20808
20809
20810 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20811 PyObject *resultobj = NULL;
20812 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20813 wxWindow *result;
20814 PyObject * obj0 = 0 ;
20815 char *kwnames[] = {
20816 (char *) "self", NULL
20817 };
20818
20819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20821 if (SWIG_arg_fail(1)) SWIG_fail;
20822 {
20823 PyThreadState* __tstate = wxPyBeginAllowThreads();
20824 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20825
20826 wxPyEndAllowThreads(__tstate);
20827 if (PyErr_Occurred()) SWIG_fail;
20828 }
20829 {
20830 resultobj = wxPyMake_wxObject(result, (bool)0);
20831 }
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20839 PyObject *obj;
20840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20841 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20842 Py_INCREF(obj);
20843 return Py_BuildValue((char *)"");
20844 }
20845 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20846 PyObject *resultobj = NULL;
20847 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20848 bool arg2 = (bool) true ;
20849 int arg3 = (int) 0 ;
20850 wxActivateEvent *result;
20851 PyObject * obj0 = 0 ;
20852 PyObject * obj1 = 0 ;
20853 PyObject * obj2 = 0 ;
20854 char *kwnames[] = {
20855 (char *) "type",(char *) "active",(char *) "Id", NULL
20856 };
20857
20858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20859 if (obj0) {
20860 {
20861 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20862 if (SWIG_arg_fail(1)) SWIG_fail;
20863 }
20864 }
20865 if (obj1) {
20866 {
20867 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20868 if (SWIG_arg_fail(2)) SWIG_fail;
20869 }
20870 }
20871 if (obj2) {
20872 {
20873 arg3 = static_cast<int >(SWIG_As_int(obj2));
20874 if (SWIG_arg_fail(3)) SWIG_fail;
20875 }
20876 }
20877 {
20878 PyThreadState* __tstate = wxPyBeginAllowThreads();
20879 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20880
20881 wxPyEndAllowThreads(__tstate);
20882 if (PyErr_Occurred()) SWIG_fail;
20883 }
20884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20885 return resultobj;
20886 fail:
20887 return NULL;
20888 }
20889
20890
20891 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20892 PyObject *resultobj = NULL;
20893 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20894 bool result;
20895 PyObject * obj0 = 0 ;
20896 char *kwnames[] = {
20897 (char *) "self", NULL
20898 };
20899
20900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20902 if (SWIG_arg_fail(1)) SWIG_fail;
20903 {
20904 PyThreadState* __tstate = wxPyBeginAllowThreads();
20905 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20906
20907 wxPyEndAllowThreads(__tstate);
20908 if (PyErr_Occurred()) SWIG_fail;
20909 }
20910 {
20911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20912 }
20913 return resultobj;
20914 fail:
20915 return NULL;
20916 }
20917
20918
20919 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20920 PyObject *obj;
20921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20922 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20923 Py_INCREF(obj);
20924 return Py_BuildValue((char *)"");
20925 }
20926 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20927 PyObject *resultobj = NULL;
20928 int arg1 = (int) 0 ;
20929 wxInitDialogEvent *result;
20930 PyObject * obj0 = 0 ;
20931 char *kwnames[] = {
20932 (char *) "Id", NULL
20933 };
20934
20935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20936 if (obj0) {
20937 {
20938 arg1 = static_cast<int >(SWIG_As_int(obj0));
20939 if (SWIG_arg_fail(1)) SWIG_fail;
20940 }
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20957 PyObject *obj;
20958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20959 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20960 Py_INCREF(obj);
20961 return Py_BuildValue((char *)"");
20962 }
20963 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20964 PyObject *resultobj = NULL;
20965 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20966 int arg2 = (int) 0 ;
20967 wxMenu *arg3 = (wxMenu *) NULL ;
20968 wxMenuEvent *result;
20969 PyObject * obj0 = 0 ;
20970 PyObject * obj1 = 0 ;
20971 PyObject * obj2 = 0 ;
20972 char *kwnames[] = {
20973 (char *) "type",(char *) "winid",(char *) "menu", NULL
20974 };
20975
20976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20977 if (obj0) {
20978 {
20979 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20980 if (SWIG_arg_fail(1)) SWIG_fail;
20981 }
20982 }
20983 if (obj1) {
20984 {
20985 arg2 = static_cast<int >(SWIG_As_int(obj1));
20986 if (SWIG_arg_fail(2)) SWIG_fail;
20987 }
20988 }
20989 if (obj2) {
20990 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20991 if (SWIG_arg_fail(3)) SWIG_fail;
20992 }
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20996
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
21001 return resultobj;
21002 fail:
21003 return NULL;
21004 }
21005
21006
21007 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
21008 PyObject *resultobj = NULL;
21009 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21010 int result;
21011 PyObject * obj0 = 0 ;
21012 char *kwnames[] = {
21013 (char *) "self", NULL
21014 };
21015
21016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
21017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21018 if (SWIG_arg_fail(1)) SWIG_fail;
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
21022
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 {
21027 resultobj = SWIG_From_int(static_cast<int >(result));
21028 }
21029 return resultobj;
21030 fail:
21031 return NULL;
21032 }
21033
21034
21035 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
21036 PyObject *resultobj = NULL;
21037 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21038 bool result;
21039 PyObject * obj0 = 0 ;
21040 char *kwnames[] = {
21041 (char *) "self", NULL
21042 };
21043
21044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
21045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21046 if (SWIG_arg_fail(1)) SWIG_fail;
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
21050
21051 wxPyEndAllowThreads(__tstate);
21052 if (PyErr_Occurred()) SWIG_fail;
21053 }
21054 {
21055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21056 }
21057 return resultobj;
21058 fail:
21059 return NULL;
21060 }
21061
21062
21063 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
21064 PyObject *resultobj = NULL;
21065 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21066 wxMenu *result;
21067 PyObject * obj0 = 0 ;
21068 char *kwnames[] = {
21069 (char *) "self", NULL
21070 };
21071
21072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
21073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21074 if (SWIG_arg_fail(1)) SWIG_fail;
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
21078
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 {
21083 resultobj = wxPyMake_wxObject(result, (bool)0);
21084 }
21085 return resultobj;
21086 fail:
21087 return NULL;
21088 }
21089
21090
21091 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21092 PyObject *obj;
21093 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21094 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21095 Py_INCREF(obj);
21096 return Py_BuildValue((char *)"");
21097 }
21098 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj = NULL;
21100 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21101 int arg2 = (int) 0 ;
21102 wxCloseEvent *result;
21103 PyObject * obj0 = 0 ;
21104 PyObject * obj1 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "type",(char *) "winid", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21110 if (obj0) {
21111 {
21112 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21113 if (SWIG_arg_fail(1)) SWIG_fail;
21114 }
21115 }
21116 if (obj1) {
21117 {
21118 arg2 = static_cast<int >(SWIG_As_int(obj1));
21119 if (SWIG_arg_fail(2)) SWIG_fail;
21120 }
21121 }
21122 {
21123 PyThreadState* __tstate = wxPyBeginAllowThreads();
21124 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21125
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21130 return resultobj;
21131 fail:
21132 return NULL;
21133 }
21134
21135
21136 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21137 PyObject *resultobj = NULL;
21138 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21139 bool arg2 ;
21140 PyObject * obj0 = 0 ;
21141 PyObject * obj1 = 0 ;
21142 char *kwnames[] = {
21143 (char *) "self",(char *) "logOff", NULL
21144 };
21145
21146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21148 if (SWIG_arg_fail(1)) SWIG_fail;
21149 {
21150 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21151 if (SWIG_arg_fail(2)) SWIG_fail;
21152 }
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 (arg1)->SetLoggingOff(arg2);
21156
21157 wxPyEndAllowThreads(__tstate);
21158 if (PyErr_Occurred()) SWIG_fail;
21159 }
21160 Py_INCREF(Py_None); resultobj = Py_None;
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21168 PyObject *resultobj = NULL;
21169 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21170 bool result;
21171 PyObject * obj0 = 0 ;
21172 char *kwnames[] = {
21173 (char *) "self", NULL
21174 };
21175
21176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21178 if (SWIG_arg_fail(1)) SWIG_fail;
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21182
21183 wxPyEndAllowThreads(__tstate);
21184 if (PyErr_Occurred()) SWIG_fail;
21185 }
21186 {
21187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21188 }
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21196 PyObject *resultobj = NULL;
21197 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21198 bool arg2 = (bool) true ;
21199 PyObject * obj0 = 0 ;
21200 PyObject * obj1 = 0 ;
21201 char *kwnames[] = {
21202 (char *) "self",(char *) "veto", NULL
21203 };
21204
21205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21207 if (SWIG_arg_fail(1)) SWIG_fail;
21208 if (obj1) {
21209 {
21210 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21211 if (SWIG_arg_fail(2)) SWIG_fail;
21212 }
21213 }
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 (arg1)->Veto(arg2);
21217
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 Py_INCREF(Py_None); resultobj = Py_None;
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj = NULL;
21230 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21231 bool result;
21232 PyObject * obj0 = 0 ;
21233 char *kwnames[] = {
21234 (char *) "self", NULL
21235 };
21236
21237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21239 if (SWIG_arg_fail(1)) SWIG_fail;
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21243
21244 wxPyEndAllowThreads(__tstate);
21245 if (PyErr_Occurred()) SWIG_fail;
21246 }
21247 {
21248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21249 }
21250 return resultobj;
21251 fail:
21252 return NULL;
21253 }
21254
21255
21256 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21257 PyObject *resultobj = NULL;
21258 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21259 bool arg2 ;
21260 PyObject * obj0 = 0 ;
21261 PyObject * obj1 = 0 ;
21262 char *kwnames[] = {
21263 (char *) "self",(char *) "canVeto", NULL
21264 };
21265
21266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21268 if (SWIG_arg_fail(1)) SWIG_fail;
21269 {
21270 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21271 if (SWIG_arg_fail(2)) SWIG_fail;
21272 }
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 (arg1)->SetCanVeto(arg2);
21276
21277 wxPyEndAllowThreads(__tstate);
21278 if (PyErr_Occurred()) SWIG_fail;
21279 }
21280 Py_INCREF(Py_None); resultobj = Py_None;
21281 return resultobj;
21282 fail:
21283 return NULL;
21284 }
21285
21286
21287 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21288 PyObject *resultobj = NULL;
21289 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21290 bool result;
21291 PyObject * obj0 = 0 ;
21292 char *kwnames[] = {
21293 (char *) "self", NULL
21294 };
21295
21296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21298 if (SWIG_arg_fail(1)) SWIG_fail;
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 {
21307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21308 }
21309 return resultobj;
21310 fail:
21311 return NULL;
21312 }
21313
21314
21315 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21316 PyObject *obj;
21317 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21318 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21319 Py_INCREF(obj);
21320 return Py_BuildValue((char *)"");
21321 }
21322 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj = NULL;
21324 int arg1 = (int) 0 ;
21325 bool arg2 = (bool) false ;
21326 wxShowEvent *result;
21327 PyObject * obj0 = 0 ;
21328 PyObject * obj1 = 0 ;
21329 char *kwnames[] = {
21330 (char *) "winid",(char *) "show", NULL
21331 };
21332
21333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21334 if (obj0) {
21335 {
21336 arg1 = static_cast<int >(SWIG_As_int(obj0));
21337 if (SWIG_arg_fail(1)) SWIG_fail;
21338 }
21339 }
21340 if (obj1) {
21341 {
21342 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21343 if (SWIG_arg_fail(2)) SWIG_fail;
21344 }
21345 }
21346 {
21347 PyThreadState* __tstate = wxPyBeginAllowThreads();
21348 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21349
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21354 return resultobj;
21355 fail:
21356 return NULL;
21357 }
21358
21359
21360 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21361 PyObject *resultobj = NULL;
21362 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21363 bool arg2 ;
21364 PyObject * obj0 = 0 ;
21365 PyObject * obj1 = 0 ;
21366 char *kwnames[] = {
21367 (char *) "self",(char *) "show", NULL
21368 };
21369
21370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21372 if (SWIG_arg_fail(1)) SWIG_fail;
21373 {
21374 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21375 if (SWIG_arg_fail(2)) SWIG_fail;
21376 }
21377 {
21378 PyThreadState* __tstate = wxPyBeginAllowThreads();
21379 (arg1)->SetShow(arg2);
21380
21381 wxPyEndAllowThreads(__tstate);
21382 if (PyErr_Occurred()) SWIG_fail;
21383 }
21384 Py_INCREF(Py_None); resultobj = Py_None;
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj = NULL;
21393 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21394 bool result;
21395 PyObject * obj0 = 0 ;
21396 char *kwnames[] = {
21397 (char *) "self", NULL
21398 };
21399
21400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21402 if (SWIG_arg_fail(1)) SWIG_fail;
21403 {
21404 PyThreadState* __tstate = wxPyBeginAllowThreads();
21405 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21406
21407 wxPyEndAllowThreads(__tstate);
21408 if (PyErr_Occurred()) SWIG_fail;
21409 }
21410 {
21411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21412 }
21413 return resultobj;
21414 fail:
21415 return NULL;
21416 }
21417
21418
21419 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21420 PyObject *obj;
21421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21422 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21423 Py_INCREF(obj);
21424 return Py_BuildValue((char *)"");
21425 }
21426 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj = NULL;
21428 int arg1 = (int) 0 ;
21429 bool arg2 = (bool) true ;
21430 wxIconizeEvent *result;
21431 PyObject * obj0 = 0 ;
21432 PyObject * obj1 = 0 ;
21433 char *kwnames[] = {
21434 (char *) "id",(char *) "iconized", NULL
21435 };
21436
21437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21438 if (obj0) {
21439 {
21440 arg1 = static_cast<int >(SWIG_As_int(obj0));
21441 if (SWIG_arg_fail(1)) SWIG_fail;
21442 }
21443 }
21444 if (obj1) {
21445 {
21446 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21447 if (SWIG_arg_fail(2)) SWIG_fail;
21448 }
21449 }
21450 {
21451 PyThreadState* __tstate = wxPyBeginAllowThreads();
21452 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21453
21454 wxPyEndAllowThreads(__tstate);
21455 if (PyErr_Occurred()) SWIG_fail;
21456 }
21457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21465 PyObject *resultobj = NULL;
21466 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21467 bool result;
21468 PyObject * obj0 = 0 ;
21469 char *kwnames[] = {
21470 (char *) "self", NULL
21471 };
21472
21473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21475 if (SWIG_arg_fail(1)) SWIG_fail;
21476 {
21477 PyThreadState* __tstate = wxPyBeginAllowThreads();
21478 result = (bool)(arg1)->Iconized();
21479
21480 wxPyEndAllowThreads(__tstate);
21481 if (PyErr_Occurred()) SWIG_fail;
21482 }
21483 {
21484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21485 }
21486 return resultobj;
21487 fail:
21488 return NULL;
21489 }
21490
21491
21492 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21493 PyObject *obj;
21494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21495 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21496 Py_INCREF(obj);
21497 return Py_BuildValue((char *)"");
21498 }
21499 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21500 PyObject *resultobj = NULL;
21501 int arg1 = (int) 0 ;
21502 wxMaximizeEvent *result;
21503 PyObject * obj0 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "id", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21509 if (obj0) {
21510 {
21511 arg1 = static_cast<int >(SWIG_As_int(obj0));
21512 if (SWIG_arg_fail(1)) SWIG_fail;
21513 }
21514 }
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21518
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21523 return resultobj;
21524 fail:
21525 return NULL;
21526 }
21527
21528
21529 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21530 PyObject *obj;
21531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21532 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21533 Py_INCREF(obj);
21534 return Py_BuildValue((char *)"");
21535 }
21536 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21537 PyObject *resultobj = NULL;
21538 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21539 wxPoint result;
21540 PyObject * obj0 = 0 ;
21541 char *kwnames[] = {
21542 (char *) "self", NULL
21543 };
21544
21545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21547 if (SWIG_arg_fail(1)) SWIG_fail;
21548 {
21549 PyThreadState* __tstate = wxPyBeginAllowThreads();
21550 result = (arg1)->GetPosition();
21551
21552 wxPyEndAllowThreads(__tstate);
21553 if (PyErr_Occurred()) SWIG_fail;
21554 }
21555 {
21556 wxPoint * resultptr;
21557 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21559 }
21560 return resultobj;
21561 fail:
21562 return NULL;
21563 }
21564
21565
21566 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21567 PyObject *resultobj = NULL;
21568 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21569 int result;
21570 PyObject * obj0 = 0 ;
21571 char *kwnames[] = {
21572 (char *) "self", NULL
21573 };
21574
21575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21577 if (SWIG_arg_fail(1)) SWIG_fail;
21578 {
21579 PyThreadState* __tstate = wxPyBeginAllowThreads();
21580 result = (int)(arg1)->GetNumberOfFiles();
21581
21582 wxPyEndAllowThreads(__tstate);
21583 if (PyErr_Occurred()) SWIG_fail;
21584 }
21585 {
21586 resultobj = SWIG_From_int(static_cast<int >(result));
21587 }
21588 return resultobj;
21589 fail:
21590 return NULL;
21591 }
21592
21593
21594 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21595 PyObject *resultobj = NULL;
21596 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21597 PyObject *result;
21598 PyObject * obj0 = 0 ;
21599 char *kwnames[] = {
21600 (char *) "self", NULL
21601 };
21602
21603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21605 if (SWIG_arg_fail(1)) SWIG_fail;
21606 {
21607 PyThreadState* __tstate = wxPyBeginAllowThreads();
21608 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21609
21610 wxPyEndAllowThreads(__tstate);
21611 if (PyErr_Occurred()) SWIG_fail;
21612 }
21613 resultobj = result;
21614 return resultobj;
21615 fail:
21616 return NULL;
21617 }
21618
21619
21620 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21621 PyObject *obj;
21622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21623 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21624 Py_INCREF(obj);
21625 return Py_BuildValue((char *)"");
21626 }
21627 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21628 PyObject *resultobj = NULL;
21629 int arg1 = (int) 0 ;
21630 wxUpdateUIEvent *result;
21631 PyObject * obj0 = 0 ;
21632 char *kwnames[] = {
21633 (char *) "commandId", NULL
21634 };
21635
21636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21637 if (obj0) {
21638 {
21639 arg1 = static_cast<int >(SWIG_As_int(obj0));
21640 if (SWIG_arg_fail(1)) SWIG_fail;
21641 }
21642 }
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21646
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj = NULL;
21659 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21660 bool result;
21661 PyObject * obj0 = 0 ;
21662 char *kwnames[] = {
21663 (char *) "self", NULL
21664 };
21665
21666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21668 if (SWIG_arg_fail(1)) SWIG_fail;
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21672
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 {
21677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21678 }
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21686 PyObject *resultobj = NULL;
21687 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21688 bool result;
21689 PyObject * obj0 = 0 ;
21690 char *kwnames[] = {
21691 (char *) "self", NULL
21692 };
21693
21694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21696 if (SWIG_arg_fail(1)) SWIG_fail;
21697 {
21698 PyThreadState* __tstate = wxPyBeginAllowThreads();
21699 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21700
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 {
21705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21706 }
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 static PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *, PyObject *args, PyObject *kwargs) {
21714 PyObject *resultobj = NULL;
21715 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21716 bool result;
21717 PyObject * obj0 = 0 ;
21718 char *kwnames[] = {
21719 (char *) "self", NULL
21720 };
21721
21722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetShown",kwnames,&obj0)) goto fail;
21723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21724 if (SWIG_arg_fail(1)) SWIG_fail;
21725 {
21726 PyThreadState* __tstate = wxPyBeginAllowThreads();
21727 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
21728
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 {
21733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21734 }
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21742 PyObject *resultobj = NULL;
21743 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21744 wxString result;
21745 PyObject * obj0 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "self", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21752 if (SWIG_arg_fail(1)) SWIG_fail;
21753 {
21754 PyThreadState* __tstate = wxPyBeginAllowThreads();
21755 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21756
21757 wxPyEndAllowThreads(__tstate);
21758 if (PyErr_Occurred()) SWIG_fail;
21759 }
21760 {
21761 #if wxUSE_UNICODE
21762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21763 #else
21764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21765 #endif
21766 }
21767 return resultobj;
21768 fail:
21769 return NULL;
21770 }
21771
21772
21773 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21774 PyObject *resultobj = NULL;
21775 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21776 bool result;
21777 PyObject * obj0 = 0 ;
21778 char *kwnames[] = {
21779 (char *) "self", NULL
21780 };
21781
21782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21784 if (SWIG_arg_fail(1)) SWIG_fail;
21785 {
21786 PyThreadState* __tstate = wxPyBeginAllowThreads();
21787 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21788
21789 wxPyEndAllowThreads(__tstate);
21790 if (PyErr_Occurred()) SWIG_fail;
21791 }
21792 {
21793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21794 }
21795 return resultobj;
21796 fail:
21797 return NULL;
21798 }
21799
21800
21801 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21802 PyObject *resultobj = NULL;
21803 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21804 bool result;
21805 PyObject * obj0 = 0 ;
21806 char *kwnames[] = {
21807 (char *) "self", NULL
21808 };
21809
21810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21812 if (SWIG_arg_fail(1)) SWIG_fail;
21813 {
21814 PyThreadState* __tstate = wxPyBeginAllowThreads();
21815 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21816
21817 wxPyEndAllowThreads(__tstate);
21818 if (PyErr_Occurred()) SWIG_fail;
21819 }
21820 {
21821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21822 }
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21830 PyObject *resultobj = NULL;
21831 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21832 bool result;
21833 PyObject * obj0 = 0 ;
21834 char *kwnames[] = {
21835 (char *) "self", NULL
21836 };
21837
21838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21840 if (SWIG_arg_fail(1)) SWIG_fail;
21841 {
21842 PyThreadState* __tstate = wxPyBeginAllowThreads();
21843 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21844
21845 wxPyEndAllowThreads(__tstate);
21846 if (PyErr_Occurred()) SWIG_fail;
21847 }
21848 {
21849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21850 }
21851 return resultobj;
21852 fail:
21853 return NULL;
21854 }
21855
21856
21857 static PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *, PyObject *args, PyObject *kwargs) {
21858 PyObject *resultobj = NULL;
21859 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21860 bool result;
21861 PyObject * obj0 = 0 ;
21862 char *kwnames[] = {
21863 (char *) "self", NULL
21864 };
21865
21866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetShown",kwnames,&obj0)) goto fail;
21867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21868 if (SWIG_arg_fail(1)) SWIG_fail;
21869 {
21870 PyThreadState* __tstate = wxPyBeginAllowThreads();
21871 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
21872
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 {
21877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21878 }
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj = NULL;
21887 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21888 bool arg2 ;
21889 PyObject * obj0 = 0 ;
21890 PyObject * obj1 = 0 ;
21891 char *kwnames[] = {
21892 (char *) "self",(char *) "check", NULL
21893 };
21894
21895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21897 if (SWIG_arg_fail(1)) SWIG_fail;
21898 {
21899 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21900 if (SWIG_arg_fail(2)) SWIG_fail;
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 (arg1)->Check(arg2);
21905
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 Py_INCREF(Py_None); resultobj = Py_None;
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj = NULL;
21918 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21919 bool arg2 ;
21920 PyObject * obj0 = 0 ;
21921 PyObject * obj1 = 0 ;
21922 char *kwnames[] = {
21923 (char *) "self",(char *) "enable", NULL
21924 };
21925
21926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21928 if (SWIG_arg_fail(1)) SWIG_fail;
21929 {
21930 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21931 if (SWIG_arg_fail(2)) SWIG_fail;
21932 }
21933 {
21934 PyThreadState* __tstate = wxPyBeginAllowThreads();
21935 (arg1)->Enable(arg2);
21936
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 Py_INCREF(Py_None); resultobj = Py_None;
21941 return resultobj;
21942 fail:
21943 return NULL;
21944 }
21945
21946
21947 static PyObject *_wrap_UpdateUIEvent_Show(PyObject *, PyObject *args, PyObject *kwargs) {
21948 PyObject *resultobj = NULL;
21949 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21950 bool arg2 ;
21951 PyObject * obj0 = 0 ;
21952 PyObject * obj1 = 0 ;
21953 char *kwnames[] = {
21954 (char *) "self",(char *) "show", NULL
21955 };
21956
21957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) goto fail;
21958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21959 if (SWIG_arg_fail(1)) SWIG_fail;
21960 {
21961 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21962 if (SWIG_arg_fail(2)) SWIG_fail;
21963 }
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 (arg1)->Show(arg2);
21967
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 Py_INCREF(Py_None); resultobj = Py_None;
21972 return resultobj;
21973 fail:
21974 return NULL;
21975 }
21976
21977
21978 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj = NULL;
21980 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21981 wxString *arg2 = 0 ;
21982 bool temp2 = false ;
21983 PyObject * obj0 = 0 ;
21984 PyObject * obj1 = 0 ;
21985 char *kwnames[] = {
21986 (char *) "self",(char *) "text", NULL
21987 };
21988
21989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21991 if (SWIG_arg_fail(1)) SWIG_fail;
21992 {
21993 arg2 = wxString_in_helper(obj1);
21994 if (arg2 == NULL) SWIG_fail;
21995 temp2 = true;
21996 }
21997 {
21998 PyThreadState* __tstate = wxPyBeginAllowThreads();
21999 (arg1)->SetText((wxString const &)*arg2);
22000
22001 wxPyEndAllowThreads(__tstate);
22002 if (PyErr_Occurred()) SWIG_fail;
22003 }
22004 Py_INCREF(Py_None); resultobj = Py_None;
22005 {
22006 if (temp2)
22007 delete arg2;
22008 }
22009 return resultobj;
22010 fail:
22011 {
22012 if (temp2)
22013 delete arg2;
22014 }
22015 return NULL;
22016 }
22017
22018
22019 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
22020 PyObject *resultobj = NULL;
22021 long arg1 ;
22022 PyObject * obj0 = 0 ;
22023 char *kwnames[] = {
22024 (char *) "updateInterval", NULL
22025 };
22026
22027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
22028 {
22029 arg1 = static_cast<long >(SWIG_As_long(obj0));
22030 if (SWIG_arg_fail(1)) SWIG_fail;
22031 }
22032 {
22033 PyThreadState* __tstate = wxPyBeginAllowThreads();
22034 wxUpdateUIEvent::SetUpdateInterval(arg1);
22035
22036 wxPyEndAllowThreads(__tstate);
22037 if (PyErr_Occurred()) SWIG_fail;
22038 }
22039 Py_INCREF(Py_None); resultobj = Py_None;
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj = NULL;
22048 long result;
22049 char *kwnames[] = {
22050 NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (long)wxUpdateUIEvent::GetUpdateInterval();
22057
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 {
22062 resultobj = SWIG_From_long(static_cast<long >(result));
22063 }
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
22071 PyObject *resultobj = NULL;
22072 wxWindow *arg1 = (wxWindow *) 0 ;
22073 bool result;
22074 PyObject * obj0 = 0 ;
22075 char *kwnames[] = {
22076 (char *) "win", NULL
22077 };
22078
22079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
22080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22081 if (SWIG_arg_fail(1)) SWIG_fail;
22082 {
22083 PyThreadState* __tstate = wxPyBeginAllowThreads();
22084 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
22085
22086 wxPyEndAllowThreads(__tstate);
22087 if (PyErr_Occurred()) SWIG_fail;
22088 }
22089 {
22090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22091 }
22092 return resultobj;
22093 fail:
22094 return NULL;
22095 }
22096
22097
22098 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
22099 PyObject *resultobj = NULL;
22100 char *kwnames[] = {
22101 NULL
22102 };
22103
22104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
22105 {
22106 PyThreadState* __tstate = wxPyBeginAllowThreads();
22107 wxUpdateUIEvent::ResetUpdateTime();
22108
22109 wxPyEndAllowThreads(__tstate);
22110 if (PyErr_Occurred()) SWIG_fail;
22111 }
22112 Py_INCREF(Py_None); resultobj = Py_None;
22113 return resultobj;
22114 fail:
22115 return NULL;
22116 }
22117
22118
22119 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22120 PyObject *resultobj = NULL;
22121 wxUpdateUIMode arg1 ;
22122 PyObject * obj0 = 0 ;
22123 char *kwnames[] = {
22124 (char *) "mode", NULL
22125 };
22126
22127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
22128 {
22129 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
22130 if (SWIG_arg_fail(1)) SWIG_fail;
22131 }
22132 {
22133 PyThreadState* __tstate = wxPyBeginAllowThreads();
22134 wxUpdateUIEvent::SetMode(arg1);
22135
22136 wxPyEndAllowThreads(__tstate);
22137 if (PyErr_Occurred()) SWIG_fail;
22138 }
22139 Py_INCREF(Py_None); resultobj = Py_None;
22140 return resultobj;
22141 fail:
22142 return NULL;
22143 }
22144
22145
22146 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22147 PyObject *resultobj = NULL;
22148 wxUpdateUIMode result;
22149 char *kwnames[] = {
22150 NULL
22151 };
22152
22153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
22154 {
22155 PyThreadState* __tstate = wxPyBeginAllowThreads();
22156 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
22157
22158 wxPyEndAllowThreads(__tstate);
22159 if (PyErr_Occurred()) SWIG_fail;
22160 }
22161 resultobj = SWIG_From_int((result));
22162 return resultobj;
22163 fail:
22164 return NULL;
22165 }
22166
22167
22168 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
22169 PyObject *obj;
22170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22171 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22172 Py_INCREF(obj);
22173 return Py_BuildValue((char *)"");
22174 }
22175 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22176 PyObject *resultobj = NULL;
22177 wxSysColourChangedEvent *result;
22178 char *kwnames[] = {
22179 NULL
22180 };
22181
22182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22186
22187 wxPyEndAllowThreads(__tstate);
22188 if (PyErr_Occurred()) SWIG_fail;
22189 }
22190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22191 return resultobj;
22192 fail:
22193 return NULL;
22194 }
22195
22196
22197 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22198 PyObject *obj;
22199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22200 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22201 Py_INCREF(obj);
22202 return Py_BuildValue((char *)"");
22203 }
22204 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22205 PyObject *resultobj = NULL;
22206 int arg1 = (int) 0 ;
22207 wxWindow *arg2 = (wxWindow *) NULL ;
22208 wxMouseCaptureChangedEvent *result;
22209 PyObject * obj0 = 0 ;
22210 PyObject * obj1 = 0 ;
22211 char *kwnames[] = {
22212 (char *) "winid",(char *) "gainedCapture", NULL
22213 };
22214
22215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22216 if (obj0) {
22217 {
22218 arg1 = static_cast<int >(SWIG_As_int(obj0));
22219 if (SWIG_arg_fail(1)) SWIG_fail;
22220 }
22221 }
22222 if (obj1) {
22223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22224 if (SWIG_arg_fail(2)) SWIG_fail;
22225 }
22226 {
22227 PyThreadState* __tstate = wxPyBeginAllowThreads();
22228 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22229
22230 wxPyEndAllowThreads(__tstate);
22231 if (PyErr_Occurred()) SWIG_fail;
22232 }
22233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22234 return resultobj;
22235 fail:
22236 return NULL;
22237 }
22238
22239
22240 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22241 PyObject *resultobj = NULL;
22242 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22243 wxWindow *result;
22244 PyObject * obj0 = 0 ;
22245 char *kwnames[] = {
22246 (char *) "self", NULL
22247 };
22248
22249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22251 if (SWIG_arg_fail(1)) SWIG_fail;
22252 {
22253 PyThreadState* __tstate = wxPyBeginAllowThreads();
22254 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22255
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 resultobj = wxPyMake_wxObject(result, (bool)0);
22261 }
22262 return resultobj;
22263 fail:
22264 return NULL;
22265 }
22266
22267
22268 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22269 PyObject *obj;
22270 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22271 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22272 Py_INCREF(obj);
22273 return Py_BuildValue((char *)"");
22274 }
22275 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj = NULL;
22277 wxDisplayChangedEvent *result;
22278 char *kwnames[] = {
22279 NULL
22280 };
22281
22282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22286
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22291 return resultobj;
22292 fail:
22293 return NULL;
22294 }
22295
22296
22297 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22298 PyObject *obj;
22299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22300 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22301 Py_INCREF(obj);
22302 return Py_BuildValue((char *)"");
22303 }
22304 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj = NULL;
22306 int arg1 = (int) 0 ;
22307 wxPaletteChangedEvent *result;
22308 PyObject * obj0 = 0 ;
22309 char *kwnames[] = {
22310 (char *) "id", NULL
22311 };
22312
22313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22314 if (obj0) {
22315 {
22316 arg1 = static_cast<int >(SWIG_As_int(obj0));
22317 if (SWIG_arg_fail(1)) SWIG_fail;
22318 }
22319 }
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22323
22324 wxPyEndAllowThreads(__tstate);
22325 if (PyErr_Occurred()) SWIG_fail;
22326 }
22327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22335 PyObject *resultobj = NULL;
22336 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22337 wxWindow *arg2 = (wxWindow *) 0 ;
22338 PyObject * obj0 = 0 ;
22339 PyObject * obj1 = 0 ;
22340 char *kwnames[] = {
22341 (char *) "self",(char *) "win", NULL
22342 };
22343
22344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22346 if (SWIG_arg_fail(1)) SWIG_fail;
22347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22348 if (SWIG_arg_fail(2)) SWIG_fail;
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 (arg1)->SetChangedWindow(arg2);
22352
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 Py_INCREF(Py_None); resultobj = Py_None;
22357 return resultobj;
22358 fail:
22359 return NULL;
22360 }
22361
22362
22363 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22364 PyObject *resultobj = NULL;
22365 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22366 wxWindow *result;
22367 PyObject * obj0 = 0 ;
22368 char *kwnames[] = {
22369 (char *) "self", NULL
22370 };
22371
22372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22374 if (SWIG_arg_fail(1)) SWIG_fail;
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 result = (wxWindow *)(arg1)->GetChangedWindow();
22378
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 {
22383 resultobj = wxPyMake_wxObject(result, (bool)0);
22384 }
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22392 PyObject *obj;
22393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22394 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22395 Py_INCREF(obj);
22396 return Py_BuildValue((char *)"");
22397 }
22398 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22399 PyObject *resultobj = NULL;
22400 int arg1 = (int) 0 ;
22401 wxQueryNewPaletteEvent *result;
22402 PyObject * obj0 = 0 ;
22403 char *kwnames[] = {
22404 (char *) "winid", NULL
22405 };
22406
22407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22408 if (obj0) {
22409 {
22410 arg1 = static_cast<int >(SWIG_As_int(obj0));
22411 if (SWIG_arg_fail(1)) SWIG_fail;
22412 }
22413 }
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj = NULL;
22430 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22431 bool arg2 ;
22432 PyObject * obj0 = 0 ;
22433 PyObject * obj1 = 0 ;
22434 char *kwnames[] = {
22435 (char *) "self",(char *) "realized", NULL
22436 };
22437
22438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22440 if (SWIG_arg_fail(1)) SWIG_fail;
22441 {
22442 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22443 if (SWIG_arg_fail(2)) SWIG_fail;
22444 }
22445 {
22446 PyThreadState* __tstate = wxPyBeginAllowThreads();
22447 (arg1)->SetPaletteRealized(arg2);
22448
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 Py_INCREF(Py_None); resultobj = Py_None;
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22460 PyObject *resultobj = NULL;
22461 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22462 bool result;
22463 PyObject * obj0 = 0 ;
22464 char *kwnames[] = {
22465 (char *) "self", NULL
22466 };
22467
22468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22470 if (SWIG_arg_fail(1)) SWIG_fail;
22471 {
22472 PyThreadState* __tstate = wxPyBeginAllowThreads();
22473 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22474
22475 wxPyEndAllowThreads(__tstate);
22476 if (PyErr_Occurred()) SWIG_fail;
22477 }
22478 {
22479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22480 }
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22488 PyObject *obj;
22489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22490 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22491 Py_INCREF(obj);
22492 return Py_BuildValue((char *)"");
22493 }
22494 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22495 PyObject *resultobj = NULL;
22496 wxNavigationKeyEvent *result;
22497 char *kwnames[] = {
22498 NULL
22499 };
22500
22501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22502 {
22503 PyThreadState* __tstate = wxPyBeginAllowThreads();
22504 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22505
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22517 PyObject *resultobj = NULL;
22518 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22519 bool result;
22520 PyObject * obj0 = 0 ;
22521 char *kwnames[] = {
22522 (char *) "self", NULL
22523 };
22524
22525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22527 if (SWIG_arg_fail(1)) SWIG_fail;
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22531
22532 wxPyEndAllowThreads(__tstate);
22533 if (PyErr_Occurred()) SWIG_fail;
22534 }
22535 {
22536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22537 }
22538 return resultobj;
22539 fail:
22540 return NULL;
22541 }
22542
22543
22544 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22545 PyObject *resultobj = NULL;
22546 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22547 bool arg2 ;
22548 PyObject * obj0 = 0 ;
22549 PyObject * obj1 = 0 ;
22550 char *kwnames[] = {
22551 (char *) "self",(char *) "forward", NULL
22552 };
22553
22554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22556 if (SWIG_arg_fail(1)) SWIG_fail;
22557 {
22558 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22559 if (SWIG_arg_fail(2)) SWIG_fail;
22560 }
22561 {
22562 PyThreadState* __tstate = wxPyBeginAllowThreads();
22563 (arg1)->SetDirection(arg2);
22564
22565 wxPyEndAllowThreads(__tstate);
22566 if (PyErr_Occurred()) SWIG_fail;
22567 }
22568 Py_INCREF(Py_None); resultobj = Py_None;
22569 return resultobj;
22570 fail:
22571 return NULL;
22572 }
22573
22574
22575 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22576 PyObject *resultobj = NULL;
22577 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22578 bool result;
22579 PyObject * obj0 = 0 ;
22580 char *kwnames[] = {
22581 (char *) "self", NULL
22582 };
22583
22584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22586 if (SWIG_arg_fail(1)) SWIG_fail;
22587 {
22588 PyThreadState* __tstate = wxPyBeginAllowThreads();
22589 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22590
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 {
22595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22596 }
22597 return resultobj;
22598 fail:
22599 return NULL;
22600 }
22601
22602
22603 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22604 PyObject *resultobj = NULL;
22605 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22606 bool arg2 ;
22607 PyObject * obj0 = 0 ;
22608 PyObject * obj1 = 0 ;
22609 char *kwnames[] = {
22610 (char *) "self",(char *) "ischange", NULL
22611 };
22612
22613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22615 if (SWIG_arg_fail(1)) SWIG_fail;
22616 {
22617 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22618 if (SWIG_arg_fail(2)) SWIG_fail;
22619 }
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 (arg1)->SetWindowChange(arg2);
22623
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 Py_INCREF(Py_None); resultobj = Py_None;
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22635 PyObject *resultobj = NULL;
22636 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22637 bool result;
22638 PyObject * obj0 = 0 ;
22639 char *kwnames[] = {
22640 (char *) "self", NULL
22641 };
22642
22643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22645 if (SWIG_arg_fail(1)) SWIG_fail;
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22649
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 {
22654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22655 }
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22663 PyObject *resultobj = NULL;
22664 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22665 bool arg2 ;
22666 PyObject * obj0 = 0 ;
22667 PyObject * obj1 = 0 ;
22668 char *kwnames[] = {
22669 (char *) "self",(char *) "bIs", NULL
22670 };
22671
22672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22674 if (SWIG_arg_fail(1)) SWIG_fail;
22675 {
22676 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22677 if (SWIG_arg_fail(2)) SWIG_fail;
22678 }
22679 {
22680 PyThreadState* __tstate = wxPyBeginAllowThreads();
22681 (arg1)->SetFromTab(arg2);
22682
22683 wxPyEndAllowThreads(__tstate);
22684 if (PyErr_Occurred()) SWIG_fail;
22685 }
22686 Py_INCREF(Py_None); resultobj = Py_None;
22687 return resultobj;
22688 fail:
22689 return NULL;
22690 }
22691
22692
22693 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22694 PyObject *resultobj = NULL;
22695 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22696 long arg2 ;
22697 PyObject * obj0 = 0 ;
22698 PyObject * obj1 = 0 ;
22699 char *kwnames[] = {
22700 (char *) "self",(char *) "flags", NULL
22701 };
22702
22703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22705 if (SWIG_arg_fail(1)) SWIG_fail;
22706 {
22707 arg2 = static_cast<long >(SWIG_As_long(obj1));
22708 if (SWIG_arg_fail(2)) SWIG_fail;
22709 }
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 (arg1)->SetFlags(arg2);
22713
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 Py_INCREF(Py_None); resultobj = Py_None;
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22725 PyObject *resultobj = NULL;
22726 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22727 wxWindow *result;
22728 PyObject * obj0 = 0 ;
22729 char *kwnames[] = {
22730 (char *) "self", NULL
22731 };
22732
22733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22735 if (SWIG_arg_fail(1)) SWIG_fail;
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22739
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 {
22744 resultobj = wxPyMake_wxObject(result, (bool)0);
22745 }
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22753 PyObject *resultobj = NULL;
22754 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22755 wxWindow *arg2 = (wxWindow *) 0 ;
22756 PyObject * obj0 = 0 ;
22757 PyObject * obj1 = 0 ;
22758 char *kwnames[] = {
22759 (char *) "self",(char *) "win", NULL
22760 };
22761
22762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22764 if (SWIG_arg_fail(1)) SWIG_fail;
22765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22766 if (SWIG_arg_fail(2)) SWIG_fail;
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 (arg1)->SetCurrentFocus(arg2);
22770
22771 wxPyEndAllowThreads(__tstate);
22772 if (PyErr_Occurred()) SWIG_fail;
22773 }
22774 Py_INCREF(Py_None); resultobj = Py_None;
22775 return resultobj;
22776 fail:
22777 return NULL;
22778 }
22779
22780
22781 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22782 PyObject *obj;
22783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22784 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22785 Py_INCREF(obj);
22786 return Py_BuildValue((char *)"");
22787 }
22788 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22789 PyObject *resultobj = NULL;
22790 wxWindow *arg1 = (wxWindow *) NULL ;
22791 wxWindowCreateEvent *result;
22792 PyObject * obj0 = 0 ;
22793 char *kwnames[] = {
22794 (char *) "win", NULL
22795 };
22796
22797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22798 if (obj0) {
22799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22800 if (SWIG_arg_fail(1)) SWIG_fail;
22801 }
22802 {
22803 PyThreadState* __tstate = wxPyBeginAllowThreads();
22804 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22805
22806 wxPyEndAllowThreads(__tstate);
22807 if (PyErr_Occurred()) SWIG_fail;
22808 }
22809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22810 return resultobj;
22811 fail:
22812 return NULL;
22813 }
22814
22815
22816 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22817 PyObject *resultobj = NULL;
22818 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22819 wxWindow *result;
22820 PyObject * obj0 = 0 ;
22821 char *kwnames[] = {
22822 (char *) "self", NULL
22823 };
22824
22825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22827 if (SWIG_arg_fail(1)) SWIG_fail;
22828 {
22829 PyThreadState* __tstate = wxPyBeginAllowThreads();
22830 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22831
22832 wxPyEndAllowThreads(__tstate);
22833 if (PyErr_Occurred()) SWIG_fail;
22834 }
22835 {
22836 resultobj = wxPyMake_wxObject(result, (bool)0);
22837 }
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22845 PyObject *obj;
22846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22847 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22848 Py_INCREF(obj);
22849 return Py_BuildValue((char *)"");
22850 }
22851 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22852 PyObject *resultobj = NULL;
22853 wxWindow *arg1 = (wxWindow *) NULL ;
22854 wxWindowDestroyEvent *result;
22855 PyObject * obj0 = 0 ;
22856 char *kwnames[] = {
22857 (char *) "win", NULL
22858 };
22859
22860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22861 if (obj0) {
22862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22863 if (SWIG_arg_fail(1)) SWIG_fail;
22864 }
22865 {
22866 PyThreadState* __tstate = wxPyBeginAllowThreads();
22867 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22868
22869 wxPyEndAllowThreads(__tstate);
22870 if (PyErr_Occurred()) SWIG_fail;
22871 }
22872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22880 PyObject *resultobj = NULL;
22881 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22882 wxWindow *result;
22883 PyObject * obj0 = 0 ;
22884 char *kwnames[] = {
22885 (char *) "self", NULL
22886 };
22887
22888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22890 if (SWIG_arg_fail(1)) SWIG_fail;
22891 {
22892 PyThreadState* __tstate = wxPyBeginAllowThreads();
22893 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22894
22895 wxPyEndAllowThreads(__tstate);
22896 if (PyErr_Occurred()) SWIG_fail;
22897 }
22898 {
22899 resultobj = wxPyMake_wxObject(result, (bool)0);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22908 PyObject *obj;
22909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22910 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22911 Py_INCREF(obj);
22912 return Py_BuildValue((char *)"");
22913 }
22914 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22915 PyObject *resultobj = NULL;
22916 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22917 int arg2 = (int) 0 ;
22918 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22919 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22920 wxContextMenuEvent *result;
22921 wxPoint temp3 ;
22922 PyObject * obj0 = 0 ;
22923 PyObject * obj1 = 0 ;
22924 PyObject * obj2 = 0 ;
22925 char *kwnames[] = {
22926 (char *) "type",(char *) "winid",(char *) "pt", NULL
22927 };
22928
22929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22930 if (obj0) {
22931 {
22932 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22933 if (SWIG_arg_fail(1)) SWIG_fail;
22934 }
22935 }
22936 if (obj1) {
22937 {
22938 arg2 = static_cast<int >(SWIG_As_int(obj1));
22939 if (SWIG_arg_fail(2)) SWIG_fail;
22940 }
22941 }
22942 if (obj2) {
22943 {
22944 arg3 = &temp3;
22945 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22946 }
22947 }
22948 {
22949 PyThreadState* __tstate = wxPyBeginAllowThreads();
22950 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22951
22952 wxPyEndAllowThreads(__tstate);
22953 if (PyErr_Occurred()) SWIG_fail;
22954 }
22955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22956 return resultobj;
22957 fail:
22958 return NULL;
22959 }
22960
22961
22962 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22963 PyObject *resultobj = NULL;
22964 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22965 wxPoint *result;
22966 PyObject * obj0 = 0 ;
22967 char *kwnames[] = {
22968 (char *) "self", NULL
22969 };
22970
22971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22973 if (SWIG_arg_fail(1)) SWIG_fail;
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 {
22977 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22978 result = (wxPoint *) &_result_ref;
22979 }
22980
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22992 PyObject *resultobj = NULL;
22993 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22994 wxPoint *arg2 = 0 ;
22995 wxPoint temp2 ;
22996 PyObject * obj0 = 0 ;
22997 PyObject * obj1 = 0 ;
22998 char *kwnames[] = {
22999 (char *) "self",(char *) "pos", NULL
23000 };
23001
23002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
23003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
23004 if (SWIG_arg_fail(1)) SWIG_fail;
23005 {
23006 arg2 = &temp2;
23007 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23008 }
23009 {
23010 PyThreadState* __tstate = wxPyBeginAllowThreads();
23011 (arg1)->SetPosition((wxPoint const &)*arg2);
23012
23013 wxPyEndAllowThreads(__tstate);
23014 if (PyErr_Occurred()) SWIG_fail;
23015 }
23016 Py_INCREF(Py_None); resultobj = Py_None;
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
23024 PyObject *obj;
23025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23026 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
23027 Py_INCREF(obj);
23028 return Py_BuildValue((char *)"");
23029 }
23030 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23031 PyObject *resultobj = NULL;
23032 wxIdleEvent *result;
23033 char *kwnames[] = {
23034 NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
23038 {
23039 PyThreadState* __tstate = wxPyBeginAllowThreads();
23040 result = (wxIdleEvent *)new wxIdleEvent();
23041
23042 wxPyEndAllowThreads(__tstate);
23043 if (PyErr_Occurred()) SWIG_fail;
23044 }
23045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
23046 return resultobj;
23047 fail:
23048 return NULL;
23049 }
23050
23051
23052 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
23053 PyObject *resultobj = NULL;
23054 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
23055 bool arg2 = (bool) true ;
23056 PyObject * obj0 = 0 ;
23057 PyObject * obj1 = 0 ;
23058 char *kwnames[] = {
23059 (char *) "self",(char *) "needMore", NULL
23060 };
23061
23062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
23063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23064 if (SWIG_arg_fail(1)) SWIG_fail;
23065 if (obj1) {
23066 {
23067 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23068 if (SWIG_arg_fail(2)) SWIG_fail;
23069 }
23070 }
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 (arg1)->RequestMore(arg2);
23074
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 Py_INCREF(Py_None); resultobj = Py_None;
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
23086 PyObject *resultobj = NULL;
23087 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
23088 bool result;
23089 PyObject * obj0 = 0 ;
23090 char *kwnames[] = {
23091 (char *) "self", NULL
23092 };
23093
23094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
23095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23096 if (SWIG_arg_fail(1)) SWIG_fail;
23097 {
23098 PyThreadState* __tstate = wxPyBeginAllowThreads();
23099 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
23100
23101 wxPyEndAllowThreads(__tstate);
23102 if (PyErr_Occurred()) SWIG_fail;
23103 }
23104 {
23105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23106 }
23107 return resultobj;
23108 fail:
23109 return NULL;
23110 }
23111
23112
23113 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
23114 PyObject *resultobj = NULL;
23115 wxIdleMode arg1 ;
23116 PyObject * obj0 = 0 ;
23117 char *kwnames[] = {
23118 (char *) "mode", NULL
23119 };
23120
23121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
23122 {
23123 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
23124 if (SWIG_arg_fail(1)) SWIG_fail;
23125 }
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 wxIdleEvent::SetMode(arg1);
23129
23130 wxPyEndAllowThreads(__tstate);
23131 if (PyErr_Occurred()) SWIG_fail;
23132 }
23133 Py_INCREF(Py_None); resultobj = Py_None;
23134 return resultobj;
23135 fail:
23136 return NULL;
23137 }
23138
23139
23140 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
23141 PyObject *resultobj = NULL;
23142 wxIdleMode result;
23143 char *kwnames[] = {
23144 NULL
23145 };
23146
23147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
23148 {
23149 PyThreadState* __tstate = wxPyBeginAllowThreads();
23150 result = (wxIdleMode)wxIdleEvent::GetMode();
23151
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 resultobj = SWIG_From_int((result));
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
23163 PyObject *resultobj = NULL;
23164 wxWindow *arg1 = (wxWindow *) 0 ;
23165 bool result;
23166 PyObject * obj0 = 0 ;
23167 char *kwnames[] = {
23168 (char *) "win", NULL
23169 };
23170
23171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23173 if (SWIG_arg_fail(1)) SWIG_fail;
23174 {
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 result = (bool)wxIdleEvent::CanSend(arg1);
23177
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 {
23182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23183 }
23184 return resultobj;
23185 fail:
23186 return NULL;
23187 }
23188
23189
23190 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23191 PyObject *obj;
23192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23193 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23194 Py_INCREF(obj);
23195 return Py_BuildValue((char *)"");
23196 }
23197 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23198 PyObject *resultobj = NULL;
23199 int arg1 = (int) 0 ;
23200 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23201 wxPyEvent *result;
23202 PyObject * obj0 = 0 ;
23203 PyObject * obj1 = 0 ;
23204 char *kwnames[] = {
23205 (char *) "winid",(char *) "eventType", NULL
23206 };
23207
23208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23209 if (obj0) {
23210 {
23211 arg1 = static_cast<int >(SWIG_As_int(obj0));
23212 if (SWIG_arg_fail(1)) SWIG_fail;
23213 }
23214 }
23215 if (obj1) {
23216 {
23217 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23218 if (SWIG_arg_fail(2)) SWIG_fail;
23219 }
23220 }
23221 {
23222 PyThreadState* __tstate = wxPyBeginAllowThreads();
23223 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23224
23225 wxPyEndAllowThreads(__tstate);
23226 if (PyErr_Occurred()) SWIG_fail;
23227 }
23228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23236 PyObject *resultobj = NULL;
23237 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23238 PyObject * obj0 = 0 ;
23239 char *kwnames[] = {
23240 (char *) "self", NULL
23241 };
23242
23243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23245 if (SWIG_arg_fail(1)) SWIG_fail;
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 delete arg1;
23249
23250 wxPyEndAllowThreads(__tstate);
23251 if (PyErr_Occurred()) SWIG_fail;
23252 }
23253 Py_INCREF(Py_None); resultobj = Py_None;
23254 return resultobj;
23255 fail:
23256 return NULL;
23257 }
23258
23259
23260 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23261 PyObject *resultobj = NULL;
23262 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23263 PyObject *arg2 = (PyObject *) 0 ;
23264 PyObject * obj0 = 0 ;
23265 PyObject * obj1 = 0 ;
23266 char *kwnames[] = {
23267 (char *) "self",(char *) "self", NULL
23268 };
23269
23270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23272 if (SWIG_arg_fail(1)) SWIG_fail;
23273 arg2 = obj1;
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 (arg1)->SetSelf(arg2);
23277
23278 wxPyEndAllowThreads(__tstate);
23279 if (PyErr_Occurred()) SWIG_fail;
23280 }
23281 Py_INCREF(Py_None); resultobj = Py_None;
23282 return resultobj;
23283 fail:
23284 return NULL;
23285 }
23286
23287
23288 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23289 PyObject *resultobj = NULL;
23290 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23291 PyObject *result;
23292 PyObject * obj0 = 0 ;
23293 char *kwnames[] = {
23294 (char *) "self", NULL
23295 };
23296
23297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23299 if (SWIG_arg_fail(1)) SWIG_fail;
23300 {
23301 PyThreadState* __tstate = wxPyBeginAllowThreads();
23302 result = (PyObject *)(arg1)->GetSelf();
23303
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 resultobj = result;
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23315 PyObject *obj;
23316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23317 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23318 Py_INCREF(obj);
23319 return Py_BuildValue((char *)"");
23320 }
23321 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23322 PyObject *resultobj = NULL;
23323 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23324 int arg2 = (int) 0 ;
23325 wxPyCommandEvent *result;
23326 PyObject * obj0 = 0 ;
23327 PyObject * obj1 = 0 ;
23328 char *kwnames[] = {
23329 (char *) "eventType",(char *) "id", NULL
23330 };
23331
23332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23333 if (obj0) {
23334 {
23335 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23336 if (SWIG_arg_fail(1)) SWIG_fail;
23337 }
23338 }
23339 if (obj1) {
23340 {
23341 arg2 = static_cast<int >(SWIG_As_int(obj1));
23342 if (SWIG_arg_fail(2)) SWIG_fail;
23343 }
23344 }
23345 {
23346 PyThreadState* __tstate = wxPyBeginAllowThreads();
23347 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23348
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = NULL;
23361 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23362 PyObject * obj0 = 0 ;
23363 char *kwnames[] = {
23364 (char *) "self", NULL
23365 };
23366
23367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23369 if (SWIG_arg_fail(1)) SWIG_fail;
23370 {
23371 PyThreadState* __tstate = wxPyBeginAllowThreads();
23372 delete arg1;
23373
23374 wxPyEndAllowThreads(__tstate);
23375 if (PyErr_Occurred()) SWIG_fail;
23376 }
23377 Py_INCREF(Py_None); resultobj = Py_None;
23378 return resultobj;
23379 fail:
23380 return NULL;
23381 }
23382
23383
23384 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23385 PyObject *resultobj = NULL;
23386 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23387 PyObject *arg2 = (PyObject *) 0 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "self",(char *) "self", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(1)) SWIG_fail;
23397 arg2 = obj1;
23398 {
23399 PyThreadState* __tstate = wxPyBeginAllowThreads();
23400 (arg1)->SetSelf(arg2);
23401
23402 wxPyEndAllowThreads(__tstate);
23403 if (PyErr_Occurred()) SWIG_fail;
23404 }
23405 Py_INCREF(Py_None); resultobj = Py_None;
23406 return resultobj;
23407 fail:
23408 return NULL;
23409 }
23410
23411
23412 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23413 PyObject *resultobj = NULL;
23414 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23415 PyObject *result;
23416 PyObject * obj0 = 0 ;
23417 char *kwnames[] = {
23418 (char *) "self", NULL
23419 };
23420
23421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23423 if (SWIG_arg_fail(1)) SWIG_fail;
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 result = (PyObject *)(arg1)->GetSelf();
23427
23428 wxPyEndAllowThreads(__tstate);
23429 if (PyErr_Occurred()) SWIG_fail;
23430 }
23431 resultobj = result;
23432 return resultobj;
23433 fail:
23434 return NULL;
23435 }
23436
23437
23438 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23439 PyObject *obj;
23440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23441 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23442 Py_INCREF(obj);
23443 return Py_BuildValue((char *)"");
23444 }
23445 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj = NULL;
23447 wxWindow *arg1 = (wxWindow *) 0 ;
23448 wxDateTime *arg2 = 0 ;
23449 wxEventType arg3 ;
23450 wxDateEvent *result;
23451 PyObject * obj0 = 0 ;
23452 PyObject * obj1 = 0 ;
23453 PyObject * obj2 = 0 ;
23454 char *kwnames[] = {
23455 (char *) "win",(char *) "dt",(char *) "type", NULL
23456 };
23457
23458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23460 if (SWIG_arg_fail(1)) SWIG_fail;
23461 {
23462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23463 if (SWIG_arg_fail(2)) SWIG_fail;
23464 if (arg2 == NULL) {
23465 SWIG_null_ref("wxDateTime");
23466 }
23467 if (SWIG_arg_fail(2)) SWIG_fail;
23468 }
23469 {
23470 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23471 if (SWIG_arg_fail(3)) SWIG_fail;
23472 }
23473 {
23474 PyThreadState* __tstate = wxPyBeginAllowThreads();
23475 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23476
23477 wxPyEndAllowThreads(__tstate);
23478 if (PyErr_Occurred()) SWIG_fail;
23479 }
23480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23481 return resultobj;
23482 fail:
23483 return NULL;
23484 }
23485
23486
23487 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23488 PyObject *resultobj = NULL;
23489 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23490 wxDateTime *result;
23491 PyObject * obj0 = 0 ;
23492 char *kwnames[] = {
23493 (char *) "self", NULL
23494 };
23495
23496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23498 if (SWIG_arg_fail(1)) SWIG_fail;
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 {
23502 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23503 result = (wxDateTime *) &_result_ref;
23504 }
23505
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23517 PyObject *resultobj = NULL;
23518 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23519 wxDateTime *arg2 = 0 ;
23520 PyObject * obj0 = 0 ;
23521 PyObject * obj1 = 0 ;
23522 char *kwnames[] = {
23523 (char *) "self",(char *) "date", NULL
23524 };
23525
23526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23528 if (SWIG_arg_fail(1)) SWIG_fail;
23529 {
23530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23531 if (SWIG_arg_fail(2)) SWIG_fail;
23532 if (arg2 == NULL) {
23533 SWIG_null_ref("wxDateTime");
23534 }
23535 if (SWIG_arg_fail(2)) SWIG_fail;
23536 }
23537 {
23538 PyThreadState* __tstate = wxPyBeginAllowThreads();
23539 (arg1)->SetDate((wxDateTime const &)*arg2);
23540
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 Py_INCREF(Py_None); resultobj = Py_None;
23545 return resultobj;
23546 fail:
23547 return NULL;
23548 }
23549
23550
23551 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23552 PyObject *obj;
23553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23554 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23555 Py_INCREF(obj);
23556 return Py_BuildValue((char *)"");
23557 }
23558 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23559 PyObject *resultobj = NULL;
23560 wxPyApp *result;
23561 char *kwnames[] = {
23562 NULL
23563 };
23564
23565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23566 {
23567 PyThreadState* __tstate = wxPyBeginAllowThreads();
23568 result = (wxPyApp *)new_wxPyApp();
23569
23570 wxPyEndAllowThreads(__tstate);
23571 if (PyErr_Occurred()) SWIG_fail;
23572 }
23573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23581 PyObject *resultobj = NULL;
23582 wxPyApp *arg1 = (wxPyApp *) 0 ;
23583 PyObject * obj0 = 0 ;
23584 char *kwnames[] = {
23585 (char *) "self", NULL
23586 };
23587
23588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23590 if (SWIG_arg_fail(1)) SWIG_fail;
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 delete arg1;
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 Py_INCREF(Py_None); resultobj = Py_None;
23599 return resultobj;
23600 fail:
23601 return NULL;
23602 }
23603
23604
23605 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23606 PyObject *resultobj = NULL;
23607 wxPyApp *arg1 = (wxPyApp *) 0 ;
23608 PyObject *arg2 = (PyObject *) 0 ;
23609 PyObject *arg3 = (PyObject *) 0 ;
23610 bool arg4 ;
23611 PyObject * obj0 = 0 ;
23612 PyObject * obj1 = 0 ;
23613 PyObject * obj2 = 0 ;
23614 PyObject * obj3 = 0 ;
23615 char *kwnames[] = {
23616 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23617 };
23618
23619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23621 if (SWIG_arg_fail(1)) SWIG_fail;
23622 arg2 = obj1;
23623 arg3 = obj2;
23624 {
23625 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23626 if (SWIG_arg_fail(4)) SWIG_fail;
23627 }
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23631
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 Py_INCREF(Py_None); resultobj = Py_None;
23636 return resultobj;
23637 fail:
23638 return NULL;
23639 }
23640
23641
23642 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23643 PyObject *resultobj = NULL;
23644 wxPyApp *arg1 = (wxPyApp *) 0 ;
23645 wxString result;
23646 PyObject * obj0 = 0 ;
23647 char *kwnames[] = {
23648 (char *) "self", NULL
23649 };
23650
23651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23653 if (SWIG_arg_fail(1)) SWIG_fail;
23654 {
23655 PyThreadState* __tstate = wxPyBeginAllowThreads();
23656 result = ((wxPyApp const *)arg1)->GetAppName();
23657
23658 wxPyEndAllowThreads(__tstate);
23659 if (PyErr_Occurred()) SWIG_fail;
23660 }
23661 {
23662 #if wxUSE_UNICODE
23663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23664 #else
23665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23666 #endif
23667 }
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23675 PyObject *resultobj = NULL;
23676 wxPyApp *arg1 = (wxPyApp *) 0 ;
23677 wxString *arg2 = 0 ;
23678 bool temp2 = false ;
23679 PyObject * obj0 = 0 ;
23680 PyObject * obj1 = 0 ;
23681 char *kwnames[] = {
23682 (char *) "self",(char *) "name", NULL
23683 };
23684
23685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23687 if (SWIG_arg_fail(1)) SWIG_fail;
23688 {
23689 arg2 = wxString_in_helper(obj1);
23690 if (arg2 == NULL) SWIG_fail;
23691 temp2 = true;
23692 }
23693 {
23694 PyThreadState* __tstate = wxPyBeginAllowThreads();
23695 (arg1)->SetAppName((wxString const &)*arg2);
23696
23697 wxPyEndAllowThreads(__tstate);
23698 if (PyErr_Occurred()) SWIG_fail;
23699 }
23700 Py_INCREF(Py_None); resultobj = Py_None;
23701 {
23702 if (temp2)
23703 delete arg2;
23704 }
23705 return resultobj;
23706 fail:
23707 {
23708 if (temp2)
23709 delete arg2;
23710 }
23711 return NULL;
23712 }
23713
23714
23715 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23716 PyObject *resultobj = NULL;
23717 wxPyApp *arg1 = (wxPyApp *) 0 ;
23718 wxString result;
23719 PyObject * obj0 = 0 ;
23720 char *kwnames[] = {
23721 (char *) "self", NULL
23722 };
23723
23724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23726 if (SWIG_arg_fail(1)) SWIG_fail;
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = ((wxPyApp const *)arg1)->GetClassName();
23730
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 {
23735 #if wxUSE_UNICODE
23736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23737 #else
23738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23739 #endif
23740 }
23741 return resultobj;
23742 fail:
23743 return NULL;
23744 }
23745
23746
23747 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23748 PyObject *resultobj = NULL;
23749 wxPyApp *arg1 = (wxPyApp *) 0 ;
23750 wxString *arg2 = 0 ;
23751 bool temp2 = false ;
23752 PyObject * obj0 = 0 ;
23753 PyObject * obj1 = 0 ;
23754 char *kwnames[] = {
23755 (char *) "self",(char *) "name", NULL
23756 };
23757
23758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23760 if (SWIG_arg_fail(1)) SWIG_fail;
23761 {
23762 arg2 = wxString_in_helper(obj1);
23763 if (arg2 == NULL) SWIG_fail;
23764 temp2 = true;
23765 }
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 (arg1)->SetClassName((wxString const &)*arg2);
23769
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 Py_INCREF(Py_None); resultobj = Py_None;
23774 {
23775 if (temp2)
23776 delete arg2;
23777 }
23778 return resultobj;
23779 fail:
23780 {
23781 if (temp2)
23782 delete arg2;
23783 }
23784 return NULL;
23785 }
23786
23787
23788 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23789 PyObject *resultobj = NULL;
23790 wxPyApp *arg1 = (wxPyApp *) 0 ;
23791 wxString *result;
23792 PyObject * obj0 = 0 ;
23793 char *kwnames[] = {
23794 (char *) "self", NULL
23795 };
23796
23797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23799 if (SWIG_arg_fail(1)) SWIG_fail;
23800 {
23801 PyThreadState* __tstate = wxPyBeginAllowThreads();
23802 {
23803 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23804 result = (wxString *) &_result_ref;
23805 }
23806
23807 wxPyEndAllowThreads(__tstate);
23808 if (PyErr_Occurred()) SWIG_fail;
23809 }
23810 {
23811 #if wxUSE_UNICODE
23812 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23813 #else
23814 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23815 #endif
23816 }
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj = NULL;
23825 wxPyApp *arg1 = (wxPyApp *) 0 ;
23826 wxString *arg2 = 0 ;
23827 bool temp2 = false ;
23828 PyObject * obj0 = 0 ;
23829 PyObject * obj1 = 0 ;
23830 char *kwnames[] = {
23831 (char *) "self",(char *) "name", NULL
23832 };
23833
23834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23836 if (SWIG_arg_fail(1)) SWIG_fail;
23837 {
23838 arg2 = wxString_in_helper(obj1);
23839 if (arg2 == NULL) SWIG_fail;
23840 temp2 = true;
23841 }
23842 {
23843 PyThreadState* __tstate = wxPyBeginAllowThreads();
23844 (arg1)->SetVendorName((wxString const &)*arg2);
23845
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 Py_INCREF(Py_None); resultobj = Py_None;
23850 {
23851 if (temp2)
23852 delete arg2;
23853 }
23854 return resultobj;
23855 fail:
23856 {
23857 if (temp2)
23858 delete arg2;
23859 }
23860 return NULL;
23861 }
23862
23863
23864 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj = NULL;
23866 wxPyApp *arg1 = (wxPyApp *) 0 ;
23867 wxAppTraits *result;
23868 PyObject * obj0 = 0 ;
23869 char *kwnames[] = {
23870 (char *) "self", NULL
23871 };
23872
23873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23875 if (SWIG_arg_fail(1)) SWIG_fail;
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 result = (wxAppTraits *)(arg1)->GetTraits();
23879
23880 wxPyEndAllowThreads(__tstate);
23881 if (PyErr_Occurred()) SWIG_fail;
23882 }
23883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23884 return resultobj;
23885 fail:
23886 return NULL;
23887 }
23888
23889
23890 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23891 PyObject *resultobj = NULL;
23892 wxPyApp *arg1 = (wxPyApp *) 0 ;
23893 PyObject * obj0 = 0 ;
23894 char *kwnames[] = {
23895 (char *) "self", NULL
23896 };
23897
23898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23900 if (SWIG_arg_fail(1)) SWIG_fail;
23901 {
23902 PyThreadState* __tstate = wxPyBeginAllowThreads();
23903 (arg1)->ProcessPendingEvents();
23904
23905 wxPyEndAllowThreads(__tstate);
23906 if (PyErr_Occurred()) SWIG_fail;
23907 }
23908 Py_INCREF(Py_None); resultobj = Py_None;
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj = NULL;
23917 wxPyApp *arg1 = (wxPyApp *) 0 ;
23918 bool arg2 = (bool) false ;
23919 bool result;
23920 PyObject * obj0 = 0 ;
23921 PyObject * obj1 = 0 ;
23922 char *kwnames[] = {
23923 (char *) "self",(char *) "onlyIfNeeded", NULL
23924 };
23925
23926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23928 if (SWIG_arg_fail(1)) SWIG_fail;
23929 if (obj1) {
23930 {
23931 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23932 if (SWIG_arg_fail(2)) SWIG_fail;
23933 }
23934 }
23935 {
23936 PyThreadState* __tstate = wxPyBeginAllowThreads();
23937 result = (bool)(arg1)->Yield(arg2);
23938
23939 wxPyEndAllowThreads(__tstate);
23940 if (PyErr_Occurred()) SWIG_fail;
23941 }
23942 {
23943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23944 }
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj = NULL;
23953 wxPyApp *arg1 = (wxPyApp *) 0 ;
23954 PyObject * obj0 = 0 ;
23955 char *kwnames[] = {
23956 (char *) "self", NULL
23957 };
23958
23959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23961 if (SWIG_arg_fail(1)) SWIG_fail;
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 (arg1)->WakeUpIdle();
23965
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 Py_INCREF(Py_None); resultobj = Py_None;
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23977 PyObject *resultobj = NULL;
23978 bool result;
23979 char *kwnames[] = {
23980 NULL
23981 };
23982
23983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 result = (bool)wxPyApp::IsMainLoopRunning();
23987
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 {
23992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23993 }
23994 return resultobj;
23995 fail:
23996 return NULL;
23997 }
23998
23999
24000 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24001 PyObject *resultobj = NULL;
24002 wxPyApp *arg1 = (wxPyApp *) 0 ;
24003 int result;
24004 PyObject * obj0 = 0 ;
24005 char *kwnames[] = {
24006 (char *) "self", NULL
24007 };
24008
24009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
24010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24011 if (SWIG_arg_fail(1)) SWIG_fail;
24012 {
24013 PyThreadState* __tstate = wxPyBeginAllowThreads();
24014 result = (int)(arg1)->MainLoop();
24015
24016 wxPyEndAllowThreads(__tstate);
24017 if (PyErr_Occurred()) SWIG_fail;
24018 }
24019 {
24020 resultobj = SWIG_From_int(static_cast<int >(result));
24021 }
24022 return resultobj;
24023 fail:
24024 return NULL;
24025 }
24026
24027
24028 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24029 PyObject *resultobj = NULL;
24030 wxPyApp *arg1 = (wxPyApp *) 0 ;
24031 PyObject * obj0 = 0 ;
24032 char *kwnames[] = {
24033 (char *) "self", NULL
24034 };
24035
24036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
24037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24038 if (SWIG_arg_fail(1)) SWIG_fail;
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 (arg1)->Exit();
24042
24043 wxPyEndAllowThreads(__tstate);
24044 if (PyErr_Occurred()) SWIG_fail;
24045 }
24046 Py_INCREF(Py_None); resultobj = Py_None;
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24054 PyObject *resultobj = NULL;
24055 wxPyApp *arg1 = (wxPyApp *) 0 ;
24056 PyObject * obj0 = 0 ;
24057 char *kwnames[] = {
24058 (char *) "self", NULL
24059 };
24060
24061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
24062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24063 if (SWIG_arg_fail(1)) SWIG_fail;
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 (arg1)->ExitMainLoop();
24067
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 Py_INCREF(Py_None); resultobj = Py_None;
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24079 PyObject *resultobj = NULL;
24080 wxPyApp *arg1 = (wxPyApp *) 0 ;
24081 bool result;
24082 PyObject * obj0 = 0 ;
24083 char *kwnames[] = {
24084 (char *) "self", NULL
24085 };
24086
24087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
24088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24089 if (SWIG_arg_fail(1)) SWIG_fail;
24090 {
24091 PyThreadState* __tstate = wxPyBeginAllowThreads();
24092 result = (bool)(arg1)->Pending();
24093
24094 wxPyEndAllowThreads(__tstate);
24095 if (PyErr_Occurred()) SWIG_fail;
24096 }
24097 {
24098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24099 }
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24107 PyObject *resultobj = NULL;
24108 wxPyApp *arg1 = (wxPyApp *) 0 ;
24109 bool result;
24110 PyObject * obj0 = 0 ;
24111 char *kwnames[] = {
24112 (char *) "self", NULL
24113 };
24114
24115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
24116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24117 if (SWIG_arg_fail(1)) SWIG_fail;
24118 {
24119 PyThreadState* __tstate = wxPyBeginAllowThreads();
24120 result = (bool)(arg1)->Dispatch();
24121
24122 wxPyEndAllowThreads(__tstate);
24123 if (PyErr_Occurred()) SWIG_fail;
24124 }
24125 {
24126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24127 }
24128 return resultobj;
24129 fail:
24130 return NULL;
24131 }
24132
24133
24134 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24135 PyObject *resultobj = NULL;
24136 wxPyApp *arg1 = (wxPyApp *) 0 ;
24137 bool result;
24138 PyObject * obj0 = 0 ;
24139 char *kwnames[] = {
24140 (char *) "self", NULL
24141 };
24142
24143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
24144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24145 if (SWIG_arg_fail(1)) SWIG_fail;
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 result = (bool)(arg1)->ProcessIdle();
24149
24150 wxPyEndAllowThreads(__tstate);
24151 if (PyErr_Occurred()) SWIG_fail;
24152 }
24153 {
24154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24155 }
24156 return resultobj;
24157 fail:
24158 return NULL;
24159 }
24160
24161
24162 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
24163 PyObject *resultobj = NULL;
24164 wxPyApp *arg1 = (wxPyApp *) 0 ;
24165 wxWindow *arg2 = (wxWindow *) 0 ;
24166 wxIdleEvent *arg3 = 0 ;
24167 bool result;
24168 PyObject * obj0 = 0 ;
24169 PyObject * obj1 = 0 ;
24170 PyObject * obj2 = 0 ;
24171 char *kwnames[] = {
24172 (char *) "self",(char *) "win",(char *) "event", NULL
24173 };
24174
24175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
24176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24177 if (SWIG_arg_fail(1)) SWIG_fail;
24178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24179 if (SWIG_arg_fail(2)) SWIG_fail;
24180 {
24181 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24182 if (SWIG_arg_fail(3)) SWIG_fail;
24183 if (arg3 == NULL) {
24184 SWIG_null_ref("wxIdleEvent");
24185 }
24186 if (SWIG_arg_fail(3)) SWIG_fail;
24187 }
24188 {
24189 PyThreadState* __tstate = wxPyBeginAllowThreads();
24190 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24191
24192 wxPyEndAllowThreads(__tstate);
24193 if (PyErr_Occurred()) SWIG_fail;
24194 }
24195 {
24196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24197 }
24198 return resultobj;
24199 fail:
24200 return NULL;
24201 }
24202
24203
24204 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24205 PyObject *resultobj = NULL;
24206 wxPyApp *arg1 = (wxPyApp *) 0 ;
24207 bool result;
24208 PyObject * obj0 = 0 ;
24209 char *kwnames[] = {
24210 (char *) "self", NULL
24211 };
24212
24213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24215 if (SWIG_arg_fail(1)) SWIG_fail;
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 result = (bool)((wxPyApp const *)arg1)->IsActive();
24219
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 {
24224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24225 }
24226 return resultobj;
24227 fail:
24228 return NULL;
24229 }
24230
24231
24232 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24233 PyObject *resultobj = NULL;
24234 wxPyApp *arg1 = (wxPyApp *) 0 ;
24235 wxWindow *arg2 = (wxWindow *) 0 ;
24236 PyObject * obj0 = 0 ;
24237 PyObject * obj1 = 0 ;
24238 char *kwnames[] = {
24239 (char *) "self",(char *) "win", NULL
24240 };
24241
24242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24244 if (SWIG_arg_fail(1)) SWIG_fail;
24245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24246 if (SWIG_arg_fail(2)) SWIG_fail;
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 (arg1)->SetTopWindow(arg2);
24250
24251 wxPyEndAllowThreads(__tstate);
24252 if (PyErr_Occurred()) SWIG_fail;
24253 }
24254 Py_INCREF(Py_None); resultobj = Py_None;
24255 return resultobj;
24256 fail:
24257 return NULL;
24258 }
24259
24260
24261 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24262 PyObject *resultobj = NULL;
24263 wxPyApp *arg1 = (wxPyApp *) 0 ;
24264 wxWindow *result;
24265 PyObject * obj0 = 0 ;
24266 char *kwnames[] = {
24267 (char *) "self", NULL
24268 };
24269
24270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24272 if (SWIG_arg_fail(1)) SWIG_fail;
24273 {
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24276
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 {
24281 resultobj = wxPyMake_wxObject(result, (bool)0);
24282 }
24283 return resultobj;
24284 fail:
24285 return NULL;
24286 }
24287
24288
24289 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24290 PyObject *resultobj = NULL;
24291 wxPyApp *arg1 = (wxPyApp *) 0 ;
24292 bool arg2 ;
24293 PyObject * obj0 = 0 ;
24294 PyObject * obj1 = 0 ;
24295 char *kwnames[] = {
24296 (char *) "self",(char *) "flag", NULL
24297 };
24298
24299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24301 if (SWIG_arg_fail(1)) SWIG_fail;
24302 {
24303 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24304 if (SWIG_arg_fail(2)) SWIG_fail;
24305 }
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 (arg1)->SetExitOnFrameDelete(arg2);
24309
24310 wxPyEndAllowThreads(__tstate);
24311 if (PyErr_Occurred()) SWIG_fail;
24312 }
24313 Py_INCREF(Py_None); resultobj = Py_None;
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj = NULL;
24322 wxPyApp *arg1 = (wxPyApp *) 0 ;
24323 bool result;
24324 PyObject * obj0 = 0 ;
24325 char *kwnames[] = {
24326 (char *) "self", NULL
24327 };
24328
24329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24331 if (SWIG_arg_fail(1)) SWIG_fail;
24332 {
24333 PyThreadState* __tstate = wxPyBeginAllowThreads();
24334 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24335
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 {
24340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24341 }
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24349 PyObject *resultobj = NULL;
24350 wxPyApp *arg1 = (wxPyApp *) 0 ;
24351 bool arg2 ;
24352 PyObject * obj0 = 0 ;
24353 PyObject * obj1 = 0 ;
24354 char *kwnames[] = {
24355 (char *) "self",(char *) "flag", NULL
24356 };
24357
24358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24360 if (SWIG_arg_fail(1)) SWIG_fail;
24361 {
24362 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24363 if (SWIG_arg_fail(2)) SWIG_fail;
24364 }
24365 {
24366 PyThreadState* __tstate = wxPyBeginAllowThreads();
24367 (arg1)->SetUseBestVisual(arg2);
24368
24369 wxPyEndAllowThreads(__tstate);
24370 if (PyErr_Occurred()) SWIG_fail;
24371 }
24372 Py_INCREF(Py_None); resultobj = Py_None;
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24380 PyObject *resultobj = NULL;
24381 wxPyApp *arg1 = (wxPyApp *) 0 ;
24382 bool result;
24383 PyObject * obj0 = 0 ;
24384 char *kwnames[] = {
24385 (char *) "self", NULL
24386 };
24387
24388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24390 if (SWIG_arg_fail(1)) SWIG_fail;
24391 {
24392 PyThreadState* __tstate = wxPyBeginAllowThreads();
24393 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24394
24395 wxPyEndAllowThreads(__tstate);
24396 if (PyErr_Occurred()) SWIG_fail;
24397 }
24398 {
24399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24400 }
24401 return resultobj;
24402 fail:
24403 return NULL;
24404 }
24405
24406
24407 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24408 PyObject *resultobj = NULL;
24409 wxPyApp *arg1 = (wxPyApp *) 0 ;
24410 int arg2 ;
24411 PyObject * obj0 = 0 ;
24412 PyObject * obj1 = 0 ;
24413 char *kwnames[] = {
24414 (char *) "self",(char *) "mode", NULL
24415 };
24416
24417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24419 if (SWIG_arg_fail(1)) SWIG_fail;
24420 {
24421 arg2 = static_cast<int >(SWIG_As_int(obj1));
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 }
24424 {
24425 PyThreadState* __tstate = wxPyBeginAllowThreads();
24426 (arg1)->SetPrintMode(arg2);
24427
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 Py_INCREF(Py_None); resultobj = Py_None;
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj = NULL;
24440 wxPyApp *arg1 = (wxPyApp *) 0 ;
24441 int result;
24442 PyObject * obj0 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "self", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 {
24451 PyThreadState* __tstate = wxPyBeginAllowThreads();
24452 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24453
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 {
24458 resultobj = SWIG_From_int(static_cast<int >(result));
24459 }
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24467 PyObject *resultobj = NULL;
24468 wxPyApp *arg1 = (wxPyApp *) 0 ;
24469 int arg2 ;
24470 PyObject * obj0 = 0 ;
24471 PyObject * obj1 = 0 ;
24472 char *kwnames[] = {
24473 (char *) "self",(char *) "mode", NULL
24474 };
24475
24476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24478 if (SWIG_arg_fail(1)) SWIG_fail;
24479 {
24480 arg2 = static_cast<int >(SWIG_As_int(obj1));
24481 if (SWIG_arg_fail(2)) SWIG_fail;
24482 }
24483 {
24484 PyThreadState* __tstate = wxPyBeginAllowThreads();
24485 (arg1)->SetAssertMode(arg2);
24486
24487 wxPyEndAllowThreads(__tstate);
24488 if (PyErr_Occurred()) SWIG_fail;
24489 }
24490 Py_INCREF(Py_None); resultobj = Py_None;
24491 return resultobj;
24492 fail:
24493 return NULL;
24494 }
24495
24496
24497 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24498 PyObject *resultobj = NULL;
24499 wxPyApp *arg1 = (wxPyApp *) 0 ;
24500 int result;
24501 PyObject * obj0 = 0 ;
24502 char *kwnames[] = {
24503 (char *) "self", NULL
24504 };
24505
24506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(1)) SWIG_fail;
24509 {
24510 PyThreadState* __tstate = wxPyBeginAllowThreads();
24511 result = (int)(arg1)->GetAssertMode();
24512
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 {
24517 resultobj = SWIG_From_int(static_cast<int >(result));
24518 }
24519 return resultobj;
24520 fail:
24521 return NULL;
24522 }
24523
24524
24525 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24526 PyObject *resultobj = NULL;
24527 bool result;
24528 char *kwnames[] = {
24529 NULL
24530 };
24531
24532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24533 {
24534 PyThreadState* __tstate = wxPyBeginAllowThreads();
24535 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24536
24537 wxPyEndAllowThreads(__tstate);
24538 if (PyErr_Occurred()) SWIG_fail;
24539 }
24540 {
24541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24542 }
24543 return resultobj;
24544 fail:
24545 return NULL;
24546 }
24547
24548
24549 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj = NULL;
24551 long result;
24552 char *kwnames[] = {
24553 NULL
24554 };
24555
24556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (long)wxPyApp::GetMacAboutMenuItemId();
24560
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 {
24565 resultobj = SWIG_From_long(static_cast<long >(result));
24566 }
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24574 PyObject *resultobj = NULL;
24575 long result;
24576 char *kwnames[] = {
24577 NULL
24578 };
24579
24580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24581 {
24582 PyThreadState* __tstate = wxPyBeginAllowThreads();
24583 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24584
24585 wxPyEndAllowThreads(__tstate);
24586 if (PyErr_Occurred()) SWIG_fail;
24587 }
24588 {
24589 resultobj = SWIG_From_long(static_cast<long >(result));
24590 }
24591 return resultobj;
24592 fail:
24593 return NULL;
24594 }
24595
24596
24597 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24598 PyObject *resultobj = NULL;
24599 long result;
24600 char *kwnames[] = {
24601 NULL
24602 };
24603
24604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 result = (long)wxPyApp::GetMacExitMenuItemId();
24608
24609 wxPyEndAllowThreads(__tstate);
24610 if (PyErr_Occurred()) SWIG_fail;
24611 }
24612 {
24613 resultobj = SWIG_From_long(static_cast<long >(result));
24614 }
24615 return resultobj;
24616 fail:
24617 return NULL;
24618 }
24619
24620
24621 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24622 PyObject *resultobj = NULL;
24623 wxString result;
24624 char *kwnames[] = {
24625 NULL
24626 };
24627
24628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24629 {
24630 PyThreadState* __tstate = wxPyBeginAllowThreads();
24631 result = wxPyApp::GetMacHelpMenuTitleName();
24632
24633 wxPyEndAllowThreads(__tstate);
24634 if (PyErr_Occurred()) SWIG_fail;
24635 }
24636 {
24637 #if wxUSE_UNICODE
24638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24639 #else
24640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24641 #endif
24642 }
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24650 PyObject *resultobj = NULL;
24651 bool arg1 ;
24652 PyObject * obj0 = 0 ;
24653 char *kwnames[] = {
24654 (char *) "val", NULL
24655 };
24656
24657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24658 {
24659 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24660 if (SWIG_arg_fail(1)) SWIG_fail;
24661 }
24662 {
24663 PyThreadState* __tstate = wxPyBeginAllowThreads();
24664 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24665
24666 wxPyEndAllowThreads(__tstate);
24667 if (PyErr_Occurred()) SWIG_fail;
24668 }
24669 Py_INCREF(Py_None); resultobj = Py_None;
24670 return resultobj;
24671 fail:
24672 return NULL;
24673 }
24674
24675
24676 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24677 PyObject *resultobj = NULL;
24678 long arg1 ;
24679 PyObject * obj0 = 0 ;
24680 char *kwnames[] = {
24681 (char *) "val", NULL
24682 };
24683
24684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24685 {
24686 arg1 = static_cast<long >(SWIG_As_long(obj0));
24687 if (SWIG_arg_fail(1)) SWIG_fail;
24688 }
24689 {
24690 PyThreadState* __tstate = wxPyBeginAllowThreads();
24691 wxPyApp::SetMacAboutMenuItemId(arg1);
24692
24693 wxPyEndAllowThreads(__tstate);
24694 if (PyErr_Occurred()) SWIG_fail;
24695 }
24696 Py_INCREF(Py_None); resultobj = Py_None;
24697 return resultobj;
24698 fail:
24699 return NULL;
24700 }
24701
24702
24703 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24704 PyObject *resultobj = NULL;
24705 long arg1 ;
24706 PyObject * obj0 = 0 ;
24707 char *kwnames[] = {
24708 (char *) "val", NULL
24709 };
24710
24711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24712 {
24713 arg1 = static_cast<long >(SWIG_As_long(obj0));
24714 if (SWIG_arg_fail(1)) SWIG_fail;
24715 }
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24719
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 Py_INCREF(Py_None); resultobj = Py_None;
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24731 PyObject *resultobj = NULL;
24732 long arg1 ;
24733 PyObject * obj0 = 0 ;
24734 char *kwnames[] = {
24735 (char *) "val", NULL
24736 };
24737
24738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24739 {
24740 arg1 = static_cast<long >(SWIG_As_long(obj0));
24741 if (SWIG_arg_fail(1)) SWIG_fail;
24742 }
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 wxPyApp::SetMacExitMenuItemId(arg1);
24746
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 Py_INCREF(Py_None); resultobj = Py_None;
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24758 PyObject *resultobj = NULL;
24759 wxString *arg1 = 0 ;
24760 bool temp1 = false ;
24761 PyObject * obj0 = 0 ;
24762 char *kwnames[] = {
24763 (char *) "val", NULL
24764 };
24765
24766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24767 {
24768 arg1 = wxString_in_helper(obj0);
24769 if (arg1 == NULL) SWIG_fail;
24770 temp1 = true;
24771 }
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24775
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 Py_INCREF(Py_None); resultobj = Py_None;
24780 {
24781 if (temp1)
24782 delete arg1;
24783 }
24784 return resultobj;
24785 fail:
24786 {
24787 if (temp1)
24788 delete arg1;
24789 }
24790 return NULL;
24791 }
24792
24793
24794 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj = NULL;
24796 wxPyApp *arg1 = (wxPyApp *) 0 ;
24797 PyObject * obj0 = 0 ;
24798 char *kwnames[] = {
24799 (char *) "self", NULL
24800 };
24801
24802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24804 if (SWIG_arg_fail(1)) SWIG_fail;
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 (arg1)->_BootstrapApp();
24808
24809 wxPyEndAllowThreads(__tstate);
24810 if (PyErr_Occurred()) SWIG_fail;
24811 }
24812 Py_INCREF(Py_None); resultobj = Py_None;
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24820 PyObject *resultobj = NULL;
24821 int result;
24822 char *kwnames[] = {
24823 NULL
24824 };
24825
24826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (int)wxPyApp_GetComCtl32Version();
24830
24831 wxPyEndAllowThreads(__tstate);
24832 if (PyErr_Occurred()) SWIG_fail;
24833 }
24834 {
24835 resultobj = SWIG_From_int(static_cast<int >(result));
24836 }
24837 return resultobj;
24838 fail:
24839 return NULL;
24840 }
24841
24842
24843 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24844 PyObject *obj;
24845 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24846 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24847 Py_INCREF(obj);
24848 return Py_BuildValue((char *)"");
24849 }
24850 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj = NULL;
24852 char *kwnames[] = {
24853 NULL
24854 };
24855
24856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 wxExit();
24860
24861 wxPyEndAllowThreads(__tstate);
24862 if (PyErr_Occurred()) SWIG_fail;
24863 }
24864 Py_INCREF(Py_None); resultobj = Py_None;
24865 return resultobj;
24866 fail:
24867 return NULL;
24868 }
24869
24870
24871 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24872 PyObject *resultobj = NULL;
24873 bool result;
24874 char *kwnames[] = {
24875 NULL
24876 };
24877
24878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (bool)wxYield();
24882
24883 wxPyEndAllowThreads(__tstate);
24884 if (PyErr_Occurred()) SWIG_fail;
24885 }
24886 {
24887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24888 }
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24896 PyObject *resultobj = NULL;
24897 bool result;
24898 char *kwnames[] = {
24899 NULL
24900 };
24901
24902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (bool)wxYieldIfNeeded();
24906
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 {
24911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24912 }
24913 return resultobj;
24914 fail:
24915 return NULL;
24916 }
24917
24918
24919 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24920 PyObject *resultobj = NULL;
24921 wxWindow *arg1 = (wxWindow *) NULL ;
24922 bool arg2 = (bool) false ;
24923 bool result;
24924 PyObject * obj0 = 0 ;
24925 PyObject * obj1 = 0 ;
24926 char *kwnames[] = {
24927 (char *) "win",(char *) "onlyIfNeeded", NULL
24928 };
24929
24930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24931 if (obj0) {
24932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24933 if (SWIG_arg_fail(1)) SWIG_fail;
24934 }
24935 if (obj1) {
24936 {
24937 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24938 if (SWIG_arg_fail(2)) SWIG_fail;
24939 }
24940 }
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = (bool)wxSafeYield(arg1,arg2);
24944
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 {
24949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24950 }
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24958 PyObject *resultobj = NULL;
24959 char *kwnames[] = {
24960 NULL
24961 };
24962
24963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24964 {
24965 PyThreadState* __tstate = wxPyBeginAllowThreads();
24966 wxWakeUpIdle();
24967
24968 wxPyEndAllowThreads(__tstate);
24969 if (PyErr_Occurred()) SWIG_fail;
24970 }
24971 Py_INCREF(Py_None); resultobj = Py_None;
24972 return resultobj;
24973 fail:
24974 return NULL;
24975 }
24976
24977
24978 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24979 PyObject *resultobj = NULL;
24980 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24981 wxEvent *arg2 = 0 ;
24982 PyObject * obj0 = 0 ;
24983 PyObject * obj1 = 0 ;
24984 char *kwnames[] = {
24985 (char *) "dest",(char *) "event", NULL
24986 };
24987
24988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24990 if (SWIG_arg_fail(1)) SWIG_fail;
24991 {
24992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24993 if (SWIG_arg_fail(2)) SWIG_fail;
24994 if (arg2 == NULL) {
24995 SWIG_null_ref("wxEvent");
24996 }
24997 if (SWIG_arg_fail(2)) SWIG_fail;
24998 }
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 wxPostEvent(arg1,*arg2);
25002
25003 wxPyEndAllowThreads(__tstate);
25004 if (PyErr_Occurred()) SWIG_fail;
25005 }
25006 Py_INCREF(Py_None); resultobj = Py_None;
25007 return resultobj;
25008 fail:
25009 return NULL;
25010 }
25011
25012
25013 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
25014 PyObject *resultobj = NULL;
25015 char *kwnames[] = {
25016 NULL
25017 };
25018
25019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
25020 {
25021 PyThreadState* __tstate = wxPyBeginAllowThreads();
25022 wxApp_CleanUp();
25023
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 Py_INCREF(Py_None); resultobj = Py_None;
25028 return resultobj;
25029 fail:
25030 return NULL;
25031 }
25032
25033
25034 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
25035 PyObject *resultobj = NULL;
25036 wxPyApp *result;
25037 char *kwnames[] = {
25038 NULL
25039 };
25040
25041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 result = (wxPyApp *)wxPyGetApp();
25045
25046 wxPyEndAllowThreads(__tstate);
25047 if (PyErr_Occurred()) SWIG_fail;
25048 }
25049 {
25050 resultobj = wxPyMake_wxObject(result, 0);
25051 }
25052 return resultobj;
25053 fail:
25054 return NULL;
25055 }
25056
25057
25058 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
25059 PyObject *resultobj = NULL;
25060 char *arg1 = (char *) 0 ;
25061 PyObject * obj0 = 0 ;
25062 char *kwnames[] = {
25063 (char *) "encoding", NULL
25064 };
25065
25066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
25067 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
25068 SWIG_arg_fail(1);SWIG_fail;
25069 }
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 wxSetDefaultPyEncoding((char const *)arg1);
25073
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 Py_INCREF(Py_None); resultobj = Py_None;
25078 return resultobj;
25079 fail:
25080 return NULL;
25081 }
25082
25083
25084 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
25085 PyObject *resultobj = NULL;
25086 char *result;
25087 char *kwnames[] = {
25088 NULL
25089 };
25090
25091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
25092 {
25093 PyThreadState* __tstate = wxPyBeginAllowThreads();
25094 result = (char *)wxGetDefaultPyEncoding();
25095
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 resultobj = SWIG_FromCharPtr(result);
25100 return resultobj;
25101 fail:
25102 return NULL;
25103 }
25104
25105
25106 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
25107 PyObject *resultobj = NULL;
25108 wxEventLoop *result;
25109 char *kwnames[] = {
25110 NULL
25111 };
25112
25113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
25114 {
25115 PyThreadState* __tstate = wxPyBeginAllowThreads();
25116 result = (wxEventLoop *)new wxEventLoop();
25117
25118 wxPyEndAllowThreads(__tstate);
25119 if (PyErr_Occurred()) SWIG_fail;
25120 }
25121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
25122 return resultobj;
25123 fail:
25124 return NULL;
25125 }
25126
25127
25128 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
25129 PyObject *resultobj = NULL;
25130 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25131 PyObject * obj0 = 0 ;
25132 char *kwnames[] = {
25133 (char *) "self", NULL
25134 };
25135
25136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
25137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25138 if (SWIG_arg_fail(1)) SWIG_fail;
25139 {
25140 PyThreadState* __tstate = wxPyBeginAllowThreads();
25141 delete arg1;
25142
25143 wxPyEndAllowThreads(__tstate);
25144 if (PyErr_Occurred()) SWIG_fail;
25145 }
25146 Py_INCREF(Py_None); resultobj = Py_None;
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
25154 PyObject *resultobj = NULL;
25155 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25156 int result;
25157 PyObject * obj0 = 0 ;
25158 char *kwnames[] = {
25159 (char *) "self", NULL
25160 };
25161
25162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
25163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25164 if (SWIG_arg_fail(1)) SWIG_fail;
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 result = (int)(arg1)->Run();
25168
25169 wxPyEndAllowThreads(__tstate);
25170 if (PyErr_Occurred()) SWIG_fail;
25171 }
25172 {
25173 resultobj = SWIG_From_int(static_cast<int >(result));
25174 }
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25182 PyObject *resultobj = NULL;
25183 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25184 int arg2 = (int) 0 ;
25185 PyObject * obj0 = 0 ;
25186 PyObject * obj1 = 0 ;
25187 char *kwnames[] = {
25188 (char *) "self",(char *) "rc", NULL
25189 };
25190
25191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25193 if (SWIG_arg_fail(1)) SWIG_fail;
25194 if (obj1) {
25195 {
25196 arg2 = static_cast<int >(SWIG_As_int(obj1));
25197 if (SWIG_arg_fail(2)) SWIG_fail;
25198 }
25199 }
25200 {
25201 PyThreadState* __tstate = wxPyBeginAllowThreads();
25202 (arg1)->Exit(arg2);
25203
25204 wxPyEndAllowThreads(__tstate);
25205 if (PyErr_Occurred()) SWIG_fail;
25206 }
25207 Py_INCREF(Py_None); resultobj = Py_None;
25208 return resultobj;
25209 fail:
25210 return NULL;
25211 }
25212
25213
25214 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25215 PyObject *resultobj = NULL;
25216 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25217 bool result;
25218 PyObject * obj0 = 0 ;
25219 char *kwnames[] = {
25220 (char *) "self", NULL
25221 };
25222
25223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25225 if (SWIG_arg_fail(1)) SWIG_fail;
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (bool)((wxEventLoop const *)arg1)->Pending();
25229
25230 wxPyEndAllowThreads(__tstate);
25231 if (PyErr_Occurred()) SWIG_fail;
25232 }
25233 {
25234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25235 }
25236 return resultobj;
25237 fail:
25238 return NULL;
25239 }
25240
25241
25242 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25243 PyObject *resultobj = NULL;
25244 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25245 bool result;
25246 PyObject * obj0 = 0 ;
25247 char *kwnames[] = {
25248 (char *) "self", NULL
25249 };
25250
25251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25253 if (SWIG_arg_fail(1)) SWIG_fail;
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 result = (bool)(arg1)->Dispatch();
25257
25258 wxPyEndAllowThreads(__tstate);
25259 if (PyErr_Occurred()) SWIG_fail;
25260 }
25261 {
25262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25263 }
25264 return resultobj;
25265 fail:
25266 return NULL;
25267 }
25268
25269
25270 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj = NULL;
25272 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25273 bool result;
25274 PyObject * obj0 = 0 ;
25275 char *kwnames[] = {
25276 (char *) "self", NULL
25277 };
25278
25279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25281 if (SWIG_arg_fail(1)) SWIG_fail;
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25285
25286 wxPyEndAllowThreads(__tstate);
25287 if (PyErr_Occurred()) SWIG_fail;
25288 }
25289 {
25290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25291 }
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25299 PyObject *resultobj = NULL;
25300 wxEventLoop *result;
25301 char *kwnames[] = {
25302 NULL
25303 };
25304
25305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (wxEventLoop *)wxEventLoop::GetActive();
25309
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25314 return resultobj;
25315 fail:
25316 return NULL;
25317 }
25318
25319
25320 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25321 PyObject *resultobj = NULL;
25322 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25323 PyObject * obj0 = 0 ;
25324 char *kwnames[] = {
25325 (char *) "loop", NULL
25326 };
25327
25328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25330 if (SWIG_arg_fail(1)) SWIG_fail;
25331 {
25332 PyThreadState* __tstate = wxPyBeginAllowThreads();
25333 wxEventLoop::SetActive(arg1);
25334
25335 wxPyEndAllowThreads(__tstate);
25336 if (PyErr_Occurred()) SWIG_fail;
25337 }
25338 Py_INCREF(Py_None); resultobj = Py_None;
25339 return resultobj;
25340 fail:
25341 return NULL;
25342 }
25343
25344
25345 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25346 PyObject *obj;
25347 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25348 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25349 Py_INCREF(obj);
25350 return Py_BuildValue((char *)"");
25351 }
25352 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25353 PyObject *resultobj = NULL;
25354 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25355 wxEventLoopActivator *result;
25356 PyObject * obj0 = 0 ;
25357 char *kwnames[] = {
25358 (char *) "evtLoop", NULL
25359 };
25360
25361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25363 if (SWIG_arg_fail(1)) SWIG_fail;
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj = NULL;
25380 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25381 PyObject * obj0 = 0 ;
25382 char *kwnames[] = {
25383 (char *) "self", NULL
25384 };
25385
25386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25388 if (SWIG_arg_fail(1)) SWIG_fail;
25389 {
25390 PyThreadState* __tstate = wxPyBeginAllowThreads();
25391 delete arg1;
25392
25393 wxPyEndAllowThreads(__tstate);
25394 if (PyErr_Occurred()) SWIG_fail;
25395 }
25396 Py_INCREF(Py_None); resultobj = Py_None;
25397 return resultobj;
25398 fail:
25399 return NULL;
25400 }
25401
25402
25403 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25404 PyObject *obj;
25405 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25406 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25407 Py_INCREF(obj);
25408 return Py_BuildValue((char *)"");
25409 }
25410 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25411 PyObject *resultobj = NULL;
25412 int arg1 = (int) 0 ;
25413 int arg2 = (int) 0 ;
25414 int arg3 = (int) 0 ;
25415 wxAcceleratorEntry *result;
25416 PyObject * obj0 = 0 ;
25417 PyObject * obj1 = 0 ;
25418 PyObject * obj2 = 0 ;
25419 char *kwnames[] = {
25420 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25421 };
25422
25423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25424 if (obj0) {
25425 {
25426 arg1 = static_cast<int >(SWIG_As_int(obj0));
25427 if (SWIG_arg_fail(1)) SWIG_fail;
25428 }
25429 }
25430 if (obj1) {
25431 {
25432 arg2 = static_cast<int >(SWIG_As_int(obj1));
25433 if (SWIG_arg_fail(2)) SWIG_fail;
25434 }
25435 }
25436 if (obj2) {
25437 {
25438 arg3 = static_cast<int >(SWIG_As_int(obj2));
25439 if (SWIG_arg_fail(3)) SWIG_fail;
25440 }
25441 }
25442 {
25443 PyThreadState* __tstate = wxPyBeginAllowThreads();
25444 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25445
25446 wxPyEndAllowThreads(__tstate);
25447 if (PyErr_Occurred()) SWIG_fail;
25448 }
25449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25450 return resultobj;
25451 fail:
25452 return NULL;
25453 }
25454
25455
25456 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25457 PyObject *resultobj = NULL;
25458 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25459 PyObject * obj0 = 0 ;
25460 char *kwnames[] = {
25461 (char *) "self", NULL
25462 };
25463
25464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25466 if (SWIG_arg_fail(1)) SWIG_fail;
25467 {
25468 PyThreadState* __tstate = wxPyBeginAllowThreads();
25469 delete arg1;
25470
25471 wxPyEndAllowThreads(__tstate);
25472 if (PyErr_Occurred()) SWIG_fail;
25473 }
25474 Py_INCREF(Py_None); resultobj = Py_None;
25475 return resultobj;
25476 fail:
25477 return NULL;
25478 }
25479
25480
25481 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25482 PyObject *resultobj = NULL;
25483 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25484 int arg2 ;
25485 int arg3 ;
25486 int arg4 ;
25487 PyObject * obj0 = 0 ;
25488 PyObject * obj1 = 0 ;
25489 PyObject * obj2 = 0 ;
25490 PyObject * obj3 = 0 ;
25491 char *kwnames[] = {
25492 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25493 };
25494
25495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25497 if (SWIG_arg_fail(1)) SWIG_fail;
25498 {
25499 arg2 = static_cast<int >(SWIG_As_int(obj1));
25500 if (SWIG_arg_fail(2)) SWIG_fail;
25501 }
25502 {
25503 arg3 = static_cast<int >(SWIG_As_int(obj2));
25504 if (SWIG_arg_fail(3)) SWIG_fail;
25505 }
25506 {
25507 arg4 = static_cast<int >(SWIG_As_int(obj3));
25508 if (SWIG_arg_fail(4)) SWIG_fail;
25509 }
25510 {
25511 PyThreadState* __tstate = wxPyBeginAllowThreads();
25512 (arg1)->Set(arg2,arg3,arg4);
25513
25514 wxPyEndAllowThreads(__tstate);
25515 if (PyErr_Occurred()) SWIG_fail;
25516 }
25517 Py_INCREF(Py_None); resultobj = Py_None;
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj = NULL;
25526 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25527 int result;
25528 PyObject * obj0 = 0 ;
25529 char *kwnames[] = {
25530 (char *) "self", NULL
25531 };
25532
25533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25535 if (SWIG_arg_fail(1)) SWIG_fail;
25536 {
25537 PyThreadState* __tstate = wxPyBeginAllowThreads();
25538 result = (int)(arg1)->GetFlags();
25539
25540 wxPyEndAllowThreads(__tstate);
25541 if (PyErr_Occurred()) SWIG_fail;
25542 }
25543 {
25544 resultobj = SWIG_From_int(static_cast<int >(result));
25545 }
25546 return resultobj;
25547 fail:
25548 return NULL;
25549 }
25550
25551
25552 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25553 PyObject *resultobj = NULL;
25554 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25555 int result;
25556 PyObject * obj0 = 0 ;
25557 char *kwnames[] = {
25558 (char *) "self", NULL
25559 };
25560
25561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25563 if (SWIG_arg_fail(1)) SWIG_fail;
25564 {
25565 PyThreadState* __tstate = wxPyBeginAllowThreads();
25566 result = (int)(arg1)->GetKeyCode();
25567
25568 wxPyEndAllowThreads(__tstate);
25569 if (PyErr_Occurred()) SWIG_fail;
25570 }
25571 {
25572 resultobj = SWIG_From_int(static_cast<int >(result));
25573 }
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25581 PyObject *resultobj = NULL;
25582 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25583 int result;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25591 if (SWIG_arg_fail(1)) SWIG_fail;
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (int)(arg1)->GetCommand();
25595
25596 wxPyEndAllowThreads(__tstate);
25597 if (PyErr_Occurred()) SWIG_fail;
25598 }
25599 {
25600 resultobj = SWIG_From_int(static_cast<int >(result));
25601 }
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25609 PyObject *obj;
25610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25611 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25612 Py_INCREF(obj);
25613 return Py_BuildValue((char *)"");
25614 }
25615 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj = NULL;
25617 int arg1 ;
25618 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25619 wxAcceleratorTable *result;
25620 PyObject * obj0 = 0 ;
25621 char *kwnames[] = {
25622 (char *) "n", NULL
25623 };
25624
25625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25626 {
25627 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25628 if (arg2) arg1 = PyList_Size(obj0);
25629 else arg1 = 0;
25630 }
25631 {
25632 PyThreadState* __tstate = wxPyBeginAllowThreads();
25633 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25634
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25639 {
25640 delete [] arg2;
25641 }
25642 return resultobj;
25643 fail:
25644 {
25645 delete [] arg2;
25646 }
25647 return NULL;
25648 }
25649
25650
25651 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25652 PyObject *resultobj = NULL;
25653 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25654 PyObject * obj0 = 0 ;
25655 char *kwnames[] = {
25656 (char *) "self", NULL
25657 };
25658
25659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25661 if (SWIG_arg_fail(1)) SWIG_fail;
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 delete arg1;
25665
25666 wxPyEndAllowThreads(__tstate);
25667 if (PyErr_Occurred()) SWIG_fail;
25668 }
25669 Py_INCREF(Py_None); resultobj = Py_None;
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25677 PyObject *resultobj = NULL;
25678 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25679 bool result;
25680 PyObject * obj0 = 0 ;
25681 char *kwnames[] = {
25682 (char *) "self", NULL
25683 };
25684
25685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25687 if (SWIG_arg_fail(1)) SWIG_fail;
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25691
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 {
25696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25697 }
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25705 PyObject *obj;
25706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25707 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25708 Py_INCREF(obj);
25709 return Py_BuildValue((char *)"");
25710 }
25711 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25712 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25713 return 1;
25714 }
25715
25716
25717 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25718 PyObject *pyobj = NULL;
25719
25720 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25721 return pyobj;
25722 }
25723
25724
25725 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25726 PyObject *resultobj = NULL;
25727 wxString *arg1 = 0 ;
25728 wxAcceleratorEntry *result;
25729 bool temp1 = false ;
25730 PyObject * obj0 = 0 ;
25731 char *kwnames[] = {
25732 (char *) "label", NULL
25733 };
25734
25735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25736 {
25737 arg1 = wxString_in_helper(obj0);
25738 if (arg1 == NULL) SWIG_fail;
25739 temp1 = true;
25740 }
25741 {
25742 PyThreadState* __tstate = wxPyBeginAllowThreads();
25743 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25744
25745 wxPyEndAllowThreads(__tstate);
25746 if (PyErr_Occurred()) SWIG_fail;
25747 }
25748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25749 {
25750 if (temp1)
25751 delete arg1;
25752 }
25753 return resultobj;
25754 fail:
25755 {
25756 if (temp1)
25757 delete arg1;
25758 }
25759 return NULL;
25760 }
25761
25762
25763 static int _wrap_PanelNameStr_set(PyObject *) {
25764 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25765 return 1;
25766 }
25767
25768
25769 static PyObject *_wrap_PanelNameStr_get(void) {
25770 PyObject *pyobj = NULL;
25771
25772 {
25773 #if wxUSE_UNICODE
25774 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25775 #else
25776 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25777 #endif
25778 }
25779 return pyobj;
25780 }
25781
25782
25783 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25784 PyObject *resultobj = NULL;
25785 wxVisualAttributes *result;
25786 char *kwnames[] = {
25787 NULL
25788 };
25789
25790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25791 {
25792 PyThreadState* __tstate = wxPyBeginAllowThreads();
25793 result = (wxVisualAttributes *)new_wxVisualAttributes();
25794
25795 wxPyEndAllowThreads(__tstate);
25796 if (PyErr_Occurred()) SWIG_fail;
25797 }
25798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj = NULL;
25807 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25808 PyObject * obj0 = 0 ;
25809 char *kwnames[] = {
25810 (char *) "self", NULL
25811 };
25812
25813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25815 if (SWIG_arg_fail(1)) SWIG_fail;
25816 {
25817 PyThreadState* __tstate = wxPyBeginAllowThreads();
25818 delete_wxVisualAttributes(arg1);
25819
25820 wxPyEndAllowThreads(__tstate);
25821 if (PyErr_Occurred()) SWIG_fail;
25822 }
25823 Py_INCREF(Py_None); resultobj = Py_None;
25824 return resultobj;
25825 fail:
25826 return NULL;
25827 }
25828
25829
25830 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25831 PyObject *resultobj = NULL;
25832 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25833 wxFont *arg2 = (wxFont *) 0 ;
25834 PyObject * obj0 = 0 ;
25835 PyObject * obj1 = 0 ;
25836 char *kwnames[] = {
25837 (char *) "self",(char *) "font", NULL
25838 };
25839
25840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25842 if (SWIG_arg_fail(1)) SWIG_fail;
25843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25844 if (SWIG_arg_fail(2)) SWIG_fail;
25845 if (arg1) (arg1)->font = *arg2;
25846
25847 Py_INCREF(Py_None); resultobj = Py_None;
25848 return resultobj;
25849 fail:
25850 return NULL;
25851 }
25852
25853
25854 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25855 PyObject *resultobj = NULL;
25856 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25857 wxFont *result;
25858 PyObject * obj0 = 0 ;
25859 char *kwnames[] = {
25860 (char *) "self", NULL
25861 };
25862
25863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25865 if (SWIG_arg_fail(1)) SWIG_fail;
25866 result = (wxFont *)& ((arg1)->font);
25867
25868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25876 PyObject *resultobj = NULL;
25877 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25878 wxColour *arg2 = (wxColour *) 0 ;
25879 PyObject * obj0 = 0 ;
25880 PyObject * obj1 = 0 ;
25881 char *kwnames[] = {
25882 (char *) "self",(char *) "colFg", NULL
25883 };
25884
25885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25887 if (SWIG_arg_fail(1)) SWIG_fail;
25888 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25889 if (SWIG_arg_fail(2)) SWIG_fail;
25890 if (arg1) (arg1)->colFg = *arg2;
25891
25892 Py_INCREF(Py_None); resultobj = Py_None;
25893 return resultobj;
25894 fail:
25895 return NULL;
25896 }
25897
25898
25899 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25900 PyObject *resultobj = NULL;
25901 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25902 wxColour *result;
25903 PyObject * obj0 = 0 ;
25904 char *kwnames[] = {
25905 (char *) "self", NULL
25906 };
25907
25908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25910 if (SWIG_arg_fail(1)) SWIG_fail;
25911 result = (wxColour *)& ((arg1)->colFg);
25912
25913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj = NULL;
25922 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25923 wxColour *arg2 = (wxColour *) 0 ;
25924 PyObject * obj0 = 0 ;
25925 PyObject * obj1 = 0 ;
25926 char *kwnames[] = {
25927 (char *) "self",(char *) "colBg", NULL
25928 };
25929
25930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(1)) SWIG_fail;
25933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25934 if (SWIG_arg_fail(2)) SWIG_fail;
25935 if (arg1) (arg1)->colBg = *arg2;
25936
25937 Py_INCREF(Py_None); resultobj = Py_None;
25938 return resultobj;
25939 fail:
25940 return NULL;
25941 }
25942
25943
25944 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25945 PyObject *resultobj = NULL;
25946 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25947 wxColour *result;
25948 PyObject * obj0 = 0 ;
25949 char *kwnames[] = {
25950 (char *) "self", NULL
25951 };
25952
25953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25955 if (SWIG_arg_fail(1)) SWIG_fail;
25956 result = (wxColour *)& ((arg1)->colBg);
25957
25958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25966 PyObject *obj;
25967 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25968 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25969 Py_INCREF(obj);
25970 return Py_BuildValue((char *)"");
25971 }
25972 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25973 PyObject *resultobj = NULL;
25974 wxWindow *arg1 = (wxWindow *) 0 ;
25975 int arg2 = (int) (int)-1 ;
25976 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25977 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25978 wxSize const &arg4_defvalue = wxDefaultSize ;
25979 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25980 long arg5 = (long) 0 ;
25981 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25982 wxString *arg6 = (wxString *) &arg6_defvalue ;
25983 wxWindow *result;
25984 wxPoint temp3 ;
25985 wxSize temp4 ;
25986 bool temp6 = false ;
25987 PyObject * obj0 = 0 ;
25988 PyObject * obj1 = 0 ;
25989 PyObject * obj2 = 0 ;
25990 PyObject * obj3 = 0 ;
25991 PyObject * obj4 = 0 ;
25992 PyObject * obj5 = 0 ;
25993 char *kwnames[] = {
25994 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25995 };
25996
25997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25999 if (SWIG_arg_fail(1)) SWIG_fail;
26000 if (obj1) {
26001 {
26002 arg2 = static_cast<int const >(SWIG_As_int(obj1));
26003 if (SWIG_arg_fail(2)) SWIG_fail;
26004 }
26005 }
26006 if (obj2) {
26007 {
26008 arg3 = &temp3;
26009 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26010 }
26011 }
26012 if (obj3) {
26013 {
26014 arg4 = &temp4;
26015 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26016 }
26017 }
26018 if (obj4) {
26019 {
26020 arg5 = static_cast<long >(SWIG_As_long(obj4));
26021 if (SWIG_arg_fail(5)) SWIG_fail;
26022 }
26023 }
26024 if (obj5) {
26025 {
26026 arg6 = wxString_in_helper(obj5);
26027 if (arg6 == NULL) SWIG_fail;
26028 temp6 = true;
26029 }
26030 }
26031 {
26032 if (!wxPyCheckForApp()) SWIG_fail;
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
26035
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
26040 {
26041 if (temp6)
26042 delete arg6;
26043 }
26044 return resultobj;
26045 fail:
26046 {
26047 if (temp6)
26048 delete arg6;
26049 }
26050 return NULL;
26051 }
26052
26053
26054 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj = NULL;
26056 wxWindow *result;
26057 char *kwnames[] = {
26058 NULL
26059 };
26060
26061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
26062 {
26063 if (!wxPyCheckForApp()) SWIG_fail;
26064 PyThreadState* __tstate = wxPyBeginAllowThreads();
26065 result = (wxWindow *)new wxWindow();
26066
26067 wxPyEndAllowThreads(__tstate);
26068 if (PyErr_Occurred()) SWIG_fail;
26069 }
26070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
26078 PyObject *resultobj = NULL;
26079 wxWindow *arg1 = (wxWindow *) 0 ;
26080 wxWindow *arg2 = (wxWindow *) 0 ;
26081 int arg3 = (int) (int)-1 ;
26082 wxPoint const &arg4_defvalue = wxDefaultPosition ;
26083 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
26084 wxSize const &arg5_defvalue = wxDefaultSize ;
26085 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
26086 long arg6 = (long) 0 ;
26087 wxString const &arg7_defvalue = wxPyPanelNameStr ;
26088 wxString *arg7 = (wxString *) &arg7_defvalue ;
26089 bool result;
26090 wxPoint temp4 ;
26091 wxSize temp5 ;
26092 bool temp7 = false ;
26093 PyObject * obj0 = 0 ;
26094 PyObject * obj1 = 0 ;
26095 PyObject * obj2 = 0 ;
26096 PyObject * obj3 = 0 ;
26097 PyObject * obj4 = 0 ;
26098 PyObject * obj5 = 0 ;
26099 PyObject * obj6 = 0 ;
26100 char *kwnames[] = {
26101 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
26102 };
26103
26104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26106 if (SWIG_arg_fail(1)) SWIG_fail;
26107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26108 if (SWIG_arg_fail(2)) SWIG_fail;
26109 if (obj2) {
26110 {
26111 arg3 = static_cast<int const >(SWIG_As_int(obj2));
26112 if (SWIG_arg_fail(3)) SWIG_fail;
26113 }
26114 }
26115 if (obj3) {
26116 {
26117 arg4 = &temp4;
26118 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
26119 }
26120 }
26121 if (obj4) {
26122 {
26123 arg5 = &temp5;
26124 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
26125 }
26126 }
26127 if (obj5) {
26128 {
26129 arg6 = static_cast<long >(SWIG_As_long(obj5));
26130 if (SWIG_arg_fail(6)) SWIG_fail;
26131 }
26132 }
26133 if (obj6) {
26134 {
26135 arg7 = wxString_in_helper(obj6);
26136 if (arg7 == NULL) SWIG_fail;
26137 temp7 = true;
26138 }
26139 }
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
26143
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 {
26148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26149 }
26150 {
26151 if (temp7)
26152 delete arg7;
26153 }
26154 return resultobj;
26155 fail:
26156 {
26157 if (temp7)
26158 delete arg7;
26159 }
26160 return NULL;
26161 }
26162
26163
26164 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
26165 PyObject *resultobj = NULL;
26166 wxWindow *arg1 = (wxWindow *) 0 ;
26167 bool arg2 = (bool) false ;
26168 bool result;
26169 PyObject * obj0 = 0 ;
26170 PyObject * obj1 = 0 ;
26171 char *kwnames[] = {
26172 (char *) "self",(char *) "force", NULL
26173 };
26174
26175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26177 if (SWIG_arg_fail(1)) SWIG_fail;
26178 if (obj1) {
26179 {
26180 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26181 if (SWIG_arg_fail(2)) SWIG_fail;
26182 }
26183 }
26184 {
26185 PyThreadState* __tstate = wxPyBeginAllowThreads();
26186 result = (bool)(arg1)->Close(arg2);
26187
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 {
26192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj = NULL;
26202 wxWindow *arg1 = (wxWindow *) 0 ;
26203 bool result;
26204 PyObject * obj0 = 0 ;
26205 char *kwnames[] = {
26206 (char *) "self", NULL
26207 };
26208
26209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26211 if (SWIG_arg_fail(1)) SWIG_fail;
26212 {
26213 PyThreadState* __tstate = wxPyBeginAllowThreads();
26214 result = (bool)(arg1)->Destroy();
26215
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 {
26220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26221 }
26222 return resultobj;
26223 fail:
26224 return NULL;
26225 }
26226
26227
26228 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26229 PyObject *resultobj = NULL;
26230 wxWindow *arg1 = (wxWindow *) 0 ;
26231 bool result;
26232 PyObject * obj0 = 0 ;
26233 char *kwnames[] = {
26234 (char *) "self", NULL
26235 };
26236
26237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26239 if (SWIG_arg_fail(1)) SWIG_fail;
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 result = (bool)(arg1)->DestroyChildren();
26243
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 {
26248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26249 }
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26257 PyObject *resultobj = NULL;
26258 wxWindow *arg1 = (wxWindow *) 0 ;
26259 bool result;
26260 PyObject * obj0 = 0 ;
26261 char *kwnames[] = {
26262 (char *) "self", NULL
26263 };
26264
26265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26267 if (SWIG_arg_fail(1)) SWIG_fail;
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26271
26272 wxPyEndAllowThreads(__tstate);
26273 if (PyErr_Occurred()) SWIG_fail;
26274 }
26275 {
26276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26277 }
26278 return resultobj;
26279 fail:
26280 return NULL;
26281 }
26282
26283
26284 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26285 PyObject *resultobj = NULL;
26286 wxWindow *arg1 = (wxWindow *) 0 ;
26287 wxString *arg2 = 0 ;
26288 bool temp2 = false ;
26289 PyObject * obj0 = 0 ;
26290 PyObject * obj1 = 0 ;
26291 char *kwnames[] = {
26292 (char *) "self",(char *) "label", NULL
26293 };
26294
26295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26297 if (SWIG_arg_fail(1)) SWIG_fail;
26298 {
26299 arg2 = wxString_in_helper(obj1);
26300 if (arg2 == NULL) SWIG_fail;
26301 temp2 = true;
26302 }
26303 {
26304 PyThreadState* __tstate = wxPyBeginAllowThreads();
26305 (arg1)->SetLabel((wxString const &)*arg2);
26306
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 Py_INCREF(Py_None); resultobj = Py_None;
26311 {
26312 if (temp2)
26313 delete arg2;
26314 }
26315 return resultobj;
26316 fail:
26317 {
26318 if (temp2)
26319 delete arg2;
26320 }
26321 return NULL;
26322 }
26323
26324
26325 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj = NULL;
26327 wxWindow *arg1 = (wxWindow *) 0 ;
26328 wxString result;
26329 PyObject * obj0 = 0 ;
26330 char *kwnames[] = {
26331 (char *) "self", NULL
26332 };
26333
26334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26336 if (SWIG_arg_fail(1)) SWIG_fail;
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = ((wxWindow const *)arg1)->GetLabel();
26340
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 {
26345 #if wxUSE_UNICODE
26346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26347 #else
26348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26349 #endif
26350 }
26351 return resultobj;
26352 fail:
26353 return NULL;
26354 }
26355
26356
26357 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26358 PyObject *resultobj = NULL;
26359 wxWindow *arg1 = (wxWindow *) 0 ;
26360 wxString *arg2 = 0 ;
26361 bool temp2 = false ;
26362 PyObject * obj0 = 0 ;
26363 PyObject * obj1 = 0 ;
26364 char *kwnames[] = {
26365 (char *) "self",(char *) "name", NULL
26366 };
26367
26368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26370 if (SWIG_arg_fail(1)) SWIG_fail;
26371 {
26372 arg2 = wxString_in_helper(obj1);
26373 if (arg2 == NULL) SWIG_fail;
26374 temp2 = true;
26375 }
26376 {
26377 PyThreadState* __tstate = wxPyBeginAllowThreads();
26378 (arg1)->SetName((wxString const &)*arg2);
26379
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 Py_INCREF(Py_None); resultobj = Py_None;
26384 {
26385 if (temp2)
26386 delete arg2;
26387 }
26388 return resultobj;
26389 fail:
26390 {
26391 if (temp2)
26392 delete arg2;
26393 }
26394 return NULL;
26395 }
26396
26397
26398 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26399 PyObject *resultobj = NULL;
26400 wxWindow *arg1 = (wxWindow *) 0 ;
26401 wxString result;
26402 PyObject * obj0 = 0 ;
26403 char *kwnames[] = {
26404 (char *) "self", NULL
26405 };
26406
26407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26409 if (SWIG_arg_fail(1)) SWIG_fail;
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = ((wxWindow const *)arg1)->GetName();
26413
26414 wxPyEndAllowThreads(__tstate);
26415 if (PyErr_Occurred()) SWIG_fail;
26416 }
26417 {
26418 #if wxUSE_UNICODE
26419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26420 #else
26421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26422 #endif
26423 }
26424 return resultobj;
26425 fail:
26426 return NULL;
26427 }
26428
26429
26430 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26431 PyObject *resultobj = NULL;
26432 wxWindow *arg1 = (wxWindow *) 0 ;
26433 wxWindowVariant arg2 ;
26434 PyObject * obj0 = 0 ;
26435 PyObject * obj1 = 0 ;
26436 char *kwnames[] = {
26437 (char *) "self",(char *) "variant", NULL
26438 };
26439
26440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26442 if (SWIG_arg_fail(1)) SWIG_fail;
26443 {
26444 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26445 if (SWIG_arg_fail(2)) SWIG_fail;
26446 }
26447 {
26448 PyThreadState* __tstate = wxPyBeginAllowThreads();
26449 (arg1)->SetWindowVariant(arg2);
26450
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 Py_INCREF(Py_None); resultobj = Py_None;
26455 return resultobj;
26456 fail:
26457 return NULL;
26458 }
26459
26460
26461 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj = NULL;
26463 wxWindow *arg1 = (wxWindow *) 0 ;
26464 wxWindowVariant result;
26465 PyObject * obj0 = 0 ;
26466 char *kwnames[] = {
26467 (char *) "self", NULL
26468 };
26469
26470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26472 if (SWIG_arg_fail(1)) SWIG_fail;
26473 {
26474 PyThreadState* __tstate = wxPyBeginAllowThreads();
26475 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26476
26477 wxPyEndAllowThreads(__tstate);
26478 if (PyErr_Occurred()) SWIG_fail;
26479 }
26480 resultobj = SWIG_From_int((result));
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26488 PyObject *resultobj = NULL;
26489 wxWindow *arg1 = (wxWindow *) 0 ;
26490 int arg2 ;
26491 PyObject * obj0 = 0 ;
26492 PyObject * obj1 = 0 ;
26493 char *kwnames[] = {
26494 (char *) "self",(char *) "winid", NULL
26495 };
26496
26497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26499 if (SWIG_arg_fail(1)) SWIG_fail;
26500 {
26501 arg2 = static_cast<int >(SWIG_As_int(obj1));
26502 if (SWIG_arg_fail(2)) SWIG_fail;
26503 }
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 (arg1)->SetId(arg2);
26507
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 Py_INCREF(Py_None); resultobj = Py_None;
26512 return resultobj;
26513 fail:
26514 return NULL;
26515 }
26516
26517
26518 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26519 PyObject *resultobj = NULL;
26520 wxWindow *arg1 = (wxWindow *) 0 ;
26521 int result;
26522 PyObject * obj0 = 0 ;
26523 char *kwnames[] = {
26524 (char *) "self", NULL
26525 };
26526
26527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26529 if (SWIG_arg_fail(1)) SWIG_fail;
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 result = (int)((wxWindow const *)arg1)->GetId();
26533
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 {
26538 resultobj = SWIG_From_int(static_cast<int >(result));
26539 }
26540 return resultobj;
26541 fail:
26542 return NULL;
26543 }
26544
26545
26546 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26547 PyObject *resultobj = NULL;
26548 int result;
26549 char *kwnames[] = {
26550 NULL
26551 };
26552
26553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26554 {
26555 PyThreadState* __tstate = wxPyBeginAllowThreads();
26556 result = (int)wxWindow::NewControlId();
26557
26558 wxPyEndAllowThreads(__tstate);
26559 if (PyErr_Occurred()) SWIG_fail;
26560 }
26561 {
26562 resultobj = SWIG_From_int(static_cast<int >(result));
26563 }
26564 return resultobj;
26565 fail:
26566 return NULL;
26567 }
26568
26569
26570 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26571 PyObject *resultobj = NULL;
26572 int arg1 ;
26573 int result;
26574 PyObject * obj0 = 0 ;
26575 char *kwnames[] = {
26576 (char *) "winid", NULL
26577 };
26578
26579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26580 {
26581 arg1 = static_cast<int >(SWIG_As_int(obj0));
26582 if (SWIG_arg_fail(1)) SWIG_fail;
26583 }
26584 {
26585 PyThreadState* __tstate = wxPyBeginAllowThreads();
26586 result = (int)wxWindow::NextControlId(arg1);
26587
26588 wxPyEndAllowThreads(__tstate);
26589 if (PyErr_Occurred()) SWIG_fail;
26590 }
26591 {
26592 resultobj = SWIG_From_int(static_cast<int >(result));
26593 }
26594 return resultobj;
26595 fail:
26596 return NULL;
26597 }
26598
26599
26600 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26601 PyObject *resultobj = NULL;
26602 int arg1 ;
26603 int result;
26604 PyObject * obj0 = 0 ;
26605 char *kwnames[] = {
26606 (char *) "winid", NULL
26607 };
26608
26609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26610 {
26611 arg1 = static_cast<int >(SWIG_As_int(obj0));
26612 if (SWIG_arg_fail(1)) SWIG_fail;
26613 }
26614 {
26615 PyThreadState* __tstate = wxPyBeginAllowThreads();
26616 result = (int)wxWindow::PrevControlId(arg1);
26617
26618 wxPyEndAllowThreads(__tstate);
26619 if (PyErr_Occurred()) SWIG_fail;
26620 }
26621 {
26622 resultobj = SWIG_From_int(static_cast<int >(result));
26623 }
26624 return resultobj;
26625 fail:
26626 return NULL;
26627 }
26628
26629
26630 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26631 PyObject *resultobj = NULL;
26632 wxWindow *arg1 = (wxWindow *) 0 ;
26633 wxSize *arg2 = 0 ;
26634 wxSize temp2 ;
26635 PyObject * obj0 = 0 ;
26636 PyObject * obj1 = 0 ;
26637 char *kwnames[] = {
26638 (char *) "self",(char *) "size", NULL
26639 };
26640
26641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26643 if (SWIG_arg_fail(1)) SWIG_fail;
26644 {
26645 arg2 = &temp2;
26646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26647 }
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 (arg1)->SetSize((wxSize const &)*arg2);
26651
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 Py_INCREF(Py_None); resultobj = Py_None;
26656 return resultobj;
26657 fail:
26658 return NULL;
26659 }
26660
26661
26662 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26663 PyObject *resultobj = NULL;
26664 wxWindow *arg1 = (wxWindow *) 0 ;
26665 int arg2 ;
26666 int arg3 ;
26667 int arg4 ;
26668 int arg5 ;
26669 int arg6 = (int) wxSIZE_AUTO ;
26670 PyObject * obj0 = 0 ;
26671 PyObject * obj1 = 0 ;
26672 PyObject * obj2 = 0 ;
26673 PyObject * obj3 = 0 ;
26674 PyObject * obj4 = 0 ;
26675 PyObject * obj5 = 0 ;
26676 char *kwnames[] = {
26677 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26678 };
26679
26680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26682 if (SWIG_arg_fail(1)) SWIG_fail;
26683 {
26684 arg2 = static_cast<int >(SWIG_As_int(obj1));
26685 if (SWIG_arg_fail(2)) SWIG_fail;
26686 }
26687 {
26688 arg3 = static_cast<int >(SWIG_As_int(obj2));
26689 if (SWIG_arg_fail(3)) SWIG_fail;
26690 }
26691 {
26692 arg4 = static_cast<int >(SWIG_As_int(obj3));
26693 if (SWIG_arg_fail(4)) SWIG_fail;
26694 }
26695 {
26696 arg5 = static_cast<int >(SWIG_As_int(obj4));
26697 if (SWIG_arg_fail(5)) SWIG_fail;
26698 }
26699 if (obj5) {
26700 {
26701 arg6 = static_cast<int >(SWIG_As_int(obj5));
26702 if (SWIG_arg_fail(6)) SWIG_fail;
26703 }
26704 }
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26708
26709 wxPyEndAllowThreads(__tstate);
26710 if (PyErr_Occurred()) SWIG_fail;
26711 }
26712 Py_INCREF(Py_None); resultobj = Py_None;
26713 return resultobj;
26714 fail:
26715 return NULL;
26716 }
26717
26718
26719 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj = NULL;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 wxRect *arg2 = 0 ;
26723 int arg3 = (int) wxSIZE_AUTO ;
26724 wxRect temp2 ;
26725 PyObject * obj0 = 0 ;
26726 PyObject * obj1 = 0 ;
26727 PyObject * obj2 = 0 ;
26728 char *kwnames[] = {
26729 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26730 };
26731
26732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26734 if (SWIG_arg_fail(1)) SWIG_fail;
26735 {
26736 arg2 = &temp2;
26737 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26738 }
26739 if (obj2) {
26740 {
26741 arg3 = static_cast<int >(SWIG_As_int(obj2));
26742 if (SWIG_arg_fail(3)) SWIG_fail;
26743 }
26744 }
26745 {
26746 PyThreadState* __tstate = wxPyBeginAllowThreads();
26747 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26748
26749 wxPyEndAllowThreads(__tstate);
26750 if (PyErr_Occurred()) SWIG_fail;
26751 }
26752 Py_INCREF(Py_None); resultobj = Py_None;
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26760 PyObject *resultobj = NULL;
26761 wxWindow *arg1 = (wxWindow *) 0 ;
26762 int arg2 ;
26763 int arg3 ;
26764 PyObject * obj0 = 0 ;
26765 PyObject * obj1 = 0 ;
26766 PyObject * obj2 = 0 ;
26767 char *kwnames[] = {
26768 (char *) "self",(char *) "width",(char *) "height", NULL
26769 };
26770
26771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26773 if (SWIG_arg_fail(1)) SWIG_fail;
26774 {
26775 arg2 = static_cast<int >(SWIG_As_int(obj1));
26776 if (SWIG_arg_fail(2)) SWIG_fail;
26777 }
26778 {
26779 arg3 = static_cast<int >(SWIG_As_int(obj2));
26780 if (SWIG_arg_fail(3)) SWIG_fail;
26781 }
26782 {
26783 PyThreadState* __tstate = wxPyBeginAllowThreads();
26784 (arg1)->SetSize(arg2,arg3);
26785
26786 wxPyEndAllowThreads(__tstate);
26787 if (PyErr_Occurred()) SWIG_fail;
26788 }
26789 Py_INCREF(Py_None); resultobj = Py_None;
26790 return resultobj;
26791 fail:
26792 return NULL;
26793 }
26794
26795
26796 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26797 PyObject *resultobj = NULL;
26798 wxWindow *arg1 = (wxWindow *) 0 ;
26799 wxPoint *arg2 = 0 ;
26800 int arg3 = (int) wxSIZE_USE_EXISTING ;
26801 wxPoint temp2 ;
26802 PyObject * obj0 = 0 ;
26803 PyObject * obj1 = 0 ;
26804 PyObject * obj2 = 0 ;
26805 char *kwnames[] = {
26806 (char *) "self",(char *) "pt",(char *) "flags", NULL
26807 };
26808
26809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26811 if (SWIG_arg_fail(1)) SWIG_fail;
26812 {
26813 arg2 = &temp2;
26814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26815 }
26816 if (obj2) {
26817 {
26818 arg3 = static_cast<int >(SWIG_As_int(obj2));
26819 if (SWIG_arg_fail(3)) SWIG_fail;
26820 }
26821 }
26822 {
26823 PyThreadState* __tstate = wxPyBeginAllowThreads();
26824 (arg1)->Move((wxPoint const &)*arg2,arg3);
26825
26826 wxPyEndAllowThreads(__tstate);
26827 if (PyErr_Occurred()) SWIG_fail;
26828 }
26829 Py_INCREF(Py_None); resultobj = Py_None;
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26837 PyObject *resultobj = NULL;
26838 wxWindow *arg1 = (wxWindow *) 0 ;
26839 int arg2 ;
26840 int arg3 ;
26841 int arg4 = (int) wxSIZE_USE_EXISTING ;
26842 PyObject * obj0 = 0 ;
26843 PyObject * obj1 = 0 ;
26844 PyObject * obj2 = 0 ;
26845 PyObject * obj3 = 0 ;
26846 char *kwnames[] = {
26847 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26848 };
26849
26850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26852 if (SWIG_arg_fail(1)) SWIG_fail;
26853 {
26854 arg2 = static_cast<int >(SWIG_As_int(obj1));
26855 if (SWIG_arg_fail(2)) SWIG_fail;
26856 }
26857 {
26858 arg3 = static_cast<int >(SWIG_As_int(obj2));
26859 if (SWIG_arg_fail(3)) SWIG_fail;
26860 }
26861 if (obj3) {
26862 {
26863 arg4 = static_cast<int >(SWIG_As_int(obj3));
26864 if (SWIG_arg_fail(4)) SWIG_fail;
26865 }
26866 }
26867 {
26868 PyThreadState* __tstate = wxPyBeginAllowThreads();
26869 (arg1)->Move(arg2,arg3,arg4);
26870
26871 wxPyEndAllowThreads(__tstate);
26872 if (PyErr_Occurred()) SWIG_fail;
26873 }
26874 Py_INCREF(Py_None); resultobj = Py_None;
26875 return resultobj;
26876 fail:
26877 return NULL;
26878 }
26879
26880
26881 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26882 PyObject *resultobj = NULL;
26883 wxWindow *arg1 = (wxWindow *) 0 ;
26884 wxSize const &arg2_defvalue = wxDefaultSize ;
26885 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26886 wxSize temp2 ;
26887 PyObject * obj0 = 0 ;
26888 PyObject * obj1 = 0 ;
26889 char *kwnames[] = {
26890 (char *) "self",(char *) "size", NULL
26891 };
26892
26893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26895 if (SWIG_arg_fail(1)) SWIG_fail;
26896 if (obj1) {
26897 {
26898 arg2 = &temp2;
26899 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26900 }
26901 }
26902 {
26903 PyThreadState* __tstate = wxPyBeginAllowThreads();
26904 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26905
26906 wxPyEndAllowThreads(__tstate);
26907 if (PyErr_Occurred()) SWIG_fail;
26908 }
26909 Py_INCREF(Py_None); resultobj = Py_None;
26910 return resultobj;
26911 fail:
26912 return NULL;
26913 }
26914
26915
26916 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26917 PyObject *resultobj = NULL;
26918 wxWindow *arg1 = (wxWindow *) 0 ;
26919 PyObject * obj0 = 0 ;
26920 char *kwnames[] = {
26921 (char *) "self", NULL
26922 };
26923
26924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26926 if (SWIG_arg_fail(1)) SWIG_fail;
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 (arg1)->Raise();
26930
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 Py_INCREF(Py_None); resultobj = Py_None;
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26942 PyObject *resultobj = NULL;
26943 wxWindow *arg1 = (wxWindow *) 0 ;
26944 PyObject * obj0 = 0 ;
26945 char *kwnames[] = {
26946 (char *) "self", NULL
26947 };
26948
26949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26951 if (SWIG_arg_fail(1)) SWIG_fail;
26952 {
26953 PyThreadState* __tstate = wxPyBeginAllowThreads();
26954 (arg1)->Lower();
26955
26956 wxPyEndAllowThreads(__tstate);
26957 if (PyErr_Occurred()) SWIG_fail;
26958 }
26959 Py_INCREF(Py_None); resultobj = Py_None;
26960 return resultobj;
26961 fail:
26962 return NULL;
26963 }
26964
26965
26966 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26967 PyObject *resultobj = NULL;
26968 wxWindow *arg1 = (wxWindow *) 0 ;
26969 wxSize *arg2 = 0 ;
26970 wxSize temp2 ;
26971 PyObject * obj0 = 0 ;
26972 PyObject * obj1 = 0 ;
26973 char *kwnames[] = {
26974 (char *) "self",(char *) "size", NULL
26975 };
26976
26977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26979 if (SWIG_arg_fail(1)) SWIG_fail;
26980 {
26981 arg2 = &temp2;
26982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26983 }
26984 {
26985 PyThreadState* __tstate = wxPyBeginAllowThreads();
26986 (arg1)->SetClientSize((wxSize const &)*arg2);
26987
26988 wxPyEndAllowThreads(__tstate);
26989 if (PyErr_Occurred()) SWIG_fail;
26990 }
26991 Py_INCREF(Py_None); resultobj = Py_None;
26992 return resultobj;
26993 fail:
26994 return NULL;
26995 }
26996
26997
26998 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26999 PyObject *resultobj = NULL;
27000 wxWindow *arg1 = (wxWindow *) 0 ;
27001 int arg2 ;
27002 int arg3 ;
27003 PyObject * obj0 = 0 ;
27004 PyObject * obj1 = 0 ;
27005 PyObject * obj2 = 0 ;
27006 char *kwnames[] = {
27007 (char *) "self",(char *) "width",(char *) "height", NULL
27008 };
27009
27010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27012 if (SWIG_arg_fail(1)) SWIG_fail;
27013 {
27014 arg2 = static_cast<int >(SWIG_As_int(obj1));
27015 if (SWIG_arg_fail(2)) SWIG_fail;
27016 }
27017 {
27018 arg3 = static_cast<int >(SWIG_As_int(obj2));
27019 if (SWIG_arg_fail(3)) SWIG_fail;
27020 }
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 (arg1)->SetClientSize(arg2,arg3);
27024
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 Py_INCREF(Py_None); resultobj = Py_None;
27029 return resultobj;
27030 fail:
27031 return NULL;
27032 }
27033
27034
27035 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27036 PyObject *resultobj = NULL;
27037 wxWindow *arg1 = (wxWindow *) 0 ;
27038 wxRect *arg2 = 0 ;
27039 wxRect temp2 ;
27040 PyObject * obj0 = 0 ;
27041 PyObject * obj1 = 0 ;
27042 char *kwnames[] = {
27043 (char *) "self",(char *) "rect", NULL
27044 };
27045
27046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
27047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27048 if (SWIG_arg_fail(1)) SWIG_fail;
27049 {
27050 arg2 = &temp2;
27051 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
27052 }
27053 {
27054 PyThreadState* __tstate = wxPyBeginAllowThreads();
27055 (arg1)->SetClientSize((wxRect const &)*arg2);
27056
27057 wxPyEndAllowThreads(__tstate);
27058 if (PyErr_Occurred()) SWIG_fail;
27059 }
27060 Py_INCREF(Py_None); resultobj = Py_None;
27061 return resultobj;
27062 fail:
27063 return NULL;
27064 }
27065
27066
27067 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
27068 PyObject *resultobj = NULL;
27069 wxWindow *arg1 = (wxWindow *) 0 ;
27070 wxPoint result;
27071 PyObject * obj0 = 0 ;
27072 char *kwnames[] = {
27073 (char *) "self", NULL
27074 };
27075
27076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
27077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27078 if (SWIG_arg_fail(1)) SWIG_fail;
27079 {
27080 PyThreadState* __tstate = wxPyBeginAllowThreads();
27081 result = (arg1)->GetPosition();
27082
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 {
27087 wxPoint * resultptr;
27088 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27090 }
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj = NULL;
27099 wxWindow *arg1 = (wxWindow *) 0 ;
27100 int *arg2 = (int *) 0 ;
27101 int *arg3 = (int *) 0 ;
27102 int temp2 ;
27103 int res2 = 0 ;
27104 int temp3 ;
27105 int res3 = 0 ;
27106 PyObject * obj0 = 0 ;
27107 char *kwnames[] = {
27108 (char *) "self", NULL
27109 };
27110
27111 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27112 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
27114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27115 if (SWIG_arg_fail(1)) SWIG_fail;
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 (arg1)->GetPosition(arg2,arg3);
27119
27120 wxPyEndAllowThreads(__tstate);
27121 if (PyErr_Occurred()) SWIG_fail;
27122 }
27123 Py_INCREF(Py_None); resultobj = Py_None;
27124 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27125 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27126 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27127 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27135 PyObject *resultobj = NULL;
27136 wxWindow *arg1 = (wxWindow *) 0 ;
27137 wxSize result;
27138 PyObject * obj0 = 0 ;
27139 char *kwnames[] = {
27140 (char *) "self", NULL
27141 };
27142
27143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
27144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27145 if (SWIG_arg_fail(1)) SWIG_fail;
27146 {
27147 PyThreadState* __tstate = wxPyBeginAllowThreads();
27148 result = ((wxWindow const *)arg1)->GetSize();
27149
27150 wxPyEndAllowThreads(__tstate);
27151 if (PyErr_Occurred()) SWIG_fail;
27152 }
27153 {
27154 wxSize * resultptr;
27155 resultptr = new wxSize(static_cast<wxSize & >(result));
27156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27157 }
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj = NULL;
27166 wxWindow *arg1 = (wxWindow *) 0 ;
27167 int *arg2 = (int *) 0 ;
27168 int *arg3 = (int *) 0 ;
27169 int temp2 ;
27170 int res2 = 0 ;
27171 int temp3 ;
27172 int res3 = 0 ;
27173 PyObject * obj0 = 0 ;
27174 char *kwnames[] = {
27175 (char *) "self", NULL
27176 };
27177
27178 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27179 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27182 if (SWIG_arg_fail(1)) SWIG_fail;
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27186
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 Py_INCREF(Py_None); resultobj = Py_None;
27191 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27192 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27193 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27194 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27195 return resultobj;
27196 fail:
27197 return NULL;
27198 }
27199
27200
27201 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27202 PyObject *resultobj = NULL;
27203 wxWindow *arg1 = (wxWindow *) 0 ;
27204 wxRect result;
27205 PyObject * obj0 = 0 ;
27206 char *kwnames[] = {
27207 (char *) "self", NULL
27208 };
27209
27210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27212 if (SWIG_arg_fail(1)) SWIG_fail;
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 result = ((wxWindow const *)arg1)->GetRect();
27216
27217 wxPyEndAllowThreads(__tstate);
27218 if (PyErr_Occurred()) SWIG_fail;
27219 }
27220 {
27221 wxRect * resultptr;
27222 resultptr = new wxRect(static_cast<wxRect & >(result));
27223 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27224 }
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27232 PyObject *resultobj = NULL;
27233 wxWindow *arg1 = (wxWindow *) 0 ;
27234 wxSize result;
27235 PyObject * obj0 = 0 ;
27236 char *kwnames[] = {
27237 (char *) "self", NULL
27238 };
27239
27240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27242 if (SWIG_arg_fail(1)) SWIG_fail;
27243 {
27244 PyThreadState* __tstate = wxPyBeginAllowThreads();
27245 result = ((wxWindow const *)arg1)->GetClientSize();
27246
27247 wxPyEndAllowThreads(__tstate);
27248 if (PyErr_Occurred()) SWIG_fail;
27249 }
27250 {
27251 wxSize * resultptr;
27252 resultptr = new wxSize(static_cast<wxSize & >(result));
27253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27254 }
27255 return resultobj;
27256 fail:
27257 return NULL;
27258 }
27259
27260
27261 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27262 PyObject *resultobj = NULL;
27263 wxWindow *arg1 = (wxWindow *) 0 ;
27264 int *arg2 = (int *) 0 ;
27265 int *arg3 = (int *) 0 ;
27266 int temp2 ;
27267 int res2 = 0 ;
27268 int temp3 ;
27269 int res3 = 0 ;
27270 PyObject * obj0 = 0 ;
27271 char *kwnames[] = {
27272 (char *) "self", NULL
27273 };
27274
27275 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27276 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27279 if (SWIG_arg_fail(1)) SWIG_fail;
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27283
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 Py_INCREF(Py_None); resultobj = Py_None;
27288 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27289 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27290 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27291 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj = NULL;
27300 wxWindow *arg1 = (wxWindow *) 0 ;
27301 wxPoint result;
27302 PyObject * obj0 = 0 ;
27303 char *kwnames[] = {
27304 (char *) "self", NULL
27305 };
27306
27307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27309 if (SWIG_arg_fail(1)) SWIG_fail;
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27313
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 wxPoint * resultptr;
27319 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27321 }
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27329 PyObject *resultobj = NULL;
27330 wxWindow *arg1 = (wxWindow *) 0 ;
27331 wxRect result;
27332 PyObject * obj0 = 0 ;
27333 char *kwnames[] = {
27334 (char *) "self", NULL
27335 };
27336
27337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27339 if (SWIG_arg_fail(1)) SWIG_fail;
27340 {
27341 PyThreadState* __tstate = wxPyBeginAllowThreads();
27342 result = ((wxWindow const *)arg1)->GetClientRect();
27343
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 {
27348 wxRect * resultptr;
27349 resultptr = new wxRect(static_cast<wxRect & >(result));
27350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27351 }
27352 return resultobj;
27353 fail:
27354 return NULL;
27355 }
27356
27357
27358 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27359 PyObject *resultobj = NULL;
27360 wxWindow *arg1 = (wxWindow *) 0 ;
27361 wxSize result;
27362 PyObject * obj0 = 0 ;
27363 char *kwnames[] = {
27364 (char *) "self", NULL
27365 };
27366
27367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27369 if (SWIG_arg_fail(1)) SWIG_fail;
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 result = ((wxWindow const *)arg1)->GetBestSize();
27373
27374 wxPyEndAllowThreads(__tstate);
27375 if (PyErr_Occurred()) SWIG_fail;
27376 }
27377 {
27378 wxSize * resultptr;
27379 resultptr = new wxSize(static_cast<wxSize & >(result));
27380 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27381 }
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27389 PyObject *resultobj = NULL;
27390 wxWindow *arg1 = (wxWindow *) 0 ;
27391 int *arg2 = (int *) 0 ;
27392 int *arg3 = (int *) 0 ;
27393 int temp2 ;
27394 int res2 = 0 ;
27395 int temp3 ;
27396 int res3 = 0 ;
27397 PyObject * obj0 = 0 ;
27398 char *kwnames[] = {
27399 (char *) "self", NULL
27400 };
27401
27402 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27403 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27406 if (SWIG_arg_fail(1)) SWIG_fail;
27407 {
27408 PyThreadState* __tstate = wxPyBeginAllowThreads();
27409 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27410
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 Py_INCREF(Py_None); resultobj = Py_None;
27415 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27416 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27417 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27418 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27426 PyObject *resultobj = NULL;
27427 wxWindow *arg1 = (wxWindow *) 0 ;
27428 PyObject * obj0 = 0 ;
27429 char *kwnames[] = {
27430 (char *) "self", NULL
27431 };
27432
27433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27435 if (SWIG_arg_fail(1)) SWIG_fail;
27436 {
27437 PyThreadState* __tstate = wxPyBeginAllowThreads();
27438 (arg1)->InvalidateBestSize();
27439
27440 wxPyEndAllowThreads(__tstate);
27441 if (PyErr_Occurred()) SWIG_fail;
27442 }
27443 Py_INCREF(Py_None); resultobj = Py_None;
27444 return resultobj;
27445 fail:
27446 return NULL;
27447 }
27448
27449
27450 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27451 PyObject *resultobj = NULL;
27452 wxWindow *arg1 = (wxWindow *) 0 ;
27453 wxSize *arg2 = 0 ;
27454 wxSize temp2 ;
27455 PyObject * obj0 = 0 ;
27456 PyObject * obj1 = 0 ;
27457 char *kwnames[] = {
27458 (char *) "self",(char *) "size", NULL
27459 };
27460
27461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27463 if (SWIG_arg_fail(1)) SWIG_fail;
27464 {
27465 arg2 = &temp2;
27466 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27467 }
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27471
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 Py_INCREF(Py_None); resultobj = Py_None;
27476 return resultobj;
27477 fail:
27478 return NULL;
27479 }
27480
27481
27482 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27483 PyObject *resultobj = NULL;
27484 wxWindow *arg1 = (wxWindow *) 0 ;
27485 wxSize result;
27486 PyObject * obj0 = 0 ;
27487 char *kwnames[] = {
27488 (char *) "self", NULL
27489 };
27490
27491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27493 if (SWIG_arg_fail(1)) SWIG_fail;
27494 {
27495 PyThreadState* __tstate = wxPyBeginAllowThreads();
27496 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27497
27498 wxPyEndAllowThreads(__tstate);
27499 if (PyErr_Occurred()) SWIG_fail;
27500 }
27501 {
27502 wxSize * resultptr;
27503 resultptr = new wxSize(static_cast<wxSize & >(result));
27504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27505 }
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = NULL;
27514 wxWindow *arg1 = (wxWindow *) 0 ;
27515 wxSize result;
27516 PyObject * obj0 = 0 ;
27517 char *kwnames[] = {
27518 (char *) "self", NULL
27519 };
27520
27521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27523 if (SWIG_arg_fail(1)) SWIG_fail;
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27527
27528 wxPyEndAllowThreads(__tstate);
27529 if (PyErr_Occurred()) SWIG_fail;
27530 }
27531 {
27532 wxSize * resultptr;
27533 resultptr = new wxSize(static_cast<wxSize & >(result));
27534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27535 }
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27543 PyObject *resultobj = NULL;
27544 wxWindow *arg1 = (wxWindow *) 0 ;
27545 int arg2 = (int) wxBOTH ;
27546 PyObject * obj0 = 0 ;
27547 PyObject * obj1 = 0 ;
27548 char *kwnames[] = {
27549 (char *) "self",(char *) "direction", NULL
27550 };
27551
27552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27554 if (SWIG_arg_fail(1)) SWIG_fail;
27555 if (obj1) {
27556 {
27557 arg2 = static_cast<int >(SWIG_As_int(obj1));
27558 if (SWIG_arg_fail(2)) SWIG_fail;
27559 }
27560 }
27561 {
27562 PyThreadState* __tstate = wxPyBeginAllowThreads();
27563 (arg1)->Center(arg2);
27564
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 Py_INCREF(Py_None); resultobj = Py_None;
27569 return resultobj;
27570 fail:
27571 return NULL;
27572 }
27573
27574
27575 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27576 PyObject *resultobj = NULL;
27577 wxWindow *arg1 = (wxWindow *) 0 ;
27578 int arg2 = (int) wxBOTH ;
27579 PyObject * obj0 = 0 ;
27580 PyObject * obj1 = 0 ;
27581 char *kwnames[] = {
27582 (char *) "self",(char *) "dir", NULL
27583 };
27584
27585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27587 if (SWIG_arg_fail(1)) SWIG_fail;
27588 if (obj1) {
27589 {
27590 arg2 = static_cast<int >(SWIG_As_int(obj1));
27591 if (SWIG_arg_fail(2)) SWIG_fail;
27592 }
27593 }
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 (arg1)->CenterOnParent(arg2);
27597
27598 wxPyEndAllowThreads(__tstate);
27599 if (PyErr_Occurred()) SWIG_fail;
27600 }
27601 Py_INCREF(Py_None); resultobj = Py_None;
27602 return resultobj;
27603 fail:
27604 return NULL;
27605 }
27606
27607
27608 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27609 PyObject *resultobj = NULL;
27610 wxWindow *arg1 = (wxWindow *) 0 ;
27611 PyObject * obj0 = 0 ;
27612 char *kwnames[] = {
27613 (char *) "self", NULL
27614 };
27615
27616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27618 if (SWIG_arg_fail(1)) SWIG_fail;
27619 {
27620 PyThreadState* __tstate = wxPyBeginAllowThreads();
27621 (arg1)->Fit();
27622
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 Py_INCREF(Py_None); resultobj = Py_None;
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27634 PyObject *resultobj = NULL;
27635 wxWindow *arg1 = (wxWindow *) 0 ;
27636 PyObject * obj0 = 0 ;
27637 char *kwnames[] = {
27638 (char *) "self", NULL
27639 };
27640
27641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(1)) SWIG_fail;
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 (arg1)->FitInside();
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 Py_INCREF(Py_None); resultobj = Py_None;
27652 return resultobj;
27653 fail:
27654 return NULL;
27655 }
27656
27657
27658 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27659 PyObject *resultobj = NULL;
27660 wxWindow *arg1 = (wxWindow *) 0 ;
27661 int arg2 ;
27662 int arg3 ;
27663 int arg4 = (int) -1 ;
27664 int arg5 = (int) -1 ;
27665 int arg6 = (int) -1 ;
27666 int arg7 = (int) -1 ;
27667 PyObject * obj0 = 0 ;
27668 PyObject * obj1 = 0 ;
27669 PyObject * obj2 = 0 ;
27670 PyObject * obj3 = 0 ;
27671 PyObject * obj4 = 0 ;
27672 PyObject * obj5 = 0 ;
27673 PyObject * obj6 = 0 ;
27674 char *kwnames[] = {
27675 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27676 };
27677
27678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27680 if (SWIG_arg_fail(1)) SWIG_fail;
27681 {
27682 arg2 = static_cast<int >(SWIG_As_int(obj1));
27683 if (SWIG_arg_fail(2)) SWIG_fail;
27684 }
27685 {
27686 arg3 = static_cast<int >(SWIG_As_int(obj2));
27687 if (SWIG_arg_fail(3)) SWIG_fail;
27688 }
27689 if (obj3) {
27690 {
27691 arg4 = static_cast<int >(SWIG_As_int(obj3));
27692 if (SWIG_arg_fail(4)) SWIG_fail;
27693 }
27694 }
27695 if (obj4) {
27696 {
27697 arg5 = static_cast<int >(SWIG_As_int(obj4));
27698 if (SWIG_arg_fail(5)) SWIG_fail;
27699 }
27700 }
27701 if (obj5) {
27702 {
27703 arg6 = static_cast<int >(SWIG_As_int(obj5));
27704 if (SWIG_arg_fail(6)) SWIG_fail;
27705 }
27706 }
27707 if (obj6) {
27708 {
27709 arg7 = static_cast<int >(SWIG_As_int(obj6));
27710 if (SWIG_arg_fail(7)) SWIG_fail;
27711 }
27712 }
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27716
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 Py_INCREF(Py_None); resultobj = Py_None;
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj = NULL;
27729 wxWindow *arg1 = (wxWindow *) 0 ;
27730 wxSize *arg2 = 0 ;
27731 wxSize const &arg3_defvalue = wxDefaultSize ;
27732 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27733 wxSize const &arg4_defvalue = wxDefaultSize ;
27734 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27735 wxSize temp2 ;
27736 wxSize temp3 ;
27737 wxSize temp4 ;
27738 PyObject * obj0 = 0 ;
27739 PyObject * obj1 = 0 ;
27740 PyObject * obj2 = 0 ;
27741 PyObject * obj3 = 0 ;
27742 char *kwnames[] = {
27743 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27744 };
27745
27746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27748 if (SWIG_arg_fail(1)) SWIG_fail;
27749 {
27750 arg2 = &temp2;
27751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27752 }
27753 if (obj2) {
27754 {
27755 arg3 = &temp3;
27756 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27757 }
27758 }
27759 if (obj3) {
27760 {
27761 arg4 = &temp4;
27762 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27763 }
27764 }
27765 {
27766 PyThreadState* __tstate = wxPyBeginAllowThreads();
27767 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27768
27769 wxPyEndAllowThreads(__tstate);
27770 if (PyErr_Occurred()) SWIG_fail;
27771 }
27772 Py_INCREF(Py_None); resultobj = Py_None;
27773 return resultobj;
27774 fail:
27775 return NULL;
27776 }
27777
27778
27779 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27780 PyObject *resultobj = NULL;
27781 wxWindow *arg1 = (wxWindow *) 0 ;
27782 int arg2 ;
27783 int arg3 ;
27784 int arg4 = (int) -1 ;
27785 int arg5 = (int) -1 ;
27786 PyObject * obj0 = 0 ;
27787 PyObject * obj1 = 0 ;
27788 PyObject * obj2 = 0 ;
27789 PyObject * obj3 = 0 ;
27790 PyObject * obj4 = 0 ;
27791 char *kwnames[] = {
27792 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27793 };
27794
27795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27797 if (SWIG_arg_fail(1)) SWIG_fail;
27798 {
27799 arg2 = static_cast<int >(SWIG_As_int(obj1));
27800 if (SWIG_arg_fail(2)) SWIG_fail;
27801 }
27802 {
27803 arg3 = static_cast<int >(SWIG_As_int(obj2));
27804 if (SWIG_arg_fail(3)) SWIG_fail;
27805 }
27806 if (obj3) {
27807 {
27808 arg4 = static_cast<int >(SWIG_As_int(obj3));
27809 if (SWIG_arg_fail(4)) SWIG_fail;
27810 }
27811 }
27812 if (obj4) {
27813 {
27814 arg5 = static_cast<int >(SWIG_As_int(obj4));
27815 if (SWIG_arg_fail(5)) SWIG_fail;
27816 }
27817 }
27818 {
27819 PyThreadState* __tstate = wxPyBeginAllowThreads();
27820 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27821
27822 wxPyEndAllowThreads(__tstate);
27823 if (PyErr_Occurred()) SWIG_fail;
27824 }
27825 Py_INCREF(Py_None); resultobj = Py_None;
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27833 PyObject *resultobj = NULL;
27834 wxWindow *arg1 = (wxWindow *) 0 ;
27835 wxSize *arg2 = 0 ;
27836 wxSize const &arg3_defvalue = wxDefaultSize ;
27837 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27838 wxSize temp2 ;
27839 wxSize temp3 ;
27840 PyObject * obj0 = 0 ;
27841 PyObject * obj1 = 0 ;
27842 PyObject * obj2 = 0 ;
27843 char *kwnames[] = {
27844 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27845 };
27846
27847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27849 if (SWIG_arg_fail(1)) SWIG_fail;
27850 {
27851 arg2 = &temp2;
27852 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27853 }
27854 if (obj2) {
27855 {
27856 arg3 = &temp3;
27857 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27858 }
27859 }
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27863
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 Py_INCREF(Py_None); resultobj = Py_None;
27868 return resultobj;
27869 fail:
27870 return NULL;
27871 }
27872
27873
27874 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27875 PyObject *resultobj = NULL;
27876 wxWindow *arg1 = (wxWindow *) 0 ;
27877 wxSize result;
27878 PyObject * obj0 = 0 ;
27879 char *kwnames[] = {
27880 (char *) "self", NULL
27881 };
27882
27883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27885 if (SWIG_arg_fail(1)) SWIG_fail;
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 result = ((wxWindow const *)arg1)->GetMaxSize();
27889
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 {
27894 wxSize * resultptr;
27895 resultptr = new wxSize(static_cast<wxSize & >(result));
27896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27897 }
27898 return resultobj;
27899 fail:
27900 return NULL;
27901 }
27902
27903
27904 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27905 PyObject *resultobj = NULL;
27906 wxWindow *arg1 = (wxWindow *) 0 ;
27907 wxSize result;
27908 PyObject * obj0 = 0 ;
27909 char *kwnames[] = {
27910 (char *) "self", NULL
27911 };
27912
27913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27915 if (SWIG_arg_fail(1)) SWIG_fail;
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = ((wxWindow const *)arg1)->GetMinSize();
27919
27920 wxPyEndAllowThreads(__tstate);
27921 if (PyErr_Occurred()) SWIG_fail;
27922 }
27923 {
27924 wxSize * resultptr;
27925 resultptr = new wxSize(static_cast<wxSize & >(result));
27926 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27927 }
27928 return resultobj;
27929 fail:
27930 return NULL;
27931 }
27932
27933
27934 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27935 PyObject *resultobj = NULL;
27936 wxWindow *arg1 = (wxWindow *) 0 ;
27937 wxSize *arg2 = 0 ;
27938 wxSize temp2 ;
27939 PyObject * obj0 = 0 ;
27940 PyObject * obj1 = 0 ;
27941 char *kwnames[] = {
27942 (char *) "self",(char *) "minSize", NULL
27943 };
27944
27945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27947 if (SWIG_arg_fail(1)) SWIG_fail;
27948 {
27949 arg2 = &temp2;
27950 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27951 }
27952 {
27953 PyThreadState* __tstate = wxPyBeginAllowThreads();
27954 (arg1)->SetMinSize((wxSize const &)*arg2);
27955
27956 wxPyEndAllowThreads(__tstate);
27957 if (PyErr_Occurred()) SWIG_fail;
27958 }
27959 Py_INCREF(Py_None); resultobj = Py_None;
27960 return resultobj;
27961 fail:
27962 return NULL;
27963 }
27964
27965
27966 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27967 PyObject *resultobj = NULL;
27968 wxWindow *arg1 = (wxWindow *) 0 ;
27969 wxSize *arg2 = 0 ;
27970 wxSize temp2 ;
27971 PyObject * obj0 = 0 ;
27972 PyObject * obj1 = 0 ;
27973 char *kwnames[] = {
27974 (char *) "self",(char *) "maxSize", NULL
27975 };
27976
27977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27979 if (SWIG_arg_fail(1)) SWIG_fail;
27980 {
27981 arg2 = &temp2;
27982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27983 }
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 (arg1)->SetMaxSize((wxSize const &)*arg2);
27987
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 Py_INCREF(Py_None); resultobj = Py_None;
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj = NULL;
28000 wxWindow *arg1 = (wxWindow *) 0 ;
28001 int result;
28002 PyObject * obj0 = 0 ;
28003 char *kwnames[] = {
28004 (char *) "self", NULL
28005 };
28006
28007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
28008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28009 if (SWIG_arg_fail(1)) SWIG_fail;
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 result = (int)((wxWindow const *)arg1)->GetMinWidth();
28013
28014 wxPyEndAllowThreads(__tstate);
28015 if (PyErr_Occurred()) SWIG_fail;
28016 }
28017 {
28018 resultobj = SWIG_From_int(static_cast<int >(result));
28019 }
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj = NULL;
28028 wxWindow *arg1 = (wxWindow *) 0 ;
28029 int result;
28030 PyObject * obj0 = 0 ;
28031 char *kwnames[] = {
28032 (char *) "self", NULL
28033 };
28034
28035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
28036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28037 if (SWIG_arg_fail(1)) SWIG_fail;
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 result = (int)((wxWindow const *)arg1)->GetMinHeight();
28041
28042 wxPyEndAllowThreads(__tstate);
28043 if (PyErr_Occurred()) SWIG_fail;
28044 }
28045 {
28046 resultobj = SWIG_From_int(static_cast<int >(result));
28047 }
28048 return resultobj;
28049 fail:
28050 return NULL;
28051 }
28052
28053
28054 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
28055 PyObject *resultobj = NULL;
28056 wxWindow *arg1 = (wxWindow *) 0 ;
28057 int result;
28058 PyObject * obj0 = 0 ;
28059 char *kwnames[] = {
28060 (char *) "self", NULL
28061 };
28062
28063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
28064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28065 if (SWIG_arg_fail(1)) SWIG_fail;
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
28069
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 {
28074 resultobj = SWIG_From_int(static_cast<int >(result));
28075 }
28076 return resultobj;
28077 fail:
28078 return NULL;
28079 }
28080
28081
28082 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
28083 PyObject *resultobj = NULL;
28084 wxWindow *arg1 = (wxWindow *) 0 ;
28085 int result;
28086 PyObject * obj0 = 0 ;
28087 char *kwnames[] = {
28088 (char *) "self", NULL
28089 };
28090
28091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
28092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28093 if (SWIG_arg_fail(1)) SWIG_fail;
28094 {
28095 PyThreadState* __tstate = wxPyBeginAllowThreads();
28096 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
28097
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 {
28102 resultobj = SWIG_From_int(static_cast<int >(result));
28103 }
28104 return resultobj;
28105 fail:
28106 return NULL;
28107 }
28108
28109
28110 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28111 PyObject *resultobj = NULL;
28112 wxWindow *arg1 = (wxWindow *) 0 ;
28113 wxSize *arg2 = 0 ;
28114 wxSize temp2 ;
28115 PyObject * obj0 = 0 ;
28116 PyObject * obj1 = 0 ;
28117 char *kwnames[] = {
28118 (char *) "self",(char *) "size", NULL
28119 };
28120
28121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
28122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(1)) SWIG_fail;
28124 {
28125 arg2 = &temp2;
28126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28127 }
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 (arg1)->SetVirtualSize((wxSize const &)*arg2);
28131
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 Py_INCREF(Py_None); resultobj = Py_None;
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj = NULL;
28144 wxWindow *arg1 = (wxWindow *) 0 ;
28145 int arg2 ;
28146 int arg3 ;
28147 PyObject * obj0 = 0 ;
28148 PyObject * obj1 = 0 ;
28149 PyObject * obj2 = 0 ;
28150 char *kwnames[] = {
28151 (char *) "self",(char *) "w",(char *) "h", NULL
28152 };
28153
28154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28156 if (SWIG_arg_fail(1)) SWIG_fail;
28157 {
28158 arg2 = static_cast<int >(SWIG_As_int(obj1));
28159 if (SWIG_arg_fail(2)) SWIG_fail;
28160 }
28161 {
28162 arg3 = static_cast<int >(SWIG_As_int(obj2));
28163 if (SWIG_arg_fail(3)) SWIG_fail;
28164 }
28165 {
28166 PyThreadState* __tstate = wxPyBeginAllowThreads();
28167 (arg1)->SetVirtualSize(arg2,arg3);
28168
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 Py_INCREF(Py_None); resultobj = Py_None;
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = NULL;
28181 wxWindow *arg1 = (wxWindow *) 0 ;
28182 wxSize result;
28183 PyObject * obj0 = 0 ;
28184 char *kwnames[] = {
28185 (char *) "self", NULL
28186 };
28187
28188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28190 if (SWIG_arg_fail(1)) SWIG_fail;
28191 {
28192 PyThreadState* __tstate = wxPyBeginAllowThreads();
28193 result = ((wxWindow const *)arg1)->GetVirtualSize();
28194
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 {
28199 wxSize * resultptr;
28200 resultptr = new wxSize(static_cast<wxSize & >(result));
28201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28202 }
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj = NULL;
28211 wxWindow *arg1 = (wxWindow *) 0 ;
28212 int *arg2 = (int *) 0 ;
28213 int *arg3 = (int *) 0 ;
28214 int temp2 ;
28215 int res2 = 0 ;
28216 int temp3 ;
28217 int res3 = 0 ;
28218 PyObject * obj0 = 0 ;
28219 char *kwnames[] = {
28220 (char *) "self", NULL
28221 };
28222
28223 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28224 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28227 if (SWIG_arg_fail(1)) SWIG_fail;
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28231
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 Py_INCREF(Py_None); resultobj = Py_None;
28236 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28237 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28238 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28239 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28240 return resultobj;
28241 fail:
28242 return NULL;
28243 }
28244
28245
28246 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28247 PyObject *resultobj = NULL;
28248 wxWindow *arg1 = (wxWindow *) 0 ;
28249 wxSize result;
28250 PyObject * obj0 = 0 ;
28251 char *kwnames[] = {
28252 (char *) "self", NULL
28253 };
28254
28255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28257 if (SWIG_arg_fail(1)) SWIG_fail;
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28261
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 {
28266 wxSize * resultptr;
28267 resultptr = new wxSize(static_cast<wxSize & >(result));
28268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28269 }
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj = NULL;
28278 wxWindow *arg1 = (wxWindow *) 0 ;
28279 bool arg2 = (bool) true ;
28280 bool result;
28281 PyObject * obj0 = 0 ;
28282 PyObject * obj1 = 0 ;
28283 char *kwnames[] = {
28284 (char *) "self",(char *) "show", NULL
28285 };
28286
28287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28289 if (SWIG_arg_fail(1)) SWIG_fail;
28290 if (obj1) {
28291 {
28292 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28293 if (SWIG_arg_fail(2)) SWIG_fail;
28294 }
28295 }
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 result = (bool)(arg1)->Show(arg2);
28299
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 {
28304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28305 }
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28313 PyObject *resultobj = NULL;
28314 wxWindow *arg1 = (wxWindow *) 0 ;
28315 bool result;
28316 PyObject * obj0 = 0 ;
28317 char *kwnames[] = {
28318 (char *) "self", NULL
28319 };
28320
28321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28323 if (SWIG_arg_fail(1)) SWIG_fail;
28324 {
28325 PyThreadState* __tstate = wxPyBeginAllowThreads();
28326 result = (bool)(arg1)->Hide();
28327
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 {
28332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28333 }
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28341 PyObject *resultobj = NULL;
28342 wxWindow *arg1 = (wxWindow *) 0 ;
28343 bool arg2 = (bool) true ;
28344 bool result;
28345 PyObject * obj0 = 0 ;
28346 PyObject * obj1 = 0 ;
28347 char *kwnames[] = {
28348 (char *) "self",(char *) "enable", NULL
28349 };
28350
28351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28353 if (SWIG_arg_fail(1)) SWIG_fail;
28354 if (obj1) {
28355 {
28356 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28357 if (SWIG_arg_fail(2)) SWIG_fail;
28358 }
28359 }
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 result = (bool)(arg1)->Enable(arg2);
28363
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 {
28368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28369 }
28370 return resultobj;
28371 fail:
28372 return NULL;
28373 }
28374
28375
28376 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28377 PyObject *resultobj = NULL;
28378 wxWindow *arg1 = (wxWindow *) 0 ;
28379 bool result;
28380 PyObject * obj0 = 0 ;
28381 char *kwnames[] = {
28382 (char *) "self", NULL
28383 };
28384
28385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28387 if (SWIG_arg_fail(1)) SWIG_fail;
28388 {
28389 PyThreadState* __tstate = wxPyBeginAllowThreads();
28390 result = (bool)(arg1)->Disable();
28391
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 {
28396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28397 }
28398 return resultobj;
28399 fail:
28400 return NULL;
28401 }
28402
28403
28404 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj = NULL;
28406 wxWindow *arg1 = (wxWindow *) 0 ;
28407 bool result;
28408 PyObject * obj0 = 0 ;
28409 char *kwnames[] = {
28410 (char *) "self", NULL
28411 };
28412
28413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28415 if (SWIG_arg_fail(1)) SWIG_fail;
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = (bool)((wxWindow const *)arg1)->IsShown();
28419
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 {
28424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28425 }
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj = NULL;
28434 wxWindow *arg1 = (wxWindow *) 0 ;
28435 bool result;
28436 PyObject * obj0 = 0 ;
28437 char *kwnames[] = {
28438 (char *) "self", NULL
28439 };
28440
28441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28443 if (SWIG_arg_fail(1)) SWIG_fail;
28444 {
28445 PyThreadState* __tstate = wxPyBeginAllowThreads();
28446 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28447
28448 wxPyEndAllowThreads(__tstate);
28449 if (PyErr_Occurred()) SWIG_fail;
28450 }
28451 {
28452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28453 }
28454 return resultobj;
28455 fail:
28456 return NULL;
28457 }
28458
28459
28460 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28461 PyObject *resultobj = NULL;
28462 wxWindow *arg1 = (wxWindow *) 0 ;
28463 long arg2 ;
28464 PyObject * obj0 = 0 ;
28465 PyObject * obj1 = 0 ;
28466 char *kwnames[] = {
28467 (char *) "self",(char *) "style", NULL
28468 };
28469
28470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28472 if (SWIG_arg_fail(1)) SWIG_fail;
28473 {
28474 arg2 = static_cast<long >(SWIG_As_long(obj1));
28475 if (SWIG_arg_fail(2)) SWIG_fail;
28476 }
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 (arg1)->SetWindowStyleFlag(arg2);
28480
28481 wxPyEndAllowThreads(__tstate);
28482 if (PyErr_Occurred()) SWIG_fail;
28483 }
28484 Py_INCREF(Py_None); resultobj = Py_None;
28485 return resultobj;
28486 fail:
28487 return NULL;
28488 }
28489
28490
28491 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28492 PyObject *resultobj = NULL;
28493 wxWindow *arg1 = (wxWindow *) 0 ;
28494 long result;
28495 PyObject * obj0 = 0 ;
28496 char *kwnames[] = {
28497 (char *) "self", NULL
28498 };
28499
28500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28502 if (SWIG_arg_fail(1)) SWIG_fail;
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28506
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 {
28511 resultobj = SWIG_From_long(static_cast<long >(result));
28512 }
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj = NULL;
28521 wxWindow *arg1 = (wxWindow *) 0 ;
28522 int arg2 ;
28523 bool result;
28524 PyObject * obj0 = 0 ;
28525 PyObject * obj1 = 0 ;
28526 char *kwnames[] = {
28527 (char *) "self",(char *) "flag", NULL
28528 };
28529
28530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28532 if (SWIG_arg_fail(1)) SWIG_fail;
28533 {
28534 arg2 = static_cast<int >(SWIG_As_int(obj1));
28535 if (SWIG_arg_fail(2)) SWIG_fail;
28536 }
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28540
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 {
28545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28546 }
28547 return resultobj;
28548 fail:
28549 return NULL;
28550 }
28551
28552
28553 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28554 PyObject *resultobj = NULL;
28555 wxWindow *arg1 = (wxWindow *) 0 ;
28556 bool result;
28557 PyObject * obj0 = 0 ;
28558 char *kwnames[] = {
28559 (char *) "self", NULL
28560 };
28561
28562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28564 if (SWIG_arg_fail(1)) SWIG_fail;
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 result = (bool)((wxWindow const *)arg1)->IsRetained();
28568
28569 wxPyEndAllowThreads(__tstate);
28570 if (PyErr_Occurred()) SWIG_fail;
28571 }
28572 {
28573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28574 }
28575 return resultobj;
28576 fail:
28577 return NULL;
28578 }
28579
28580
28581 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28582 PyObject *resultobj = NULL;
28583 wxWindow *arg1 = (wxWindow *) 0 ;
28584 long arg2 ;
28585 PyObject * obj0 = 0 ;
28586 PyObject * obj1 = 0 ;
28587 char *kwnames[] = {
28588 (char *) "self",(char *) "exStyle", NULL
28589 };
28590
28591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28593 if (SWIG_arg_fail(1)) SWIG_fail;
28594 {
28595 arg2 = static_cast<long >(SWIG_As_long(obj1));
28596 if (SWIG_arg_fail(2)) SWIG_fail;
28597 }
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 (arg1)->SetExtraStyle(arg2);
28601
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 Py_INCREF(Py_None); resultobj = Py_None;
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj = NULL;
28614 wxWindow *arg1 = (wxWindow *) 0 ;
28615 long result;
28616 PyObject * obj0 = 0 ;
28617 char *kwnames[] = {
28618 (char *) "self", NULL
28619 };
28620
28621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28623 if (SWIG_arg_fail(1)) SWIG_fail;
28624 {
28625 PyThreadState* __tstate = wxPyBeginAllowThreads();
28626 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28627
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 {
28632 resultobj = SWIG_From_long(static_cast<long >(result));
28633 }
28634 return resultobj;
28635 fail:
28636 return NULL;
28637 }
28638
28639
28640 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28641 PyObject *resultobj = NULL;
28642 wxWindow *arg1 = (wxWindow *) 0 ;
28643 bool arg2 = (bool) true ;
28644 PyObject * obj0 = 0 ;
28645 PyObject * obj1 = 0 ;
28646 char *kwnames[] = {
28647 (char *) "self",(char *) "modal", NULL
28648 };
28649
28650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28652 if (SWIG_arg_fail(1)) SWIG_fail;
28653 if (obj1) {
28654 {
28655 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28656 if (SWIG_arg_fail(2)) SWIG_fail;
28657 }
28658 }
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 (arg1)->MakeModal(arg2);
28662
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 Py_INCREF(Py_None); resultobj = Py_None;
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28674 PyObject *resultobj = NULL;
28675 wxWindow *arg1 = (wxWindow *) 0 ;
28676 bool arg2 ;
28677 PyObject * obj0 = 0 ;
28678 PyObject * obj1 = 0 ;
28679 char *kwnames[] = {
28680 (char *) "self",(char *) "enableTheme", NULL
28681 };
28682
28683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28685 if (SWIG_arg_fail(1)) SWIG_fail;
28686 {
28687 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28688 if (SWIG_arg_fail(2)) SWIG_fail;
28689 }
28690 {
28691 PyThreadState* __tstate = wxPyBeginAllowThreads();
28692 (arg1)->SetThemeEnabled(arg2);
28693
28694 wxPyEndAllowThreads(__tstate);
28695 if (PyErr_Occurred()) SWIG_fail;
28696 }
28697 Py_INCREF(Py_None); resultobj = Py_None;
28698 return resultobj;
28699 fail:
28700 return NULL;
28701 }
28702
28703
28704 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28705 PyObject *resultobj = NULL;
28706 wxWindow *arg1 = (wxWindow *) 0 ;
28707 bool result;
28708 PyObject * obj0 = 0 ;
28709 char *kwnames[] = {
28710 (char *) "self", NULL
28711 };
28712
28713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28715 if (SWIG_arg_fail(1)) SWIG_fail;
28716 {
28717 PyThreadState* __tstate = wxPyBeginAllowThreads();
28718 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28719
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 {
28724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28725 }
28726 return resultobj;
28727 fail:
28728 return NULL;
28729 }
28730
28731
28732 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28733 PyObject *resultobj = NULL;
28734 wxWindow *arg1 = (wxWindow *) 0 ;
28735 PyObject * obj0 = 0 ;
28736 char *kwnames[] = {
28737 (char *) "self", NULL
28738 };
28739
28740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",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 (arg1)->SetFocus();
28746
28747 wxPyEndAllowThreads(__tstate);
28748 if (PyErr_Occurred()) SWIG_fail;
28749 }
28750 Py_INCREF(Py_None); resultobj = Py_None;
28751 return resultobj;
28752 fail:
28753 return NULL;
28754 }
28755
28756
28757 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28758 PyObject *resultobj = NULL;
28759 wxWindow *arg1 = (wxWindow *) 0 ;
28760 PyObject * obj0 = 0 ;
28761 char *kwnames[] = {
28762 (char *) "self", NULL
28763 };
28764
28765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28767 if (SWIG_arg_fail(1)) SWIG_fail;
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 (arg1)->SetFocusFromKbd();
28771
28772 wxPyEndAllowThreads(__tstate);
28773 if (PyErr_Occurred()) SWIG_fail;
28774 }
28775 Py_INCREF(Py_None); resultobj = Py_None;
28776 return resultobj;
28777 fail:
28778 return NULL;
28779 }
28780
28781
28782 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28783 PyObject *resultobj = NULL;
28784 wxWindow *result;
28785 char *kwnames[] = {
28786 NULL
28787 };
28788
28789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28790 {
28791 if (!wxPyCheckForApp()) SWIG_fail;
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = (wxWindow *)wxWindow::FindFocus();
28794
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 {
28799 resultobj = wxPyMake_wxObject(result, 0);
28800 }
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28808 PyObject *resultobj = NULL;
28809 wxWindow *arg1 = (wxWindow *) 0 ;
28810 bool result;
28811 PyObject * obj0 = 0 ;
28812 char *kwnames[] = {
28813 (char *) "self", NULL
28814 };
28815
28816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28818 if (SWIG_arg_fail(1)) SWIG_fail;
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28822
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 {
28827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28828 }
28829 return resultobj;
28830 fail:
28831 return NULL;
28832 }
28833
28834
28835 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj = NULL;
28837 wxWindow *arg1 = (wxWindow *) 0 ;
28838 bool result;
28839 PyObject * obj0 = 0 ;
28840 char *kwnames[] = {
28841 (char *) "self", NULL
28842 };
28843
28844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28846 if (SWIG_arg_fail(1)) SWIG_fail;
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28850
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 {
28855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28856 }
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28864 PyObject *resultobj = NULL;
28865 wxWindow *arg1 = (wxWindow *) 0 ;
28866 wxWindow *result;
28867 PyObject * obj0 = 0 ;
28868 char *kwnames[] = {
28869 (char *) "self", NULL
28870 };
28871
28872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28874 if (SWIG_arg_fail(1)) SWIG_fail;
28875 {
28876 PyThreadState* __tstate = wxPyBeginAllowThreads();
28877 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28878
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 {
28883 resultobj = wxPyMake_wxObject(result, 0);
28884 }
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28892 PyObject *resultobj = NULL;
28893 wxWindow *arg1 = (wxWindow *) 0 ;
28894 wxWindow *arg2 = (wxWindow *) 0 ;
28895 wxWindow *result;
28896 PyObject * obj0 = 0 ;
28897 PyObject * obj1 = 0 ;
28898 char *kwnames[] = {
28899 (char *) "self",(char *) "child", NULL
28900 };
28901
28902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28906 if (SWIG_arg_fail(2)) SWIG_fail;
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28910
28911 wxPyEndAllowThreads(__tstate);
28912 if (PyErr_Occurred()) SWIG_fail;
28913 }
28914 {
28915 resultobj = wxPyMake_wxObject(result, 0);
28916 }
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj = NULL;
28925 wxWindow *arg1 = (wxWindow *) 0 ;
28926 wxWindow *arg2 = (wxWindow *) 0 ;
28927 PyObject * obj0 = 0 ;
28928 PyObject * obj1 = 0 ;
28929 char *kwnames[] = {
28930 (char *) "self",(char *) "win", NULL
28931 };
28932
28933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28935 if (SWIG_arg_fail(1)) SWIG_fail;
28936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28937 if (SWIG_arg_fail(2)) SWIG_fail;
28938 {
28939 PyThreadState* __tstate = wxPyBeginAllowThreads();
28940 (arg1)->SetTmpDefaultItem(arg2);
28941
28942 wxPyEndAllowThreads(__tstate);
28943 if (PyErr_Occurred()) SWIG_fail;
28944 }
28945 Py_INCREF(Py_None); resultobj = Py_None;
28946 return resultobj;
28947 fail:
28948 return NULL;
28949 }
28950
28951
28952 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28953 PyObject *resultobj = NULL;
28954 wxWindow *arg1 = (wxWindow *) 0 ;
28955 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28956 bool result;
28957 PyObject * obj0 = 0 ;
28958 PyObject * obj1 = 0 ;
28959 char *kwnames[] = {
28960 (char *) "self",(char *) "flags", NULL
28961 };
28962
28963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28965 if (SWIG_arg_fail(1)) SWIG_fail;
28966 if (obj1) {
28967 {
28968 arg2 = static_cast<int >(SWIG_As_int(obj1));
28969 if (SWIG_arg_fail(2)) SWIG_fail;
28970 }
28971 }
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 result = (bool)(arg1)->Navigate(arg2);
28975
28976 wxPyEndAllowThreads(__tstate);
28977 if (PyErr_Occurred()) SWIG_fail;
28978 }
28979 {
28980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28981 }
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj = NULL;
28990 wxWindow *arg1 = (wxWindow *) 0 ;
28991 wxWindow *arg2 = (wxWindow *) 0 ;
28992 PyObject * obj0 = 0 ;
28993 PyObject * obj1 = 0 ;
28994 char *kwnames[] = {
28995 (char *) "self",(char *) "win", NULL
28996 };
28997
28998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29000 if (SWIG_arg_fail(1)) SWIG_fail;
29001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29002 if (SWIG_arg_fail(2)) SWIG_fail;
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 (arg1)->MoveAfterInTabOrder(arg2);
29006
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 Py_INCREF(Py_None); resultobj = Py_None;
29011 return resultobj;
29012 fail:
29013 return NULL;
29014 }
29015
29016
29017 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
29018 PyObject *resultobj = NULL;
29019 wxWindow *arg1 = (wxWindow *) 0 ;
29020 wxWindow *arg2 = (wxWindow *) 0 ;
29021 PyObject * obj0 = 0 ;
29022 PyObject * obj1 = 0 ;
29023 char *kwnames[] = {
29024 (char *) "self",(char *) "win", NULL
29025 };
29026
29027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
29028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29029 if (SWIG_arg_fail(1)) SWIG_fail;
29030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29031 if (SWIG_arg_fail(2)) SWIG_fail;
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 (arg1)->MoveBeforeInTabOrder(arg2);
29035
29036 wxPyEndAllowThreads(__tstate);
29037 if (PyErr_Occurred()) SWIG_fail;
29038 }
29039 Py_INCREF(Py_None); resultobj = Py_None;
29040 return resultobj;
29041 fail:
29042 return NULL;
29043 }
29044
29045
29046 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
29047 PyObject *resultobj = NULL;
29048 wxWindow *arg1 = (wxWindow *) 0 ;
29049 PyObject *result;
29050 PyObject * obj0 = 0 ;
29051 char *kwnames[] = {
29052 (char *) "self", NULL
29053 };
29054
29055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
29056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29057 if (SWIG_arg_fail(1)) SWIG_fail;
29058 {
29059 PyThreadState* __tstate = wxPyBeginAllowThreads();
29060 result = (PyObject *)wxWindow_GetChildren(arg1);
29061
29062 wxPyEndAllowThreads(__tstate);
29063 if (PyErr_Occurred()) SWIG_fail;
29064 }
29065 resultobj = result;
29066 return resultobj;
29067 fail:
29068 return NULL;
29069 }
29070
29071
29072 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
29073 PyObject *resultobj = NULL;
29074 wxWindow *arg1 = (wxWindow *) 0 ;
29075 wxWindow *result;
29076 PyObject * obj0 = 0 ;
29077 char *kwnames[] = {
29078 (char *) "self", NULL
29079 };
29080
29081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
29082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29083 if (SWIG_arg_fail(1)) SWIG_fail;
29084 {
29085 PyThreadState* __tstate = wxPyBeginAllowThreads();
29086 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
29087
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 {
29092 resultobj = wxPyMake_wxObject(result, 0);
29093 }
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
29101 PyObject *resultobj = NULL;
29102 wxWindow *arg1 = (wxWindow *) 0 ;
29103 wxWindow *result;
29104 PyObject * obj0 = 0 ;
29105 char *kwnames[] = {
29106 (char *) "self", NULL
29107 };
29108
29109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
29110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29111 if (SWIG_arg_fail(1)) SWIG_fail;
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
29115
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 {
29120 resultobj = wxPyMake_wxObject(result, 0);
29121 }
29122 return resultobj;
29123 fail:
29124 return NULL;
29125 }
29126
29127
29128 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
29129 PyObject *resultobj = NULL;
29130 wxWindow *arg1 = (wxWindow *) 0 ;
29131 bool result;
29132 PyObject * obj0 = 0 ;
29133 char *kwnames[] = {
29134 (char *) "self", NULL
29135 };
29136
29137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29139 if (SWIG_arg_fail(1)) SWIG_fail;
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29143
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 {
29148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29149 }
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29157 PyObject *resultobj = NULL;
29158 wxWindow *arg1 = (wxWindow *) 0 ;
29159 wxWindow *arg2 = (wxWindow *) 0 ;
29160 bool result;
29161 PyObject * obj0 = 0 ;
29162 PyObject * obj1 = 0 ;
29163 char *kwnames[] = {
29164 (char *) "self",(char *) "newParent", NULL
29165 };
29166
29167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29169 if (SWIG_arg_fail(1)) SWIG_fail;
29170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29171 if (SWIG_arg_fail(2)) SWIG_fail;
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = (bool)(arg1)->Reparent(arg2);
29175
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 {
29180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29181 }
29182 return resultobj;
29183 fail:
29184 return NULL;
29185 }
29186
29187
29188 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29189 PyObject *resultobj = NULL;
29190 wxWindow *arg1 = (wxWindow *) 0 ;
29191 wxWindow *arg2 = (wxWindow *) 0 ;
29192 PyObject * obj0 = 0 ;
29193 PyObject * obj1 = 0 ;
29194 char *kwnames[] = {
29195 (char *) "self",(char *) "child", NULL
29196 };
29197
29198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29200 if (SWIG_arg_fail(1)) SWIG_fail;
29201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29202 if (SWIG_arg_fail(2)) SWIG_fail;
29203 {
29204 PyThreadState* __tstate = wxPyBeginAllowThreads();
29205 (arg1)->AddChild(arg2);
29206
29207 wxPyEndAllowThreads(__tstate);
29208 if (PyErr_Occurred()) SWIG_fail;
29209 }
29210 Py_INCREF(Py_None); resultobj = Py_None;
29211 return resultobj;
29212 fail:
29213 return NULL;
29214 }
29215
29216
29217 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29218 PyObject *resultobj = NULL;
29219 wxWindow *arg1 = (wxWindow *) 0 ;
29220 wxWindow *arg2 = (wxWindow *) 0 ;
29221 PyObject * obj0 = 0 ;
29222 PyObject * obj1 = 0 ;
29223 char *kwnames[] = {
29224 (char *) "self",(char *) "child", NULL
29225 };
29226
29227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29229 if (SWIG_arg_fail(1)) SWIG_fail;
29230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29231 if (SWIG_arg_fail(2)) SWIG_fail;
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 (arg1)->RemoveChild(arg2);
29235
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 Py_INCREF(Py_None); resultobj = Py_None;
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj = NULL;
29248 wxWindow *arg1 = (wxWindow *) 0 ;
29249 long arg2 ;
29250 wxWindow *result;
29251 PyObject * obj0 = 0 ;
29252 PyObject * obj1 = 0 ;
29253 char *kwnames[] = {
29254 (char *) "self",(char *) "winid", NULL
29255 };
29256
29257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29259 if (SWIG_arg_fail(1)) SWIG_fail;
29260 {
29261 arg2 = static_cast<long >(SWIG_As_long(obj1));
29262 if (SWIG_arg_fail(2)) SWIG_fail;
29263 }
29264 {
29265 PyThreadState* __tstate = wxPyBeginAllowThreads();
29266 result = (wxWindow *)(arg1)->FindWindow(arg2);
29267
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 {
29272 resultobj = wxPyMake_wxObject(result, 0);
29273 }
29274 return resultobj;
29275 fail:
29276 return NULL;
29277 }
29278
29279
29280 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29281 PyObject *resultobj = NULL;
29282 wxWindow *arg1 = (wxWindow *) 0 ;
29283 wxString *arg2 = 0 ;
29284 wxWindow *result;
29285 bool temp2 = false ;
29286 PyObject * obj0 = 0 ;
29287 PyObject * obj1 = 0 ;
29288 char *kwnames[] = {
29289 (char *) "self",(char *) "name", NULL
29290 };
29291
29292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29294 if (SWIG_arg_fail(1)) SWIG_fail;
29295 {
29296 arg2 = wxString_in_helper(obj1);
29297 if (arg2 == NULL) SWIG_fail;
29298 temp2 = true;
29299 }
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29303
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 {
29308 resultobj = wxPyMake_wxObject(result, 0);
29309 }
29310 {
29311 if (temp2)
29312 delete arg2;
29313 }
29314 return resultobj;
29315 fail:
29316 {
29317 if (temp2)
29318 delete arg2;
29319 }
29320 return NULL;
29321 }
29322
29323
29324 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj = NULL;
29326 wxWindow *arg1 = (wxWindow *) 0 ;
29327 wxEvtHandler *result;
29328 PyObject * obj0 = 0 ;
29329 char *kwnames[] = {
29330 (char *) "self", NULL
29331 };
29332
29333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29335 if (SWIG_arg_fail(1)) SWIG_fail;
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29339
29340 wxPyEndAllowThreads(__tstate);
29341 if (PyErr_Occurred()) SWIG_fail;
29342 }
29343 {
29344 resultobj = wxPyMake_wxObject(result, 0);
29345 }
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj = NULL;
29354 wxWindow *arg1 = (wxWindow *) 0 ;
29355 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29356 PyObject * obj0 = 0 ;
29357 PyObject * obj1 = 0 ;
29358 char *kwnames[] = {
29359 (char *) "self",(char *) "handler", NULL
29360 };
29361
29362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29364 if (SWIG_arg_fail(1)) SWIG_fail;
29365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29366 if (SWIG_arg_fail(2)) SWIG_fail;
29367 {
29368 PyThreadState* __tstate = wxPyBeginAllowThreads();
29369 (arg1)->SetEventHandler(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_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29382 PyObject *resultobj = NULL;
29383 wxWindow *arg1 = (wxWindow *) 0 ;
29384 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29385 PyObject * obj0 = 0 ;
29386 PyObject * obj1 = 0 ;
29387 char *kwnames[] = {
29388 (char *) "self",(char *) "handler", NULL
29389 };
29390
29391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29393 if (SWIG_arg_fail(1)) SWIG_fail;
29394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29395 if (SWIG_arg_fail(2)) SWIG_fail;
29396 {
29397 PyThreadState* __tstate = wxPyBeginAllowThreads();
29398 (arg1)->PushEventHandler(arg2);
29399
29400 wxPyEndAllowThreads(__tstate);
29401 if (PyErr_Occurred()) SWIG_fail;
29402 }
29403 Py_INCREF(Py_None); resultobj = Py_None;
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29411 PyObject *resultobj = NULL;
29412 wxWindow *arg1 = (wxWindow *) 0 ;
29413 bool arg2 = (bool) false ;
29414 wxEvtHandler *result;
29415 PyObject * obj0 = 0 ;
29416 PyObject * obj1 = 0 ;
29417 char *kwnames[] = {
29418 (char *) "self",(char *) "deleteHandler", NULL
29419 };
29420
29421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29423 if (SWIG_arg_fail(1)) SWIG_fail;
29424 if (obj1) {
29425 {
29426 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29427 if (SWIG_arg_fail(2)) SWIG_fail;
29428 }
29429 }
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29433
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = wxPyMake_wxObject(result, 0);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = NULL;
29448 wxWindow *arg1 = (wxWindow *) 0 ;
29449 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29450 bool result;
29451 PyObject * obj0 = 0 ;
29452 PyObject * obj1 = 0 ;
29453 char *kwnames[] = {
29454 (char *) "self",(char *) "handler", NULL
29455 };
29456
29457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(1)) SWIG_fail;
29460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29461 if (SWIG_arg_fail(2)) SWIG_fail;
29462 {
29463 PyThreadState* __tstate = wxPyBeginAllowThreads();
29464 result = (bool)(arg1)->RemoveEventHandler(arg2);
29465
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 {
29470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29471 }
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj = NULL;
29480 wxWindow *arg1 = (wxWindow *) 0 ;
29481 wxValidator *arg2 = 0 ;
29482 PyObject * obj0 = 0 ;
29483 PyObject * obj1 = 0 ;
29484 char *kwnames[] = {
29485 (char *) "self",(char *) "validator", NULL
29486 };
29487
29488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29490 if (SWIG_arg_fail(1)) SWIG_fail;
29491 {
29492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29493 if (SWIG_arg_fail(2)) SWIG_fail;
29494 if (arg2 == NULL) {
29495 SWIG_null_ref("wxValidator");
29496 }
29497 if (SWIG_arg_fail(2)) SWIG_fail;
29498 }
29499 {
29500 PyThreadState* __tstate = wxPyBeginAllowThreads();
29501 (arg1)->SetValidator((wxValidator const &)*arg2);
29502
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 Py_INCREF(Py_None); resultobj = Py_None;
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj = NULL;
29515 wxWindow *arg1 = (wxWindow *) 0 ;
29516 wxValidator *result;
29517 PyObject * obj0 = 0 ;
29518 char *kwnames[] = {
29519 (char *) "self", NULL
29520 };
29521
29522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29524 if (SWIG_arg_fail(1)) SWIG_fail;
29525 {
29526 PyThreadState* __tstate = wxPyBeginAllowThreads();
29527 result = (wxValidator *)(arg1)->GetValidator();
29528
29529 wxPyEndAllowThreads(__tstate);
29530 if (PyErr_Occurred()) SWIG_fail;
29531 }
29532 {
29533 resultobj = wxPyMake_wxObject(result, (bool)0);
29534 }
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29542 PyObject *resultobj = NULL;
29543 wxWindow *arg1 = (wxWindow *) 0 ;
29544 bool result;
29545 PyObject * obj0 = 0 ;
29546 char *kwnames[] = {
29547 (char *) "self", NULL
29548 };
29549
29550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29552 if (SWIG_arg_fail(1)) SWIG_fail;
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (bool)(arg1)->Validate();
29556
29557 wxPyEndAllowThreads(__tstate);
29558 if (PyErr_Occurred()) SWIG_fail;
29559 }
29560 {
29561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29562 }
29563 return resultobj;
29564 fail:
29565 return NULL;
29566 }
29567
29568
29569 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29570 PyObject *resultobj = NULL;
29571 wxWindow *arg1 = (wxWindow *) 0 ;
29572 bool result;
29573 PyObject * obj0 = 0 ;
29574 char *kwnames[] = {
29575 (char *) "self", NULL
29576 };
29577
29578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29580 if (SWIG_arg_fail(1)) SWIG_fail;
29581 {
29582 PyThreadState* __tstate = wxPyBeginAllowThreads();
29583 result = (bool)(arg1)->TransferDataToWindow();
29584
29585 wxPyEndAllowThreads(__tstate);
29586 if (PyErr_Occurred()) SWIG_fail;
29587 }
29588 {
29589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29590 }
29591 return resultobj;
29592 fail:
29593 return NULL;
29594 }
29595
29596
29597 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29598 PyObject *resultobj = NULL;
29599 wxWindow *arg1 = (wxWindow *) 0 ;
29600 bool result;
29601 PyObject * obj0 = 0 ;
29602 char *kwnames[] = {
29603 (char *) "self", NULL
29604 };
29605
29606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29608 if (SWIG_arg_fail(1)) SWIG_fail;
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (bool)(arg1)->TransferDataFromWindow();
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_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29626 PyObject *resultobj = NULL;
29627 wxWindow *arg1 = (wxWindow *) 0 ;
29628 PyObject * obj0 = 0 ;
29629 char *kwnames[] = {
29630 (char *) "self", NULL
29631 };
29632
29633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29635 if (SWIG_arg_fail(1)) SWIG_fail;
29636 {
29637 PyThreadState* __tstate = wxPyBeginAllowThreads();
29638 (arg1)->InitDialog();
29639
29640 wxPyEndAllowThreads(__tstate);
29641 if (PyErr_Occurred()) SWIG_fail;
29642 }
29643 Py_INCREF(Py_None); resultobj = Py_None;
29644 return resultobj;
29645 fail:
29646 return NULL;
29647 }
29648
29649
29650 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29651 PyObject *resultobj = NULL;
29652 wxWindow *arg1 = (wxWindow *) 0 ;
29653 wxAcceleratorTable *arg2 = 0 ;
29654 PyObject * obj0 = 0 ;
29655 PyObject * obj1 = 0 ;
29656 char *kwnames[] = {
29657 (char *) "self",(char *) "accel", NULL
29658 };
29659
29660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29662 if (SWIG_arg_fail(1)) SWIG_fail;
29663 {
29664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29665 if (SWIG_arg_fail(2)) SWIG_fail;
29666 if (arg2 == NULL) {
29667 SWIG_null_ref("wxAcceleratorTable");
29668 }
29669 if (SWIG_arg_fail(2)) SWIG_fail;
29670 }
29671 {
29672 PyThreadState* __tstate = wxPyBeginAllowThreads();
29673 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29674
29675 wxPyEndAllowThreads(__tstate);
29676 if (PyErr_Occurred()) SWIG_fail;
29677 }
29678 Py_INCREF(Py_None); resultobj = Py_None;
29679 return resultobj;
29680 fail:
29681 return NULL;
29682 }
29683
29684
29685 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29686 PyObject *resultobj = NULL;
29687 wxWindow *arg1 = (wxWindow *) 0 ;
29688 wxAcceleratorTable *result;
29689 PyObject * obj0 = 0 ;
29690 char *kwnames[] = {
29691 (char *) "self", NULL
29692 };
29693
29694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29696 if (SWIG_arg_fail(1)) SWIG_fail;
29697 {
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29700
29701 wxPyEndAllowThreads(__tstate);
29702 if (PyErr_Occurred()) SWIG_fail;
29703 }
29704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = NULL;
29713 wxWindow *arg1 = (wxWindow *) 0 ;
29714 int arg2 ;
29715 int arg3 ;
29716 int arg4 ;
29717 bool result;
29718 PyObject * obj0 = 0 ;
29719 PyObject * obj1 = 0 ;
29720 PyObject * obj2 = 0 ;
29721 PyObject * obj3 = 0 ;
29722 char *kwnames[] = {
29723 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29724 };
29725
29726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29728 if (SWIG_arg_fail(1)) SWIG_fail;
29729 {
29730 arg2 = static_cast<int >(SWIG_As_int(obj1));
29731 if (SWIG_arg_fail(2)) SWIG_fail;
29732 }
29733 {
29734 arg3 = static_cast<int >(SWIG_As_int(obj2));
29735 if (SWIG_arg_fail(3)) SWIG_fail;
29736 }
29737 {
29738 arg4 = static_cast<int >(SWIG_As_int(obj3));
29739 if (SWIG_arg_fail(4)) SWIG_fail;
29740 }
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29744
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 {
29749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29750 }
29751 return resultobj;
29752 fail:
29753 return NULL;
29754 }
29755
29756
29757 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj = NULL;
29759 wxWindow *arg1 = (wxWindow *) 0 ;
29760 int arg2 ;
29761 bool result;
29762 PyObject * obj0 = 0 ;
29763 PyObject * obj1 = 0 ;
29764 char *kwnames[] = {
29765 (char *) "self",(char *) "hotkeyId", NULL
29766 };
29767
29768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29770 if (SWIG_arg_fail(1)) SWIG_fail;
29771 {
29772 arg2 = static_cast<int >(SWIG_As_int(obj1));
29773 if (SWIG_arg_fail(2)) SWIG_fail;
29774 }
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29778
29779 wxPyEndAllowThreads(__tstate);
29780 if (PyErr_Occurred()) SWIG_fail;
29781 }
29782 {
29783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29784 }
29785 return resultobj;
29786 fail:
29787 return NULL;
29788 }
29789
29790
29791 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29792 PyObject *resultobj = NULL;
29793 wxWindow *arg1 = (wxWindow *) 0 ;
29794 wxPoint *arg2 = 0 ;
29795 wxPoint result;
29796 wxPoint temp2 ;
29797 PyObject * obj0 = 0 ;
29798 PyObject * obj1 = 0 ;
29799 char *kwnames[] = {
29800 (char *) "self",(char *) "pt", NULL
29801 };
29802
29803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29805 if (SWIG_arg_fail(1)) SWIG_fail;
29806 {
29807 arg2 = &temp2;
29808 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29809 }
29810 {
29811 PyThreadState* __tstate = wxPyBeginAllowThreads();
29812 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29813
29814 wxPyEndAllowThreads(__tstate);
29815 if (PyErr_Occurred()) SWIG_fail;
29816 }
29817 {
29818 wxPoint * resultptr;
29819 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29820 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29821 }
29822 return resultobj;
29823 fail:
29824 return NULL;
29825 }
29826
29827
29828 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29829 PyObject *resultobj = NULL;
29830 wxWindow *arg1 = (wxWindow *) 0 ;
29831 wxSize *arg2 = 0 ;
29832 wxSize result;
29833 wxSize temp2 ;
29834 PyObject * obj0 = 0 ;
29835 PyObject * obj1 = 0 ;
29836 char *kwnames[] = {
29837 (char *) "self",(char *) "sz", NULL
29838 };
29839
29840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29842 if (SWIG_arg_fail(1)) SWIG_fail;
29843 {
29844 arg2 = &temp2;
29845 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29846 }
29847 {
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29850
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 {
29855 wxSize * resultptr;
29856 resultptr = new wxSize(static_cast<wxSize & >(result));
29857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29858 }
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29866 PyObject *resultobj = NULL;
29867 wxWindow *arg1 = (wxWindow *) 0 ;
29868 wxPoint *arg2 = 0 ;
29869 wxPoint result;
29870 wxPoint temp2 ;
29871 PyObject * obj0 = 0 ;
29872 PyObject * obj1 = 0 ;
29873 char *kwnames[] = {
29874 (char *) "self",(char *) "pt", NULL
29875 };
29876
29877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29879 if (SWIG_arg_fail(1)) SWIG_fail;
29880 {
29881 arg2 = &temp2;
29882 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29883 }
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29887
29888 wxPyEndAllowThreads(__tstate);
29889 if (PyErr_Occurred()) SWIG_fail;
29890 }
29891 {
29892 wxPoint * resultptr;
29893 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29895 }
29896 return resultobj;
29897 fail:
29898 return NULL;
29899 }
29900
29901
29902 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29903 PyObject *resultobj = NULL;
29904 wxWindow *arg1 = (wxWindow *) 0 ;
29905 wxSize *arg2 = 0 ;
29906 wxSize result;
29907 wxSize temp2 ;
29908 PyObject * obj0 = 0 ;
29909 PyObject * obj1 = 0 ;
29910 char *kwnames[] = {
29911 (char *) "self",(char *) "sz", NULL
29912 };
29913
29914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29916 if (SWIG_arg_fail(1)) SWIG_fail;
29917 {
29918 arg2 = &temp2;
29919 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29920 }
29921 {
29922 PyThreadState* __tstate = wxPyBeginAllowThreads();
29923 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29924
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 {
29929 wxSize * resultptr;
29930 resultptr = new wxSize(static_cast<wxSize & >(result));
29931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29932 }
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29940 PyObject *resultobj = NULL;
29941 wxWindow *arg1 = (wxWindow *) 0 ;
29942 wxPoint *arg2 = 0 ;
29943 wxPoint result;
29944 wxPoint temp2 ;
29945 PyObject * obj0 = 0 ;
29946 PyObject * obj1 = 0 ;
29947 char *kwnames[] = {
29948 (char *) "self",(char *) "pt", NULL
29949 };
29950
29951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
29956 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29957 }
29958 {
29959 PyThreadState* __tstate = wxPyBeginAllowThreads();
29960 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29961
29962 wxPyEndAllowThreads(__tstate);
29963 if (PyErr_Occurred()) SWIG_fail;
29964 }
29965 {
29966 wxPoint * resultptr;
29967 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29968 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29969 }
29970 return resultobj;
29971 fail:
29972 return NULL;
29973 }
29974
29975
29976 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29977 PyObject *resultobj = NULL;
29978 wxWindow *arg1 = (wxWindow *) 0 ;
29979 wxSize *arg2 = 0 ;
29980 wxSize result;
29981 wxSize temp2 ;
29982 PyObject * obj0 = 0 ;
29983 PyObject * obj1 = 0 ;
29984 char *kwnames[] = {
29985 (char *) "self",(char *) "sz", NULL
29986 };
29987
29988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29990 if (SWIG_arg_fail(1)) SWIG_fail;
29991 {
29992 arg2 = &temp2;
29993 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29994 }
29995 {
29996 PyThreadState* __tstate = wxPyBeginAllowThreads();
29997 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29998
29999 wxPyEndAllowThreads(__tstate);
30000 if (PyErr_Occurred()) SWIG_fail;
30001 }
30002 {
30003 wxSize * resultptr;
30004 resultptr = new wxSize(static_cast<wxSize & >(result));
30005 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
30006 }
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
30014 PyObject *resultobj = NULL;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 int arg2 ;
30017 int arg3 ;
30018 PyObject * obj0 = 0 ;
30019 PyObject * obj1 = 0 ;
30020 PyObject * obj2 = 0 ;
30021 char *kwnames[] = {
30022 (char *) "self",(char *) "x",(char *) "y", NULL
30023 };
30024
30025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
30026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(1)) SWIG_fail;
30028 {
30029 arg2 = static_cast<int >(SWIG_As_int(obj1));
30030 if (SWIG_arg_fail(2)) SWIG_fail;
30031 }
30032 {
30033 arg3 = static_cast<int >(SWIG_As_int(obj2));
30034 if (SWIG_arg_fail(3)) SWIG_fail;
30035 }
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 (arg1)->WarpPointer(arg2,arg3);
30039
30040 wxPyEndAllowThreads(__tstate);
30041 if (PyErr_Occurred()) SWIG_fail;
30042 }
30043 Py_INCREF(Py_None); resultobj = Py_None;
30044 return resultobj;
30045 fail:
30046 return NULL;
30047 }
30048
30049
30050 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
30051 PyObject *resultobj = NULL;
30052 wxWindow *arg1 = (wxWindow *) 0 ;
30053 PyObject * obj0 = 0 ;
30054 char *kwnames[] = {
30055 (char *) "self", NULL
30056 };
30057
30058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
30059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30060 if (SWIG_arg_fail(1)) SWIG_fail;
30061 {
30062 PyThreadState* __tstate = wxPyBeginAllowThreads();
30063 (arg1)->CaptureMouse();
30064
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 Py_INCREF(Py_None); resultobj = Py_None;
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj = NULL;
30077 wxWindow *arg1 = (wxWindow *) 0 ;
30078 PyObject * obj0 = 0 ;
30079 char *kwnames[] = {
30080 (char *) "self", NULL
30081 };
30082
30083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
30084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30085 if (SWIG_arg_fail(1)) SWIG_fail;
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 (arg1)->ReleaseMouse();
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_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30101 PyObject *resultobj = NULL;
30102 wxWindow *result;
30103 char *kwnames[] = {
30104 NULL
30105 };
30106
30107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
30108 {
30109 if (!wxPyCheckForApp()) SWIG_fail;
30110 PyThreadState* __tstate = wxPyBeginAllowThreads();
30111 result = (wxWindow *)wxWindow::GetCapture();
30112
30113 wxPyEndAllowThreads(__tstate);
30114 if (PyErr_Occurred()) SWIG_fail;
30115 }
30116 {
30117 resultobj = wxPyMake_wxObject(result, 0);
30118 }
30119 return resultobj;
30120 fail:
30121 return NULL;
30122 }
30123
30124
30125 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj = NULL;
30127 wxWindow *arg1 = (wxWindow *) 0 ;
30128 bool result;
30129 PyObject * obj0 = 0 ;
30130 char *kwnames[] = {
30131 (char *) "self", NULL
30132 };
30133
30134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
30135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30136 if (SWIG_arg_fail(1)) SWIG_fail;
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 result = (bool)((wxWindow const *)arg1)->HasCapture();
30140
30141 wxPyEndAllowThreads(__tstate);
30142 if (PyErr_Occurred()) SWIG_fail;
30143 }
30144 {
30145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30146 }
30147 return resultobj;
30148 fail:
30149 return NULL;
30150 }
30151
30152
30153 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30154 PyObject *resultobj = NULL;
30155 wxWindow *arg1 = (wxWindow *) 0 ;
30156 bool arg2 = (bool) true ;
30157 wxRect *arg3 = (wxRect *) NULL ;
30158 PyObject * obj0 = 0 ;
30159 PyObject * obj1 = 0 ;
30160 PyObject * obj2 = 0 ;
30161 char *kwnames[] = {
30162 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30163 };
30164
30165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30167 if (SWIG_arg_fail(1)) SWIG_fail;
30168 if (obj1) {
30169 {
30170 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30171 if (SWIG_arg_fail(2)) SWIG_fail;
30172 }
30173 }
30174 if (obj2) {
30175 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30176 if (SWIG_arg_fail(3)) SWIG_fail;
30177 }
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30181
30182 wxPyEndAllowThreads(__tstate);
30183 if (PyErr_Occurred()) SWIG_fail;
30184 }
30185 Py_INCREF(Py_None); resultobj = Py_None;
30186 return resultobj;
30187 fail:
30188 return NULL;
30189 }
30190
30191
30192 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30193 PyObject *resultobj = NULL;
30194 wxWindow *arg1 = (wxWindow *) 0 ;
30195 wxRect *arg2 = 0 ;
30196 bool arg3 = (bool) true ;
30197 wxRect temp2 ;
30198 PyObject * obj0 = 0 ;
30199 PyObject * obj1 = 0 ;
30200 PyObject * obj2 = 0 ;
30201 char *kwnames[] = {
30202 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30203 };
30204
30205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30207 if (SWIG_arg_fail(1)) SWIG_fail;
30208 {
30209 arg2 = &temp2;
30210 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30211 }
30212 if (obj2) {
30213 {
30214 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30215 if (SWIG_arg_fail(3)) SWIG_fail;
30216 }
30217 }
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30221
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 Py_INCREF(Py_None); resultobj = Py_None;
30226 return resultobj;
30227 fail:
30228 return NULL;
30229 }
30230
30231
30232 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30233 PyObject *resultobj = NULL;
30234 wxWindow *arg1 = (wxWindow *) 0 ;
30235 PyObject * obj0 = 0 ;
30236 char *kwnames[] = {
30237 (char *) "self", NULL
30238 };
30239
30240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30242 if (SWIG_arg_fail(1)) SWIG_fail;
30243 {
30244 PyThreadState* __tstate = wxPyBeginAllowThreads();
30245 (arg1)->Update();
30246
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 Py_INCREF(Py_None); resultobj = Py_None;
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30258 PyObject *resultobj = NULL;
30259 wxWindow *arg1 = (wxWindow *) 0 ;
30260 PyObject * obj0 = 0 ;
30261 char *kwnames[] = {
30262 (char *) "self", NULL
30263 };
30264
30265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30267 if (SWIG_arg_fail(1)) SWIG_fail;
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 (arg1)->ClearBackground();
30271
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 Py_INCREF(Py_None); resultobj = Py_None;
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30283 PyObject *resultobj = NULL;
30284 wxWindow *arg1 = (wxWindow *) 0 ;
30285 PyObject * obj0 = 0 ;
30286 char *kwnames[] = {
30287 (char *) "self", NULL
30288 };
30289
30290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30292 if (SWIG_arg_fail(1)) SWIG_fail;
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 (arg1)->Freeze();
30296
30297 wxPyEndAllowThreads(__tstate);
30298 if (PyErr_Occurred()) SWIG_fail;
30299 }
30300 Py_INCREF(Py_None); resultobj = Py_None;
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30308 PyObject *resultobj = NULL;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 PyObject * obj0 = 0 ;
30311 char *kwnames[] = {
30312 (char *) "self", NULL
30313 };
30314
30315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30317 if (SWIG_arg_fail(1)) SWIG_fail;
30318 {
30319 PyThreadState* __tstate = wxPyBeginAllowThreads();
30320 (arg1)->Thaw();
30321
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 Py_INCREF(Py_None); resultobj = Py_None;
30326 return resultobj;
30327 fail:
30328 return NULL;
30329 }
30330
30331
30332 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30333 PyObject *resultobj = NULL;
30334 wxWindow *arg1 = (wxWindow *) 0 ;
30335 wxDC *arg2 = 0 ;
30336 PyObject * obj0 = 0 ;
30337 PyObject * obj1 = 0 ;
30338 char *kwnames[] = {
30339 (char *) "self",(char *) "dc", NULL
30340 };
30341
30342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30344 if (SWIG_arg_fail(1)) SWIG_fail;
30345 {
30346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30347 if (SWIG_arg_fail(2)) SWIG_fail;
30348 if (arg2 == NULL) {
30349 SWIG_null_ref("wxDC");
30350 }
30351 if (SWIG_arg_fail(2)) SWIG_fail;
30352 }
30353 {
30354 PyThreadState* __tstate = wxPyBeginAllowThreads();
30355 (arg1)->PrepareDC(*arg2);
30356
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 Py_INCREF(Py_None); resultobj = Py_None;
30361 return resultobj;
30362 fail:
30363 return NULL;
30364 }
30365
30366
30367 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30368 PyObject *resultobj = NULL;
30369 wxWindow *arg1 = (wxWindow *) 0 ;
30370 wxRegion *result;
30371 PyObject * obj0 = 0 ;
30372 char *kwnames[] = {
30373 (char *) "self", NULL
30374 };
30375
30376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30378 if (SWIG_arg_fail(1)) SWIG_fail;
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 {
30382 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30383 result = (wxRegion *) &_result_ref;
30384 }
30385
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj = NULL;
30398 wxWindow *arg1 = (wxWindow *) 0 ;
30399 wxRect result;
30400 PyObject * obj0 = 0 ;
30401 char *kwnames[] = {
30402 (char *) "self", NULL
30403 };
30404
30405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30407 if (SWIG_arg_fail(1)) SWIG_fail;
30408 {
30409 PyThreadState* __tstate = wxPyBeginAllowThreads();
30410 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30411
30412 wxPyEndAllowThreads(__tstate);
30413 if (PyErr_Occurred()) SWIG_fail;
30414 }
30415 {
30416 wxRect * resultptr;
30417 resultptr = new wxRect(static_cast<wxRect & >(result));
30418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30419 }
30420 return resultobj;
30421 fail:
30422 return NULL;
30423 }
30424
30425
30426 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30427 PyObject *resultobj = NULL;
30428 wxWindow *arg1 = (wxWindow *) 0 ;
30429 int arg2 ;
30430 int arg3 ;
30431 int arg4 = (int) 1 ;
30432 int arg5 = (int) 1 ;
30433 bool result;
30434 PyObject * obj0 = 0 ;
30435 PyObject * obj1 = 0 ;
30436 PyObject * obj2 = 0 ;
30437 PyObject * obj3 = 0 ;
30438 PyObject * obj4 = 0 ;
30439 char *kwnames[] = {
30440 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30441 };
30442
30443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30445 if (SWIG_arg_fail(1)) SWIG_fail;
30446 {
30447 arg2 = static_cast<int >(SWIG_As_int(obj1));
30448 if (SWIG_arg_fail(2)) SWIG_fail;
30449 }
30450 {
30451 arg3 = static_cast<int >(SWIG_As_int(obj2));
30452 if (SWIG_arg_fail(3)) SWIG_fail;
30453 }
30454 if (obj3) {
30455 {
30456 arg4 = static_cast<int >(SWIG_As_int(obj3));
30457 if (SWIG_arg_fail(4)) SWIG_fail;
30458 }
30459 }
30460 if (obj4) {
30461 {
30462 arg5 = static_cast<int >(SWIG_As_int(obj4));
30463 if (SWIG_arg_fail(5)) SWIG_fail;
30464 }
30465 }
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30469
30470 wxPyEndAllowThreads(__tstate);
30471 if (PyErr_Occurred()) SWIG_fail;
30472 }
30473 {
30474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30475 }
30476 return resultobj;
30477 fail:
30478 return NULL;
30479 }
30480
30481
30482 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30483 PyObject *resultobj = NULL;
30484 wxWindow *arg1 = (wxWindow *) 0 ;
30485 wxPoint *arg2 = 0 ;
30486 bool result;
30487 wxPoint temp2 ;
30488 PyObject * obj0 = 0 ;
30489 PyObject * obj1 = 0 ;
30490 char *kwnames[] = {
30491 (char *) "self",(char *) "pt", NULL
30492 };
30493
30494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30496 if (SWIG_arg_fail(1)) SWIG_fail;
30497 {
30498 arg2 = &temp2;
30499 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30500 }
30501 {
30502 PyThreadState* __tstate = wxPyBeginAllowThreads();
30503 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30504
30505 wxPyEndAllowThreads(__tstate);
30506 if (PyErr_Occurred()) SWIG_fail;
30507 }
30508 {
30509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30510 }
30511 return resultobj;
30512 fail:
30513 return NULL;
30514 }
30515
30516
30517 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30518 PyObject *resultobj = NULL;
30519 wxWindow *arg1 = (wxWindow *) 0 ;
30520 wxRect *arg2 = 0 ;
30521 bool result;
30522 wxRect temp2 ;
30523 PyObject * obj0 = 0 ;
30524 PyObject * obj1 = 0 ;
30525 char *kwnames[] = {
30526 (char *) "self",(char *) "rect", NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30531 if (SWIG_arg_fail(1)) SWIG_fail;
30532 {
30533 arg2 = &temp2;
30534 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30535 }
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30539
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 {
30544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj = NULL;
30554 wxWindow *arg1 = (wxWindow *) 0 ;
30555 wxVisualAttributes result;
30556 PyObject * obj0 = 0 ;
30557 char *kwnames[] = {
30558 (char *) "self", NULL
30559 };
30560
30561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30563 if (SWIG_arg_fail(1)) SWIG_fail;
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30567
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 {
30572 wxVisualAttributes * resultptr;
30573 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30575 }
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30583 PyObject *resultobj = NULL;
30584 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30585 wxVisualAttributes result;
30586 PyObject * obj0 = 0 ;
30587 char *kwnames[] = {
30588 (char *) "variant", NULL
30589 };
30590
30591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30592 if (obj0) {
30593 {
30594 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30595 if (SWIG_arg_fail(1)) SWIG_fail;
30596 }
30597 }
30598 {
30599 if (!wxPyCheckForApp()) SWIG_fail;
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 result = wxWindow::GetClassDefaultAttributes(arg1);
30602
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 {
30607 wxVisualAttributes * resultptr;
30608 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30610 }
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj = NULL;
30619 wxWindow *arg1 = (wxWindow *) 0 ;
30620 wxColour *arg2 = 0 ;
30621 bool result;
30622 wxColour temp2 ;
30623 PyObject * obj0 = 0 ;
30624 PyObject * obj1 = 0 ;
30625 char *kwnames[] = {
30626 (char *) "self",(char *) "colour", NULL
30627 };
30628
30629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30631 if (SWIG_arg_fail(1)) SWIG_fail;
30632 {
30633 arg2 = &temp2;
30634 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30635 }
30636 {
30637 PyThreadState* __tstate = wxPyBeginAllowThreads();
30638 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30639
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 {
30644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30645 }
30646 return resultobj;
30647 fail:
30648 return NULL;
30649 }
30650
30651
30652 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30653 PyObject *resultobj = NULL;
30654 wxWindow *arg1 = (wxWindow *) 0 ;
30655 wxColour *arg2 = 0 ;
30656 wxColour temp2 ;
30657 PyObject * obj0 = 0 ;
30658 PyObject * obj1 = 0 ;
30659 char *kwnames[] = {
30660 (char *) "self",(char *) "colour", NULL
30661 };
30662
30663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30665 if (SWIG_arg_fail(1)) SWIG_fail;
30666 {
30667 arg2 = &temp2;
30668 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30669 }
30670 {
30671 PyThreadState* __tstate = wxPyBeginAllowThreads();
30672 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30673
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 Py_INCREF(Py_None); resultobj = Py_None;
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30685 PyObject *resultobj = NULL;
30686 wxWindow *arg1 = (wxWindow *) 0 ;
30687 wxColour *arg2 = 0 ;
30688 bool result;
30689 wxColour temp2 ;
30690 PyObject * obj0 = 0 ;
30691 PyObject * obj1 = 0 ;
30692 char *kwnames[] = {
30693 (char *) "self",(char *) "colour", NULL
30694 };
30695
30696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30698 if (SWIG_arg_fail(1)) SWIG_fail;
30699 {
30700 arg2 = &temp2;
30701 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30702 }
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30706
30707 wxPyEndAllowThreads(__tstate);
30708 if (PyErr_Occurred()) SWIG_fail;
30709 }
30710 {
30711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30712 }
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30720 PyObject *resultobj = NULL;
30721 wxWindow *arg1 = (wxWindow *) 0 ;
30722 wxColour *arg2 = 0 ;
30723 wxColour temp2 ;
30724 PyObject * obj0 = 0 ;
30725 PyObject * obj1 = 0 ;
30726 char *kwnames[] = {
30727 (char *) "self",(char *) "colour", NULL
30728 };
30729
30730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30732 if (SWIG_arg_fail(1)) SWIG_fail;
30733 {
30734 arg2 = &temp2;
30735 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30736 }
30737 {
30738 PyThreadState* __tstate = wxPyBeginAllowThreads();
30739 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30740
30741 wxPyEndAllowThreads(__tstate);
30742 if (PyErr_Occurred()) SWIG_fail;
30743 }
30744 Py_INCREF(Py_None); resultobj = Py_None;
30745 return resultobj;
30746 fail:
30747 return NULL;
30748 }
30749
30750
30751 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30752 PyObject *resultobj = NULL;
30753 wxWindow *arg1 = (wxWindow *) 0 ;
30754 wxColour result;
30755 PyObject * obj0 = 0 ;
30756 char *kwnames[] = {
30757 (char *) "self", NULL
30758 };
30759
30760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30762 if (SWIG_arg_fail(1)) SWIG_fail;
30763 {
30764 PyThreadState* __tstate = wxPyBeginAllowThreads();
30765 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30766
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 {
30771 wxColour * resultptr;
30772 resultptr = new wxColour(static_cast<wxColour & >(result));
30773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30774 }
30775 return resultobj;
30776 fail:
30777 return NULL;
30778 }
30779
30780
30781 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30782 PyObject *resultobj = NULL;
30783 wxWindow *arg1 = (wxWindow *) 0 ;
30784 wxColour result;
30785 PyObject * obj0 = 0 ;
30786 char *kwnames[] = {
30787 (char *) "self", NULL
30788 };
30789
30790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30792 if (SWIG_arg_fail(1)) SWIG_fail;
30793 {
30794 PyThreadState* __tstate = wxPyBeginAllowThreads();
30795 result = ((wxWindow const *)arg1)->GetForegroundColour();
30796
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 {
30801 wxColour * resultptr;
30802 resultptr = new wxColour(static_cast<wxColour & >(result));
30803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30804 }
30805 return resultobj;
30806 fail:
30807 return NULL;
30808 }
30809
30810
30811 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30812 PyObject *resultobj = NULL;
30813 wxWindow *arg1 = (wxWindow *) 0 ;
30814 bool result;
30815 PyObject * obj0 = 0 ;
30816 char *kwnames[] = {
30817 (char *) "self", NULL
30818 };
30819
30820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30822 if (SWIG_arg_fail(1)) SWIG_fail;
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30826
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 {
30831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30832 }
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30840 PyObject *resultobj = NULL;
30841 wxWindow *arg1 = (wxWindow *) 0 ;
30842 bool result;
30843 PyObject * obj0 = 0 ;
30844 char *kwnames[] = {
30845 (char *) "self", NULL
30846 };
30847
30848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(1)) SWIG_fail;
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30854
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 {
30859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj = NULL;
30869 wxWindow *arg1 = (wxWindow *) 0 ;
30870 wxBackgroundStyle arg2 ;
30871 bool result;
30872 PyObject * obj0 = 0 ;
30873 PyObject * obj1 = 0 ;
30874 char *kwnames[] = {
30875 (char *) "self",(char *) "style", NULL
30876 };
30877
30878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30880 if (SWIG_arg_fail(1)) SWIG_fail;
30881 {
30882 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30883 if (SWIG_arg_fail(2)) SWIG_fail;
30884 }
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30888
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 {
30893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30894 }
30895 return resultobj;
30896 fail:
30897 return NULL;
30898 }
30899
30900
30901 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30902 PyObject *resultobj = NULL;
30903 wxWindow *arg1 = (wxWindow *) 0 ;
30904 wxBackgroundStyle result;
30905 PyObject * obj0 = 0 ;
30906 char *kwnames[] = {
30907 (char *) "self", NULL
30908 };
30909
30910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30912 if (SWIG_arg_fail(1)) SWIG_fail;
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30916
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 resultobj = SWIG_From_int((result));
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj = NULL;
30929 wxWindow *arg1 = (wxWindow *) 0 ;
30930 bool result;
30931 PyObject * obj0 = 0 ;
30932 char *kwnames[] = {
30933 (char *) "self", NULL
30934 };
30935
30936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30938 if (SWIG_arg_fail(1)) SWIG_fail;
30939 {
30940 PyThreadState* __tstate = wxPyBeginAllowThreads();
30941 result = (bool)(arg1)->HasTransparentBackground();
30942
30943 wxPyEndAllowThreads(__tstate);
30944 if (PyErr_Occurred()) SWIG_fail;
30945 }
30946 {
30947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30948 }
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30956 PyObject *resultobj = NULL;
30957 wxWindow *arg1 = (wxWindow *) 0 ;
30958 wxCursor *arg2 = 0 ;
30959 bool result;
30960 PyObject * obj0 = 0 ;
30961 PyObject * obj1 = 0 ;
30962 char *kwnames[] = {
30963 (char *) "self",(char *) "cursor", NULL
30964 };
30965
30966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30968 if (SWIG_arg_fail(1)) SWIG_fail;
30969 {
30970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30971 if (SWIG_arg_fail(2)) SWIG_fail;
30972 if (arg2 == NULL) {
30973 SWIG_null_ref("wxCursor");
30974 }
30975 if (SWIG_arg_fail(2)) SWIG_fail;
30976 }
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30980
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 {
30985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj = NULL;
30995 wxWindow *arg1 = (wxWindow *) 0 ;
30996 wxCursor result;
30997 PyObject * obj0 = 0 ;
30998 char *kwnames[] = {
30999 (char *) "self", NULL
31000 };
31001
31002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
31003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31004 if (SWIG_arg_fail(1)) SWIG_fail;
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = (arg1)->GetCursor();
31008
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 wxCursor * resultptr;
31014 resultptr = new wxCursor(static_cast<wxCursor & >(result));
31015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
31016 }
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
31024 PyObject *resultobj = NULL;
31025 wxWindow *arg1 = (wxWindow *) 0 ;
31026 wxFont *arg2 = 0 ;
31027 bool result;
31028 PyObject * obj0 = 0 ;
31029 PyObject * obj1 = 0 ;
31030 char *kwnames[] = {
31031 (char *) "self",(char *) "font", NULL
31032 };
31033
31034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
31035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31036 if (SWIG_arg_fail(1)) SWIG_fail;
31037 {
31038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31039 if (SWIG_arg_fail(2)) SWIG_fail;
31040 if (arg2 == NULL) {
31041 SWIG_null_ref("wxFont");
31042 }
31043 if (SWIG_arg_fail(2)) SWIG_fail;
31044 }
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
31048
31049 wxPyEndAllowThreads(__tstate);
31050 if (PyErr_Occurred()) SWIG_fail;
31051 }
31052 {
31053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31054 }
31055 return resultobj;
31056 fail:
31057 return NULL;
31058 }
31059
31060
31061 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
31062 PyObject *resultobj = NULL;
31063 wxWindow *arg1 = (wxWindow *) 0 ;
31064 wxFont *arg2 = 0 ;
31065 PyObject * obj0 = 0 ;
31066 PyObject * obj1 = 0 ;
31067 char *kwnames[] = {
31068 (char *) "self",(char *) "font", NULL
31069 };
31070
31071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
31072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31073 if (SWIG_arg_fail(1)) SWIG_fail;
31074 {
31075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31076 if (SWIG_arg_fail(2)) SWIG_fail;
31077 if (arg2 == NULL) {
31078 SWIG_null_ref("wxFont");
31079 }
31080 if (SWIG_arg_fail(2)) SWIG_fail;
31081 }
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 (arg1)->SetOwnFont((wxFont const &)*arg2);
31085
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 Py_INCREF(Py_None); resultobj = Py_None;
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
31097 PyObject *resultobj = NULL;
31098 wxWindow *arg1 = (wxWindow *) 0 ;
31099 wxFont result;
31100 PyObject * obj0 = 0 ;
31101 char *kwnames[] = {
31102 (char *) "self", NULL
31103 };
31104
31105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
31106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31107 if (SWIG_arg_fail(1)) SWIG_fail;
31108 {
31109 PyThreadState* __tstate = wxPyBeginAllowThreads();
31110 result = (arg1)->GetFont();
31111
31112 wxPyEndAllowThreads(__tstate);
31113 if (PyErr_Occurred()) SWIG_fail;
31114 }
31115 {
31116 wxFont * resultptr;
31117 resultptr = new wxFont(static_cast<wxFont & >(result));
31118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
31119 }
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj = NULL;
31128 wxWindow *arg1 = (wxWindow *) 0 ;
31129 wxCaret *arg2 = (wxCaret *) 0 ;
31130 PyObject * obj0 = 0 ;
31131 PyObject * obj1 = 0 ;
31132 char *kwnames[] = {
31133 (char *) "self",(char *) "caret", NULL
31134 };
31135
31136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
31137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31138 if (SWIG_arg_fail(1)) SWIG_fail;
31139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31140 if (SWIG_arg_fail(2)) SWIG_fail;
31141 {
31142 PyThreadState* __tstate = wxPyBeginAllowThreads();
31143 (arg1)->SetCaret(arg2);
31144
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 Py_INCREF(Py_None); resultobj = Py_None;
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj = NULL;
31157 wxWindow *arg1 = (wxWindow *) 0 ;
31158 wxCaret *result;
31159 PyObject * obj0 = 0 ;
31160 char *kwnames[] = {
31161 (char *) "self", NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31166 if (SWIG_arg_fail(1)) SWIG_fail;
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31170
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31175 return resultobj;
31176 fail:
31177 return NULL;
31178 }
31179
31180
31181 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31182 PyObject *resultobj = NULL;
31183 wxWindow *arg1 = (wxWindow *) 0 ;
31184 int result;
31185 PyObject * obj0 = 0 ;
31186 char *kwnames[] = {
31187 (char *) "self", NULL
31188 };
31189
31190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31192 if (SWIG_arg_fail(1)) SWIG_fail;
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31196
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 {
31201 resultobj = SWIG_From_int(static_cast<int >(result));
31202 }
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj = NULL;
31211 wxWindow *arg1 = (wxWindow *) 0 ;
31212 int result;
31213 PyObject * obj0 = 0 ;
31214 char *kwnames[] = {
31215 (char *) "self", NULL
31216 };
31217
31218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31220 if (SWIG_arg_fail(1)) SWIG_fail;
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31224
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 {
31229 resultobj = SWIG_From_int(static_cast<int >(result));
31230 }
31231 return resultobj;
31232 fail:
31233 return NULL;
31234 }
31235
31236
31237 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31238 PyObject *resultobj = NULL;
31239 wxWindow *arg1 = (wxWindow *) 0 ;
31240 wxString *arg2 = 0 ;
31241 int *arg3 = (int *) 0 ;
31242 int *arg4 = (int *) 0 ;
31243 bool temp2 = false ;
31244 int temp3 ;
31245 int res3 = 0 ;
31246 int temp4 ;
31247 int res4 = 0 ;
31248 PyObject * obj0 = 0 ;
31249 PyObject * obj1 = 0 ;
31250 char *kwnames[] = {
31251 (char *) "self",(char *) "string", NULL
31252 };
31253
31254 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31255 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31258 if (SWIG_arg_fail(1)) SWIG_fail;
31259 {
31260 arg2 = wxString_in_helper(obj1);
31261 if (arg2 == NULL) SWIG_fail;
31262 temp2 = true;
31263 }
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
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, ((res3 == SWIG_NEWOBJ) ?
31273 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31274 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31275 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31276 {
31277 if (temp2)
31278 delete arg2;
31279 }
31280 return resultobj;
31281 fail:
31282 {
31283 if (temp2)
31284 delete arg2;
31285 }
31286 return NULL;
31287 }
31288
31289
31290 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31291 PyObject *resultobj = NULL;
31292 wxWindow *arg1 = (wxWindow *) 0 ;
31293 wxString *arg2 = 0 ;
31294 int *arg3 = (int *) 0 ;
31295 int *arg4 = (int *) 0 ;
31296 int *arg5 = (int *) 0 ;
31297 int *arg6 = (int *) 0 ;
31298 wxFont *arg7 = (wxFont *) NULL ;
31299 bool temp2 = false ;
31300 int temp3 ;
31301 int res3 = 0 ;
31302 int temp4 ;
31303 int res4 = 0 ;
31304 int temp5 ;
31305 int res5 = 0 ;
31306 int temp6 ;
31307 int res6 = 0 ;
31308 PyObject * obj0 = 0 ;
31309 PyObject * obj1 = 0 ;
31310 PyObject * obj2 = 0 ;
31311 char *kwnames[] = {
31312 (char *) "self",(char *) "string",(char *) "font", NULL
31313 };
31314
31315 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31316 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31317 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31318 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31321 if (SWIG_arg_fail(1)) SWIG_fail;
31322 {
31323 arg2 = wxString_in_helper(obj1);
31324 if (arg2 == NULL) SWIG_fail;
31325 temp2 = true;
31326 }
31327 if (obj2) {
31328 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31329 if (SWIG_arg_fail(7)) SWIG_fail;
31330 }
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31334
31335 wxPyEndAllowThreads(__tstate);
31336 if (PyErr_Occurred()) SWIG_fail;
31337 }
31338 Py_INCREF(Py_None); resultobj = Py_None;
31339 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31340 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31341 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31342 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31343 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31344 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31345 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31346 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31347 {
31348 if (temp2)
31349 delete arg2;
31350 }
31351 return resultobj;
31352 fail:
31353 {
31354 if (temp2)
31355 delete arg2;
31356 }
31357 return NULL;
31358 }
31359
31360
31361 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj = NULL;
31363 wxWindow *arg1 = (wxWindow *) 0 ;
31364 int *arg2 = (int *) 0 ;
31365 int *arg3 = (int *) 0 ;
31366 int temp2 ;
31367 int res2 = 0 ;
31368 int temp3 ;
31369 int res3 = 0 ;
31370 PyObject * obj0 = 0 ;
31371 PyObject * obj1 = 0 ;
31372 PyObject * obj2 = 0 ;
31373 char *kwnames[] = {
31374 (char *) "self",(char *) "x",(char *) "y", NULL
31375 };
31376
31377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31379 if (SWIG_arg_fail(1)) SWIG_fail;
31380 {
31381 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31382 temp2 = SWIG_As_int(obj1);
31383 if (SWIG_arg_fail(2)) SWIG_fail;
31384 arg2 = &temp2;
31385 res2 = SWIG_NEWOBJ;
31386 }
31387 }
31388 {
31389 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31390 temp3 = SWIG_As_int(obj2);
31391 if (SWIG_arg_fail(3)) SWIG_fail;
31392 arg3 = &temp3;
31393 res3 = SWIG_NEWOBJ;
31394 }
31395 }
31396 {
31397 PyThreadState* __tstate = wxPyBeginAllowThreads();
31398 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31399
31400 wxPyEndAllowThreads(__tstate);
31401 if (PyErr_Occurred()) SWIG_fail;
31402 }
31403 Py_INCREF(Py_None); resultobj = Py_None;
31404 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31405 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31406 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31407 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31408 return resultobj;
31409 fail:
31410 return NULL;
31411 }
31412
31413
31414 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31415 PyObject *resultobj = NULL;
31416 wxWindow *arg1 = (wxWindow *) 0 ;
31417 int *arg2 = (int *) 0 ;
31418 int *arg3 = (int *) 0 ;
31419 int temp2 ;
31420 int res2 = 0 ;
31421 int temp3 ;
31422 int res3 = 0 ;
31423 PyObject * obj0 = 0 ;
31424 PyObject * obj1 = 0 ;
31425 PyObject * obj2 = 0 ;
31426 char *kwnames[] = {
31427 (char *) "self",(char *) "x",(char *) "y", NULL
31428 };
31429
31430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31432 if (SWIG_arg_fail(1)) SWIG_fail;
31433 {
31434 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31435 temp2 = SWIG_As_int(obj1);
31436 if (SWIG_arg_fail(2)) SWIG_fail;
31437 arg2 = &temp2;
31438 res2 = SWIG_NEWOBJ;
31439 }
31440 }
31441 {
31442 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31443 temp3 = SWIG_As_int(obj2);
31444 if (SWIG_arg_fail(3)) SWIG_fail;
31445 arg3 = &temp3;
31446 res3 = SWIG_NEWOBJ;
31447 }
31448 }
31449 {
31450 PyThreadState* __tstate = wxPyBeginAllowThreads();
31451 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31452
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 Py_INCREF(Py_None); resultobj = Py_None;
31457 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31458 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31459 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31460 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31461 return resultobj;
31462 fail:
31463 return NULL;
31464 }
31465
31466
31467 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31468 PyObject *resultobj = NULL;
31469 wxWindow *arg1 = (wxWindow *) 0 ;
31470 wxPoint *arg2 = 0 ;
31471 wxPoint result;
31472 wxPoint temp2 ;
31473 PyObject * obj0 = 0 ;
31474 PyObject * obj1 = 0 ;
31475 char *kwnames[] = {
31476 (char *) "self",(char *) "pt", NULL
31477 };
31478
31479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31481 if (SWIG_arg_fail(1)) SWIG_fail;
31482 {
31483 arg2 = &temp2;
31484 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31485 }
31486 {
31487 PyThreadState* __tstate = wxPyBeginAllowThreads();
31488 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31489
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 {
31494 wxPoint * resultptr;
31495 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31496 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31497 }
31498 return resultobj;
31499 fail:
31500 return NULL;
31501 }
31502
31503
31504 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31505 PyObject *resultobj = NULL;
31506 wxWindow *arg1 = (wxWindow *) 0 ;
31507 wxPoint *arg2 = 0 ;
31508 wxPoint result;
31509 wxPoint temp2 ;
31510 PyObject * obj0 = 0 ;
31511 PyObject * obj1 = 0 ;
31512 char *kwnames[] = {
31513 (char *) "self",(char *) "pt", NULL
31514 };
31515
31516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31518 if (SWIG_arg_fail(1)) SWIG_fail;
31519 {
31520 arg2 = &temp2;
31521 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31522 }
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31526
31527 wxPyEndAllowThreads(__tstate);
31528 if (PyErr_Occurred()) SWIG_fail;
31529 }
31530 {
31531 wxPoint * resultptr;
31532 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31534 }
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31542 PyObject *resultobj = NULL;
31543 wxWindow *arg1 = (wxWindow *) 0 ;
31544 int arg2 ;
31545 int arg3 ;
31546 wxHitTest result;
31547 PyObject * obj0 = 0 ;
31548 PyObject * obj1 = 0 ;
31549 PyObject * obj2 = 0 ;
31550 char *kwnames[] = {
31551 (char *) "self",(char *) "x",(char *) "y", NULL
31552 };
31553
31554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31556 if (SWIG_arg_fail(1)) SWIG_fail;
31557 {
31558 arg2 = static_cast<int >(SWIG_As_int(obj1));
31559 if (SWIG_arg_fail(2)) SWIG_fail;
31560 }
31561 {
31562 arg3 = static_cast<int >(SWIG_As_int(obj2));
31563 if (SWIG_arg_fail(3)) SWIG_fail;
31564 }
31565 {
31566 PyThreadState* __tstate = wxPyBeginAllowThreads();
31567 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31568
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 resultobj = SWIG_From_int((result));
31573 return resultobj;
31574 fail:
31575 return NULL;
31576 }
31577
31578
31579 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31580 PyObject *resultobj = NULL;
31581 wxWindow *arg1 = (wxWindow *) 0 ;
31582 wxPoint *arg2 = 0 ;
31583 wxHitTest result;
31584 wxPoint temp2 ;
31585 PyObject * obj0 = 0 ;
31586 PyObject * obj1 = 0 ;
31587 char *kwnames[] = {
31588 (char *) "self",(char *) "pt", NULL
31589 };
31590
31591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31593 if (SWIG_arg_fail(1)) SWIG_fail;
31594 {
31595 arg2 = &temp2;
31596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31597 }
31598 {
31599 PyThreadState* __tstate = wxPyBeginAllowThreads();
31600 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31601
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 resultobj = SWIG_From_int((result));
31606 return resultobj;
31607 fail:
31608 return NULL;
31609 }
31610
31611
31612 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31613 PyObject *resultobj = NULL;
31614 wxWindow *arg1 = (wxWindow *) 0 ;
31615 long arg2 ;
31616 wxBorder result;
31617 PyObject * obj0 = 0 ;
31618 PyObject * obj1 = 0 ;
31619
31620 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31622 if (SWIG_arg_fail(1)) SWIG_fail;
31623 {
31624 arg2 = static_cast<long >(SWIG_As_long(obj1));
31625 if (SWIG_arg_fail(2)) SWIG_fail;
31626 }
31627 {
31628 PyThreadState* __tstate = wxPyBeginAllowThreads();
31629 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31630
31631 wxPyEndAllowThreads(__tstate);
31632 if (PyErr_Occurred()) SWIG_fail;
31633 }
31634 resultobj = SWIG_From_int((result));
31635 return resultobj;
31636 fail:
31637 return NULL;
31638 }
31639
31640
31641 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31642 PyObject *resultobj = NULL;
31643 wxWindow *arg1 = (wxWindow *) 0 ;
31644 wxBorder result;
31645 PyObject * obj0 = 0 ;
31646
31647 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31649 if (SWIG_arg_fail(1)) SWIG_fail;
31650 {
31651 PyThreadState* __tstate = wxPyBeginAllowThreads();
31652 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31653
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 resultobj = SWIG_From_int((result));
31658 return resultobj;
31659 fail:
31660 return NULL;
31661 }
31662
31663
31664 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31665 int argc;
31666 PyObject *argv[3];
31667 int ii;
31668
31669 argc = PyObject_Length(args);
31670 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31671 argv[ii] = PyTuple_GetItem(args,ii);
31672 }
31673 if (argc == 1) {
31674 int _v;
31675 {
31676 void *ptr;
31677 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31678 _v = 0;
31679 PyErr_Clear();
31680 } else {
31681 _v = 1;
31682 }
31683 }
31684 if (_v) {
31685 return _wrap_Window_GetBorder__SWIG_1(self,args);
31686 }
31687 }
31688 if (argc == 2) {
31689 int _v;
31690 {
31691 void *ptr;
31692 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31693 _v = 0;
31694 PyErr_Clear();
31695 } else {
31696 _v = 1;
31697 }
31698 }
31699 if (_v) {
31700 _v = SWIG_Check_long(argv[1]);
31701 if (_v) {
31702 return _wrap_Window_GetBorder__SWIG_0(self,args);
31703 }
31704 }
31705 }
31706
31707 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31708 return NULL;
31709 }
31710
31711
31712 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31713 PyObject *resultobj = NULL;
31714 wxWindow *arg1 = (wxWindow *) 0 ;
31715 long arg2 = (long) wxUPDATE_UI_NONE ;
31716 PyObject * obj0 = 0 ;
31717 PyObject * obj1 = 0 ;
31718 char *kwnames[] = {
31719 (char *) "self",(char *) "flags", NULL
31720 };
31721
31722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31724 if (SWIG_arg_fail(1)) SWIG_fail;
31725 if (obj1) {
31726 {
31727 arg2 = static_cast<long >(SWIG_As_long(obj1));
31728 if (SWIG_arg_fail(2)) SWIG_fail;
31729 }
31730 }
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 (arg1)->UpdateWindowUI(arg2);
31734
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 Py_INCREF(Py_None); resultobj = Py_None;
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj = NULL;
31747 wxWindow *arg1 = (wxWindow *) 0 ;
31748 wxMenu *arg2 = (wxMenu *) 0 ;
31749 int arg3 = (int) -1 ;
31750 int arg4 = (int) -1 ;
31751 bool result;
31752 PyObject * obj0 = 0 ;
31753 PyObject * obj1 = 0 ;
31754 PyObject * obj2 = 0 ;
31755 PyObject * obj3 = 0 ;
31756 char *kwnames[] = {
31757 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31758 };
31759
31760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31762 if (SWIG_arg_fail(1)) SWIG_fail;
31763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31764 if (SWIG_arg_fail(2)) SWIG_fail;
31765 if (obj2) {
31766 {
31767 arg3 = static_cast<int >(SWIG_As_int(obj2));
31768 if (SWIG_arg_fail(3)) SWIG_fail;
31769 }
31770 }
31771 if (obj3) {
31772 {
31773 arg4 = static_cast<int >(SWIG_As_int(obj3));
31774 if (SWIG_arg_fail(4)) SWIG_fail;
31775 }
31776 }
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31780
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 {
31785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31786 }
31787 return resultobj;
31788 fail:
31789 return NULL;
31790 }
31791
31792
31793 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31794 PyObject *resultobj = NULL;
31795 wxWindow *arg1 = (wxWindow *) 0 ;
31796 wxMenu *arg2 = (wxMenu *) 0 ;
31797 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31798 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31799 bool result;
31800 wxPoint temp3 ;
31801 PyObject * obj0 = 0 ;
31802 PyObject * obj1 = 0 ;
31803 PyObject * obj2 = 0 ;
31804 char *kwnames[] = {
31805 (char *) "self",(char *) "menu",(char *) "pos", NULL
31806 };
31807
31808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31810 if (SWIG_arg_fail(1)) SWIG_fail;
31811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31812 if (SWIG_arg_fail(2)) SWIG_fail;
31813 if (obj2) {
31814 {
31815 arg3 = &temp3;
31816 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31817 }
31818 }
31819 {
31820 PyThreadState* __tstate = wxPyBeginAllowThreads();
31821 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31822
31823 wxPyEndAllowThreads(__tstate);
31824 if (PyErr_Occurred()) SWIG_fail;
31825 }
31826 {
31827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31828 }
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31836 PyObject *resultobj = NULL;
31837 wxWindow *arg1 = (wxWindow *) 0 ;
31838 long result;
31839 PyObject * obj0 = 0 ;
31840 char *kwnames[] = {
31841 (char *) "self", NULL
31842 };
31843
31844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31846 if (SWIG_arg_fail(1)) SWIG_fail;
31847 {
31848 PyThreadState* __tstate = wxPyBeginAllowThreads();
31849 result = (long)wxWindow_GetHandle(arg1);
31850
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 {
31855 resultobj = SWIG_From_long(static_cast<long >(result));
31856 }
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = NULL;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 long arg2 ;
31867 PyObject * obj0 = 0 ;
31868 PyObject * obj1 = 0 ;
31869 char *kwnames[] = {
31870 (char *) "self",(char *) "handle", NULL
31871 };
31872
31873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31875 if (SWIG_arg_fail(1)) SWIG_fail;
31876 {
31877 arg2 = static_cast<long >(SWIG_As_long(obj1));
31878 if (SWIG_arg_fail(2)) SWIG_fail;
31879 }
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 wxWindow_AssociateHandle(arg1,arg2);
31883
31884 wxPyEndAllowThreads(__tstate);
31885 if (PyErr_Occurred()) SWIG_fail;
31886 }
31887 Py_INCREF(Py_None); resultobj = Py_None;
31888 return resultobj;
31889 fail:
31890 return NULL;
31891 }
31892
31893
31894 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31895 PyObject *resultobj = NULL;
31896 wxWindow *arg1 = (wxWindow *) 0 ;
31897 PyObject * obj0 = 0 ;
31898 char *kwnames[] = {
31899 (char *) "self", NULL
31900 };
31901
31902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31904 if (SWIG_arg_fail(1)) SWIG_fail;
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 (arg1)->DissociateHandle();
31908
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 Py_INCREF(Py_None); resultobj = Py_None;
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31920 PyObject *resultobj = NULL;
31921 wxWindow *arg1 = (wxWindow *) 0 ;
31922 int arg2 ;
31923 bool result;
31924 PyObject * obj0 = 0 ;
31925 PyObject * obj1 = 0 ;
31926 char *kwnames[] = {
31927 (char *) "self",(char *) "orient", NULL
31928 };
31929
31930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31932 if (SWIG_arg_fail(1)) SWIG_fail;
31933 {
31934 arg2 = static_cast<int >(SWIG_As_int(obj1));
31935 if (SWIG_arg_fail(2)) SWIG_fail;
31936 }
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31940
31941 wxPyEndAllowThreads(__tstate);
31942 if (PyErr_Occurred()) SWIG_fail;
31943 }
31944 {
31945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31946 }
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31954 PyObject *resultobj = NULL;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 int arg2 ;
31957 int arg3 ;
31958 int arg4 ;
31959 int arg5 ;
31960 bool arg6 = (bool) true ;
31961 PyObject * obj0 = 0 ;
31962 PyObject * obj1 = 0 ;
31963 PyObject * obj2 = 0 ;
31964 PyObject * obj3 = 0 ;
31965 PyObject * obj4 = 0 ;
31966 PyObject * obj5 = 0 ;
31967 char *kwnames[] = {
31968 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31969 };
31970
31971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31973 if (SWIG_arg_fail(1)) SWIG_fail;
31974 {
31975 arg2 = static_cast<int >(SWIG_As_int(obj1));
31976 if (SWIG_arg_fail(2)) SWIG_fail;
31977 }
31978 {
31979 arg3 = static_cast<int >(SWIG_As_int(obj2));
31980 if (SWIG_arg_fail(3)) SWIG_fail;
31981 }
31982 {
31983 arg4 = static_cast<int >(SWIG_As_int(obj3));
31984 if (SWIG_arg_fail(4)) SWIG_fail;
31985 }
31986 {
31987 arg5 = static_cast<int >(SWIG_As_int(obj4));
31988 if (SWIG_arg_fail(5)) SWIG_fail;
31989 }
31990 if (obj5) {
31991 {
31992 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31993 if (SWIG_arg_fail(6)) SWIG_fail;
31994 }
31995 }
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31999
32000 wxPyEndAllowThreads(__tstate);
32001 if (PyErr_Occurred()) SWIG_fail;
32002 }
32003 Py_INCREF(Py_None); resultobj = Py_None;
32004 return resultobj;
32005 fail:
32006 return NULL;
32007 }
32008
32009
32010 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
32011 PyObject *resultobj = NULL;
32012 wxWindow *arg1 = (wxWindow *) 0 ;
32013 int arg2 ;
32014 int arg3 ;
32015 bool arg4 = (bool) true ;
32016 PyObject * obj0 = 0 ;
32017 PyObject * obj1 = 0 ;
32018 PyObject * obj2 = 0 ;
32019 PyObject * obj3 = 0 ;
32020 char *kwnames[] = {
32021 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
32022 };
32023
32024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32026 if (SWIG_arg_fail(1)) SWIG_fail;
32027 {
32028 arg2 = static_cast<int >(SWIG_As_int(obj1));
32029 if (SWIG_arg_fail(2)) SWIG_fail;
32030 }
32031 {
32032 arg3 = static_cast<int >(SWIG_As_int(obj2));
32033 if (SWIG_arg_fail(3)) SWIG_fail;
32034 }
32035 if (obj3) {
32036 {
32037 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
32038 if (SWIG_arg_fail(4)) SWIG_fail;
32039 }
32040 }
32041 {
32042 PyThreadState* __tstate = wxPyBeginAllowThreads();
32043 (arg1)->SetScrollPos(arg2,arg3,arg4);
32044
32045 wxPyEndAllowThreads(__tstate);
32046 if (PyErr_Occurred()) SWIG_fail;
32047 }
32048 Py_INCREF(Py_None); resultobj = Py_None;
32049 return resultobj;
32050 fail:
32051 return NULL;
32052 }
32053
32054
32055 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
32056 PyObject *resultobj = NULL;
32057 wxWindow *arg1 = (wxWindow *) 0 ;
32058 int arg2 ;
32059 int result;
32060 PyObject * obj0 = 0 ;
32061 PyObject * obj1 = 0 ;
32062 char *kwnames[] = {
32063 (char *) "self",(char *) "orientation", NULL
32064 };
32065
32066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
32067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32068 if (SWIG_arg_fail(1)) SWIG_fail;
32069 {
32070 arg2 = static_cast<int >(SWIG_As_int(obj1));
32071 if (SWIG_arg_fail(2)) SWIG_fail;
32072 }
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
32076
32077 wxPyEndAllowThreads(__tstate);
32078 if (PyErr_Occurred()) SWIG_fail;
32079 }
32080 {
32081 resultobj = SWIG_From_int(static_cast<int >(result));
32082 }
32083 return resultobj;
32084 fail:
32085 return NULL;
32086 }
32087
32088
32089 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
32090 PyObject *resultobj = NULL;
32091 wxWindow *arg1 = (wxWindow *) 0 ;
32092 int arg2 ;
32093 int result;
32094 PyObject * obj0 = 0 ;
32095 PyObject * obj1 = 0 ;
32096 char *kwnames[] = {
32097 (char *) "self",(char *) "orientation", NULL
32098 };
32099
32100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
32101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32102 if (SWIG_arg_fail(1)) SWIG_fail;
32103 {
32104 arg2 = static_cast<int >(SWIG_As_int(obj1));
32105 if (SWIG_arg_fail(2)) SWIG_fail;
32106 }
32107 {
32108 PyThreadState* __tstate = wxPyBeginAllowThreads();
32109 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
32110
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 {
32115 resultobj = SWIG_From_int(static_cast<int >(result));
32116 }
32117 return resultobj;
32118 fail:
32119 return NULL;
32120 }
32121
32122
32123 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
32124 PyObject *resultobj = NULL;
32125 wxWindow *arg1 = (wxWindow *) 0 ;
32126 int arg2 ;
32127 int result;
32128 PyObject * obj0 = 0 ;
32129 PyObject * obj1 = 0 ;
32130 char *kwnames[] = {
32131 (char *) "self",(char *) "orientation", NULL
32132 };
32133
32134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32136 if (SWIG_arg_fail(1)) SWIG_fail;
32137 {
32138 arg2 = static_cast<int >(SWIG_As_int(obj1));
32139 if (SWIG_arg_fail(2)) SWIG_fail;
32140 }
32141 {
32142 PyThreadState* __tstate = wxPyBeginAllowThreads();
32143 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32144
32145 wxPyEndAllowThreads(__tstate);
32146 if (PyErr_Occurred()) SWIG_fail;
32147 }
32148 {
32149 resultobj = SWIG_From_int(static_cast<int >(result));
32150 }
32151 return resultobj;
32152 fail:
32153 return NULL;
32154 }
32155
32156
32157 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32158 PyObject *resultobj = NULL;
32159 wxWindow *arg1 = (wxWindow *) 0 ;
32160 int arg2 ;
32161 int arg3 ;
32162 wxRect *arg4 = (wxRect *) NULL ;
32163 PyObject * obj0 = 0 ;
32164 PyObject * obj1 = 0 ;
32165 PyObject * obj2 = 0 ;
32166 PyObject * obj3 = 0 ;
32167 char *kwnames[] = {
32168 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32169 };
32170
32171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32173 if (SWIG_arg_fail(1)) SWIG_fail;
32174 {
32175 arg2 = static_cast<int >(SWIG_As_int(obj1));
32176 if (SWIG_arg_fail(2)) SWIG_fail;
32177 }
32178 {
32179 arg3 = static_cast<int >(SWIG_As_int(obj2));
32180 if (SWIG_arg_fail(3)) SWIG_fail;
32181 }
32182 if (obj3) {
32183 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32184 if (SWIG_arg_fail(4)) SWIG_fail;
32185 }
32186 {
32187 PyThreadState* __tstate = wxPyBeginAllowThreads();
32188 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32189
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 Py_INCREF(Py_None); resultobj = Py_None;
32194 return resultobj;
32195 fail:
32196 return NULL;
32197 }
32198
32199
32200 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32201 PyObject *resultobj = NULL;
32202 wxWindow *arg1 = (wxWindow *) 0 ;
32203 int arg2 ;
32204 bool result;
32205 PyObject * obj0 = 0 ;
32206 PyObject * obj1 = 0 ;
32207 char *kwnames[] = {
32208 (char *) "self",(char *) "lines", NULL
32209 };
32210
32211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32213 if (SWIG_arg_fail(1)) SWIG_fail;
32214 {
32215 arg2 = static_cast<int >(SWIG_As_int(obj1));
32216 if (SWIG_arg_fail(2)) SWIG_fail;
32217 }
32218 {
32219 PyThreadState* __tstate = wxPyBeginAllowThreads();
32220 result = (bool)(arg1)->ScrollLines(arg2);
32221
32222 wxPyEndAllowThreads(__tstate);
32223 if (PyErr_Occurred()) SWIG_fail;
32224 }
32225 {
32226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32227 }
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = NULL;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 int arg2 ;
32238 bool result;
32239 PyObject * obj0 = 0 ;
32240 PyObject * obj1 = 0 ;
32241 char *kwnames[] = {
32242 (char *) "self",(char *) "pages", NULL
32243 };
32244
32245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32247 if (SWIG_arg_fail(1)) SWIG_fail;
32248 {
32249 arg2 = static_cast<int >(SWIG_As_int(obj1));
32250 if (SWIG_arg_fail(2)) SWIG_fail;
32251 }
32252 {
32253 PyThreadState* __tstate = wxPyBeginAllowThreads();
32254 result = (bool)(arg1)->ScrollPages(arg2);
32255
32256 wxPyEndAllowThreads(__tstate);
32257 if (PyErr_Occurred()) SWIG_fail;
32258 }
32259 {
32260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32261 }
32262 return resultobj;
32263 fail:
32264 return NULL;
32265 }
32266
32267
32268 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32269 PyObject *resultobj = NULL;
32270 wxWindow *arg1 = (wxWindow *) 0 ;
32271 bool result;
32272 PyObject * obj0 = 0 ;
32273 char *kwnames[] = {
32274 (char *) "self", NULL
32275 };
32276
32277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32279 if (SWIG_arg_fail(1)) SWIG_fail;
32280 {
32281 PyThreadState* __tstate = wxPyBeginAllowThreads();
32282 result = (bool)(arg1)->LineUp();
32283
32284 wxPyEndAllowThreads(__tstate);
32285 if (PyErr_Occurred()) SWIG_fail;
32286 }
32287 {
32288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32289 }
32290 return resultobj;
32291 fail:
32292 return NULL;
32293 }
32294
32295
32296 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32297 PyObject *resultobj = NULL;
32298 wxWindow *arg1 = (wxWindow *) 0 ;
32299 bool result;
32300 PyObject * obj0 = 0 ;
32301 char *kwnames[] = {
32302 (char *) "self", NULL
32303 };
32304
32305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32307 if (SWIG_arg_fail(1)) SWIG_fail;
32308 {
32309 PyThreadState* __tstate = wxPyBeginAllowThreads();
32310 result = (bool)(arg1)->LineDown();
32311
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 {
32316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32317 }
32318 return resultobj;
32319 fail:
32320 return NULL;
32321 }
32322
32323
32324 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32325 PyObject *resultobj = NULL;
32326 wxWindow *arg1 = (wxWindow *) 0 ;
32327 bool result;
32328 PyObject * obj0 = 0 ;
32329 char *kwnames[] = {
32330 (char *) "self", NULL
32331 };
32332
32333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32335 if (SWIG_arg_fail(1)) SWIG_fail;
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (bool)(arg1)->PageUp();
32339
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 {
32344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32345 }
32346 return resultobj;
32347 fail:
32348 return NULL;
32349 }
32350
32351
32352 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32353 PyObject *resultobj = NULL;
32354 wxWindow *arg1 = (wxWindow *) 0 ;
32355 bool result;
32356 PyObject * obj0 = 0 ;
32357 char *kwnames[] = {
32358 (char *) "self", NULL
32359 };
32360
32361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32363 if (SWIG_arg_fail(1)) SWIG_fail;
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = (bool)(arg1)->PageDown();
32367
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 {
32372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32373 }
32374 return resultobj;
32375 fail:
32376 return NULL;
32377 }
32378
32379
32380 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32381 PyObject *resultobj = NULL;
32382 wxWindow *arg1 = (wxWindow *) 0 ;
32383 wxString *arg2 = 0 ;
32384 bool temp2 = false ;
32385 PyObject * obj0 = 0 ;
32386 PyObject * obj1 = 0 ;
32387 char *kwnames[] = {
32388 (char *) "self",(char *) "text", NULL
32389 };
32390
32391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32393 if (SWIG_arg_fail(1)) SWIG_fail;
32394 {
32395 arg2 = wxString_in_helper(obj1);
32396 if (arg2 == NULL) SWIG_fail;
32397 temp2 = true;
32398 }
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 (arg1)->SetHelpText((wxString const &)*arg2);
32402
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 Py_INCREF(Py_None); resultobj = Py_None;
32407 {
32408 if (temp2)
32409 delete arg2;
32410 }
32411 return resultobj;
32412 fail:
32413 {
32414 if (temp2)
32415 delete arg2;
32416 }
32417 return NULL;
32418 }
32419
32420
32421 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32422 PyObject *resultobj = NULL;
32423 wxWindow *arg1 = (wxWindow *) 0 ;
32424 wxString *arg2 = 0 ;
32425 bool temp2 = false ;
32426 PyObject * obj0 = 0 ;
32427 PyObject * obj1 = 0 ;
32428 char *kwnames[] = {
32429 (char *) "self",(char *) "text", NULL
32430 };
32431
32432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32434 if (SWIG_arg_fail(1)) SWIG_fail;
32435 {
32436 arg2 = wxString_in_helper(obj1);
32437 if (arg2 == NULL) SWIG_fail;
32438 temp2 = true;
32439 }
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32443
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 Py_INCREF(Py_None); resultobj = Py_None;
32448 {
32449 if (temp2)
32450 delete arg2;
32451 }
32452 return resultobj;
32453 fail:
32454 {
32455 if (temp2)
32456 delete arg2;
32457 }
32458 return NULL;
32459 }
32460
32461
32462 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32463 PyObject *resultobj = NULL;
32464 wxWindow *arg1 = (wxWindow *) 0 ;
32465 wxString result;
32466 PyObject * obj0 = 0 ;
32467 char *kwnames[] = {
32468 (char *) "self", NULL
32469 };
32470
32471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32473 if (SWIG_arg_fail(1)) SWIG_fail;
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 result = ((wxWindow const *)arg1)->GetHelpText();
32477
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 {
32482 #if wxUSE_UNICODE
32483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32484 #else
32485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32486 #endif
32487 }
32488 return resultobj;
32489 fail:
32490 return NULL;
32491 }
32492
32493
32494 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32495 PyObject *resultobj = NULL;
32496 wxWindow *arg1 = (wxWindow *) 0 ;
32497 wxString *arg2 = 0 ;
32498 bool temp2 = false ;
32499 PyObject * obj0 = 0 ;
32500 PyObject * obj1 = 0 ;
32501 char *kwnames[] = {
32502 (char *) "self",(char *) "tip", NULL
32503 };
32504
32505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32507 if (SWIG_arg_fail(1)) SWIG_fail;
32508 {
32509 arg2 = wxString_in_helper(obj1);
32510 if (arg2 == NULL) SWIG_fail;
32511 temp2 = true;
32512 }
32513 {
32514 PyThreadState* __tstate = wxPyBeginAllowThreads();
32515 (arg1)->SetToolTip((wxString const &)*arg2);
32516
32517 wxPyEndAllowThreads(__tstate);
32518 if (PyErr_Occurred()) SWIG_fail;
32519 }
32520 Py_INCREF(Py_None); resultobj = Py_None;
32521 {
32522 if (temp2)
32523 delete arg2;
32524 }
32525 return resultobj;
32526 fail:
32527 {
32528 if (temp2)
32529 delete arg2;
32530 }
32531 return NULL;
32532 }
32533
32534
32535 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32536 PyObject *resultobj = NULL;
32537 wxWindow *arg1 = (wxWindow *) 0 ;
32538 wxToolTip *arg2 = (wxToolTip *) 0 ;
32539 PyObject * obj0 = 0 ;
32540 PyObject * obj1 = 0 ;
32541 char *kwnames[] = {
32542 (char *) "self",(char *) "tip", NULL
32543 };
32544
32545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32547 if (SWIG_arg_fail(1)) SWIG_fail;
32548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32549 if (SWIG_arg_fail(2)) SWIG_fail;
32550 {
32551 PyThreadState* __tstate = wxPyBeginAllowThreads();
32552 (arg1)->SetToolTip(arg2);
32553
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 Py_INCREF(Py_None); resultobj = Py_None;
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj = NULL;
32566 wxWindow *arg1 = (wxWindow *) 0 ;
32567 wxToolTip *result;
32568 PyObject * obj0 = 0 ;
32569 char *kwnames[] = {
32570 (char *) "self", NULL
32571 };
32572
32573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32575 if (SWIG_arg_fail(1)) SWIG_fail;
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32579
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 {
32584 resultobj = wxPyMake_wxObject(result, (bool)0);
32585 }
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32593 PyObject *resultobj = NULL;
32594 wxWindow *arg1 = (wxWindow *) 0 ;
32595 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32596 PyObject * obj0 = 0 ;
32597 PyObject * obj1 = 0 ;
32598 char *kwnames[] = {
32599 (char *) "self",(char *) "dropTarget", NULL
32600 };
32601
32602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32604 if (SWIG_arg_fail(1)) SWIG_fail;
32605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32606 if (SWIG_arg_fail(2)) SWIG_fail;
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 (arg1)->SetDropTarget(arg2);
32610
32611 wxPyEndAllowThreads(__tstate);
32612 if (PyErr_Occurred()) SWIG_fail;
32613 }
32614 Py_INCREF(Py_None); resultobj = Py_None;
32615 return resultobj;
32616 fail:
32617 return NULL;
32618 }
32619
32620
32621 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32622 PyObject *resultobj = NULL;
32623 wxWindow *arg1 = (wxWindow *) 0 ;
32624 wxPyDropTarget *result;
32625 PyObject * obj0 = 0 ;
32626 char *kwnames[] = {
32627 (char *) "self", NULL
32628 };
32629
32630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32632 if (SWIG_arg_fail(1)) SWIG_fail;
32633 {
32634 PyThreadState* __tstate = wxPyBeginAllowThreads();
32635 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32636
32637 wxPyEndAllowThreads(__tstate);
32638 if (PyErr_Occurred()) SWIG_fail;
32639 }
32640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32641 return resultobj;
32642 fail:
32643 return NULL;
32644 }
32645
32646
32647 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32648 PyObject *resultobj = NULL;
32649 wxWindow *arg1 = (wxWindow *) 0 ;
32650 bool arg2 ;
32651 PyObject * obj0 = 0 ;
32652 PyObject * obj1 = 0 ;
32653 char *kwnames[] = {
32654 (char *) "self",(char *) "accept", NULL
32655 };
32656
32657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32659 if (SWIG_arg_fail(1)) SWIG_fail;
32660 {
32661 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32662 if (SWIG_arg_fail(2)) SWIG_fail;
32663 }
32664 {
32665 PyThreadState* __tstate = wxPyBeginAllowThreads();
32666 wxWindow_DragAcceptFiles(arg1,arg2);
32667
32668 wxPyEndAllowThreads(__tstate);
32669 if (PyErr_Occurred()) SWIG_fail;
32670 }
32671 Py_INCREF(Py_None); resultobj = Py_None;
32672 return resultobj;
32673 fail:
32674 return NULL;
32675 }
32676
32677
32678 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32679 PyObject *resultobj = NULL;
32680 wxWindow *arg1 = (wxWindow *) 0 ;
32681 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32682 PyObject * obj0 = 0 ;
32683 PyObject * obj1 = 0 ;
32684 char *kwnames[] = {
32685 (char *) "self",(char *) "constraints", NULL
32686 };
32687
32688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32690 if (SWIG_arg_fail(1)) SWIG_fail;
32691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32692 if (SWIG_arg_fail(2)) SWIG_fail;
32693 {
32694 PyThreadState* __tstate = wxPyBeginAllowThreads();
32695 (arg1)->SetConstraints(arg2);
32696
32697 wxPyEndAllowThreads(__tstate);
32698 if (PyErr_Occurred()) SWIG_fail;
32699 }
32700 Py_INCREF(Py_None); resultobj = Py_None;
32701 return resultobj;
32702 fail:
32703 return NULL;
32704 }
32705
32706
32707 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32708 PyObject *resultobj = NULL;
32709 wxWindow *arg1 = (wxWindow *) 0 ;
32710 wxLayoutConstraints *result;
32711 PyObject * obj0 = 0 ;
32712 char *kwnames[] = {
32713 (char *) "self", NULL
32714 };
32715
32716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32718 if (SWIG_arg_fail(1)) SWIG_fail;
32719 {
32720 PyThreadState* __tstate = wxPyBeginAllowThreads();
32721 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32722
32723 wxPyEndAllowThreads(__tstate);
32724 if (PyErr_Occurred()) SWIG_fail;
32725 }
32726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32727 return resultobj;
32728 fail:
32729 return NULL;
32730 }
32731
32732
32733 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32734 PyObject *resultobj = NULL;
32735 wxWindow *arg1 = (wxWindow *) 0 ;
32736 bool arg2 ;
32737 PyObject * obj0 = 0 ;
32738 PyObject * obj1 = 0 ;
32739 char *kwnames[] = {
32740 (char *) "self",(char *) "autoLayout", NULL
32741 };
32742
32743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32745 if (SWIG_arg_fail(1)) SWIG_fail;
32746 {
32747 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32748 if (SWIG_arg_fail(2)) SWIG_fail;
32749 }
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 (arg1)->SetAutoLayout(arg2);
32753
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 Py_INCREF(Py_None); resultobj = Py_None;
32758 return resultobj;
32759 fail:
32760 return NULL;
32761 }
32762
32763
32764 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32765 PyObject *resultobj = NULL;
32766 wxWindow *arg1 = (wxWindow *) 0 ;
32767 bool result;
32768 PyObject * obj0 = 0 ;
32769 char *kwnames[] = {
32770 (char *) "self", NULL
32771 };
32772
32773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32775 if (SWIG_arg_fail(1)) SWIG_fail;
32776 {
32777 PyThreadState* __tstate = wxPyBeginAllowThreads();
32778 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32779
32780 wxPyEndAllowThreads(__tstate);
32781 if (PyErr_Occurred()) SWIG_fail;
32782 }
32783 {
32784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32785 }
32786 return resultobj;
32787 fail:
32788 return NULL;
32789 }
32790
32791
32792 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32793 PyObject *resultobj = NULL;
32794 wxWindow *arg1 = (wxWindow *) 0 ;
32795 bool result;
32796 PyObject * obj0 = 0 ;
32797 char *kwnames[] = {
32798 (char *) "self", NULL
32799 };
32800
32801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32803 if (SWIG_arg_fail(1)) SWIG_fail;
32804 {
32805 PyThreadState* __tstate = wxPyBeginAllowThreads();
32806 result = (bool)(arg1)->Layout();
32807
32808 wxPyEndAllowThreads(__tstate);
32809 if (PyErr_Occurred()) SWIG_fail;
32810 }
32811 {
32812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32813 }
32814 return resultobj;
32815 fail:
32816 return NULL;
32817 }
32818
32819
32820 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32821 PyObject *resultobj = NULL;
32822 wxWindow *arg1 = (wxWindow *) 0 ;
32823 wxSizer *arg2 = (wxSizer *) 0 ;
32824 bool arg3 = (bool) true ;
32825 PyObject * obj0 = 0 ;
32826 PyObject * obj1 = 0 ;
32827 PyObject * obj2 = 0 ;
32828 char *kwnames[] = {
32829 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32830 };
32831
32832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32834 if (SWIG_arg_fail(1)) SWIG_fail;
32835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32836 if (SWIG_arg_fail(2)) SWIG_fail;
32837 if (obj2) {
32838 {
32839 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32840 if (SWIG_arg_fail(3)) SWIG_fail;
32841 }
32842 }
32843 {
32844 PyThreadState* __tstate = wxPyBeginAllowThreads();
32845 (arg1)->SetSizer(arg2,arg3);
32846
32847 wxPyEndAllowThreads(__tstate);
32848 if (PyErr_Occurred()) SWIG_fail;
32849 }
32850 Py_INCREF(Py_None); resultobj = Py_None;
32851 return resultobj;
32852 fail:
32853 return NULL;
32854 }
32855
32856
32857 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32858 PyObject *resultobj = NULL;
32859 wxWindow *arg1 = (wxWindow *) 0 ;
32860 wxSizer *arg2 = (wxSizer *) 0 ;
32861 bool arg3 = (bool) true ;
32862 PyObject * obj0 = 0 ;
32863 PyObject * obj1 = 0 ;
32864 PyObject * obj2 = 0 ;
32865 char *kwnames[] = {
32866 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32867 };
32868
32869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32871 if (SWIG_arg_fail(1)) SWIG_fail;
32872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32873 if (SWIG_arg_fail(2)) SWIG_fail;
32874 if (obj2) {
32875 {
32876 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32877 if (SWIG_arg_fail(3)) SWIG_fail;
32878 }
32879 }
32880 {
32881 PyThreadState* __tstate = wxPyBeginAllowThreads();
32882 (arg1)->SetSizerAndFit(arg2,arg3);
32883
32884 wxPyEndAllowThreads(__tstate);
32885 if (PyErr_Occurred()) SWIG_fail;
32886 }
32887 Py_INCREF(Py_None); resultobj = Py_None;
32888 return resultobj;
32889 fail:
32890 return NULL;
32891 }
32892
32893
32894 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32895 PyObject *resultobj = NULL;
32896 wxWindow *arg1 = (wxWindow *) 0 ;
32897 wxSizer *result;
32898 PyObject * obj0 = 0 ;
32899 char *kwnames[] = {
32900 (char *) "self", NULL
32901 };
32902
32903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32905 if (SWIG_arg_fail(1)) SWIG_fail;
32906 {
32907 PyThreadState* __tstate = wxPyBeginAllowThreads();
32908 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32909
32910 wxPyEndAllowThreads(__tstate);
32911 if (PyErr_Occurred()) SWIG_fail;
32912 }
32913 {
32914 resultobj = wxPyMake_wxObject(result, (bool)0);
32915 }
32916 return resultobj;
32917 fail:
32918 return NULL;
32919 }
32920
32921
32922 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32923 PyObject *resultobj = NULL;
32924 wxWindow *arg1 = (wxWindow *) 0 ;
32925 wxSizer *arg2 = (wxSizer *) 0 ;
32926 PyObject * obj0 = 0 ;
32927 PyObject * obj1 = 0 ;
32928 char *kwnames[] = {
32929 (char *) "self",(char *) "sizer", NULL
32930 };
32931
32932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32934 if (SWIG_arg_fail(1)) SWIG_fail;
32935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32936 if (SWIG_arg_fail(2)) SWIG_fail;
32937 {
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 (arg1)->SetContainingSizer(arg2);
32940
32941 wxPyEndAllowThreads(__tstate);
32942 if (PyErr_Occurred()) SWIG_fail;
32943 }
32944 Py_INCREF(Py_None); resultobj = Py_None;
32945 return resultobj;
32946 fail:
32947 return NULL;
32948 }
32949
32950
32951 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32952 PyObject *resultobj = NULL;
32953 wxWindow *arg1 = (wxWindow *) 0 ;
32954 wxSizer *result;
32955 PyObject * obj0 = 0 ;
32956 char *kwnames[] = {
32957 (char *) "self", NULL
32958 };
32959
32960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32962 if (SWIG_arg_fail(1)) SWIG_fail;
32963 {
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32966
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 {
32971 resultobj = wxPyMake_wxObject(result, (bool)0);
32972 }
32973 return resultobj;
32974 fail:
32975 return NULL;
32976 }
32977
32978
32979 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32980 PyObject *resultobj = NULL;
32981 wxWindow *arg1 = (wxWindow *) 0 ;
32982 PyObject * obj0 = 0 ;
32983 char *kwnames[] = {
32984 (char *) "self", NULL
32985 };
32986
32987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32989 if (SWIG_arg_fail(1)) SWIG_fail;
32990 {
32991 PyThreadState* __tstate = wxPyBeginAllowThreads();
32992 (arg1)->InheritAttributes();
32993
32994 wxPyEndAllowThreads(__tstate);
32995 if (PyErr_Occurred()) SWIG_fail;
32996 }
32997 Py_INCREF(Py_None); resultobj = Py_None;
32998 return resultobj;
32999 fail:
33000 return NULL;
33001 }
33002
33003
33004 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
33005 PyObject *resultobj = NULL;
33006 wxWindow *arg1 = (wxWindow *) 0 ;
33007 bool result;
33008 PyObject * obj0 = 0 ;
33009 char *kwnames[] = {
33010 (char *) "self", NULL
33011 };
33012
33013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
33014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33015 if (SWIG_arg_fail(1)) SWIG_fail;
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
33019
33020 wxPyEndAllowThreads(__tstate);
33021 if (PyErr_Occurred()) SWIG_fail;
33022 }
33023 {
33024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33025 }
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
33033 PyObject *obj;
33034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33035 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
33036 Py_INCREF(obj);
33037 return Py_BuildValue((char *)"");
33038 }
33039 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
33040 PyObject *resultobj = NULL;
33041 long arg1 ;
33042 wxWindow *arg2 = (wxWindow *) NULL ;
33043 wxWindow *result;
33044 PyObject * obj0 = 0 ;
33045 PyObject * obj1 = 0 ;
33046 char *kwnames[] = {
33047 (char *) "id",(char *) "parent", NULL
33048 };
33049
33050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
33051 {
33052 arg1 = static_cast<long >(SWIG_As_long(obj0));
33053 if (SWIG_arg_fail(1)) SWIG_fail;
33054 }
33055 if (obj1) {
33056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33057 if (SWIG_arg_fail(2)) SWIG_fail;
33058 }
33059 {
33060 if (!wxPyCheckForApp()) SWIG_fail;
33061 PyThreadState* __tstate = wxPyBeginAllowThreads();
33062 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
33063
33064 wxPyEndAllowThreads(__tstate);
33065 if (PyErr_Occurred()) SWIG_fail;
33066 }
33067 {
33068 resultobj = wxPyMake_wxObject(result, 0);
33069 }
33070 return resultobj;
33071 fail:
33072 return NULL;
33073 }
33074
33075
33076 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
33077 PyObject *resultobj = NULL;
33078 wxString *arg1 = 0 ;
33079 wxWindow *arg2 = (wxWindow *) NULL ;
33080 wxWindow *result;
33081 bool temp1 = false ;
33082 PyObject * obj0 = 0 ;
33083 PyObject * obj1 = 0 ;
33084 char *kwnames[] = {
33085 (char *) "name",(char *) "parent", NULL
33086 };
33087
33088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
33089 {
33090 arg1 = wxString_in_helper(obj0);
33091 if (arg1 == NULL) SWIG_fail;
33092 temp1 = true;
33093 }
33094 if (obj1) {
33095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33096 if (SWIG_arg_fail(2)) SWIG_fail;
33097 }
33098 {
33099 if (!wxPyCheckForApp()) SWIG_fail;
33100 PyThreadState* __tstate = wxPyBeginAllowThreads();
33101 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
33102
33103 wxPyEndAllowThreads(__tstate);
33104 if (PyErr_Occurred()) SWIG_fail;
33105 }
33106 {
33107 resultobj = wxPyMake_wxObject(result, 0);
33108 }
33109 {
33110 if (temp1)
33111 delete arg1;
33112 }
33113 return resultobj;
33114 fail:
33115 {
33116 if (temp1)
33117 delete arg1;
33118 }
33119 return NULL;
33120 }
33121
33122
33123 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33124 PyObject *resultobj = NULL;
33125 wxString *arg1 = 0 ;
33126 wxWindow *arg2 = (wxWindow *) NULL ;
33127 wxWindow *result;
33128 bool temp1 = false ;
33129 PyObject * obj0 = 0 ;
33130 PyObject * obj1 = 0 ;
33131 char *kwnames[] = {
33132 (char *) "label",(char *) "parent", NULL
33133 };
33134
33135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33136 {
33137 arg1 = wxString_in_helper(obj0);
33138 if (arg1 == NULL) SWIG_fail;
33139 temp1 = true;
33140 }
33141 if (obj1) {
33142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33143 if (SWIG_arg_fail(2)) SWIG_fail;
33144 }
33145 {
33146 if (!wxPyCheckForApp()) SWIG_fail;
33147 PyThreadState* __tstate = wxPyBeginAllowThreads();
33148 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33149
33150 wxPyEndAllowThreads(__tstate);
33151 if (PyErr_Occurred()) SWIG_fail;
33152 }
33153 {
33154 resultobj = wxPyMake_wxObject(result, 0);
33155 }
33156 {
33157 if (temp1)
33158 delete arg1;
33159 }
33160 return resultobj;
33161 fail:
33162 {
33163 if (temp1)
33164 delete arg1;
33165 }
33166 return NULL;
33167 }
33168
33169
33170 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33171 PyObject *resultobj = NULL;
33172 wxWindow *arg1 = (wxWindow *) 0 ;
33173 unsigned long arg2 ;
33174 wxWindow *result;
33175 PyObject * obj0 = 0 ;
33176 PyObject * obj1 = 0 ;
33177 char *kwnames[] = {
33178 (char *) "parent",(char *) "_hWnd", NULL
33179 };
33180
33181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33183 if (SWIG_arg_fail(1)) SWIG_fail;
33184 {
33185 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33186 if (SWIG_arg_fail(2)) SWIG_fail;
33187 }
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33191
33192 wxPyEndAllowThreads(__tstate);
33193 if (PyErr_Occurred()) SWIG_fail;
33194 }
33195 {
33196 resultobj = wxPyMake_wxObject(result, 0);
33197 }
33198 return resultobj;
33199 fail:
33200 return NULL;
33201 }
33202
33203
33204 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33205 PyObject *resultobj = NULL;
33206 PyObject *result;
33207 char *kwnames[] = {
33208 NULL
33209 };
33210
33211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 result = (PyObject *)GetTopLevelWindows();
33215
33216 wxPyEndAllowThreads(__tstate);
33217 if (PyErr_Occurred()) SWIG_fail;
33218 }
33219 resultobj = result;
33220 return resultobj;
33221 fail:
33222 return NULL;
33223 }
33224
33225
33226 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33227 PyObject *resultobj = NULL;
33228 wxValidator *result;
33229 char *kwnames[] = {
33230 NULL
33231 };
33232
33233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 result = (wxValidator *)new wxValidator();
33237
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33242 return resultobj;
33243 fail:
33244 return NULL;
33245 }
33246
33247
33248 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33249 PyObject *resultobj = NULL;
33250 wxValidator *arg1 = (wxValidator *) 0 ;
33251 wxValidator *result;
33252 PyObject * obj0 = 0 ;
33253 char *kwnames[] = {
33254 (char *) "self", NULL
33255 };
33256
33257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33259 if (SWIG_arg_fail(1)) SWIG_fail;
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 result = (wxValidator *)(arg1)->Clone();
33263
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 {
33268 resultobj = wxPyMake_wxObject(result, 0);
33269 }
33270 return resultobj;
33271 fail:
33272 return NULL;
33273 }
33274
33275
33276 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33277 PyObject *resultobj = NULL;
33278 wxValidator *arg1 = (wxValidator *) 0 ;
33279 wxWindow *arg2 = (wxWindow *) 0 ;
33280 bool result;
33281 PyObject * obj0 = 0 ;
33282 PyObject * obj1 = 0 ;
33283 char *kwnames[] = {
33284 (char *) "self",(char *) "parent", NULL
33285 };
33286
33287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33289 if (SWIG_arg_fail(1)) SWIG_fail;
33290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33291 if (SWIG_arg_fail(2)) SWIG_fail;
33292 {
33293 PyThreadState* __tstate = wxPyBeginAllowThreads();
33294 result = (bool)(arg1)->Validate(arg2);
33295
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 {
33300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33301 }
33302 return resultobj;
33303 fail:
33304 return NULL;
33305 }
33306
33307
33308 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33309 PyObject *resultobj = NULL;
33310 wxValidator *arg1 = (wxValidator *) 0 ;
33311 bool result;
33312 PyObject * obj0 = 0 ;
33313 char *kwnames[] = {
33314 (char *) "self", NULL
33315 };
33316
33317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33319 if (SWIG_arg_fail(1)) SWIG_fail;
33320 {
33321 PyThreadState* __tstate = wxPyBeginAllowThreads();
33322 result = (bool)(arg1)->TransferToWindow();
33323
33324 wxPyEndAllowThreads(__tstate);
33325 if (PyErr_Occurred()) SWIG_fail;
33326 }
33327 {
33328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33329 }
33330 return resultobj;
33331 fail:
33332 return NULL;
33333 }
33334
33335
33336 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33337 PyObject *resultobj = NULL;
33338 wxValidator *arg1 = (wxValidator *) 0 ;
33339 bool result;
33340 PyObject * obj0 = 0 ;
33341 char *kwnames[] = {
33342 (char *) "self", NULL
33343 };
33344
33345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33347 if (SWIG_arg_fail(1)) SWIG_fail;
33348 {
33349 PyThreadState* __tstate = wxPyBeginAllowThreads();
33350 result = (bool)(arg1)->TransferFromWindow();
33351
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 {
33356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33357 }
33358 return resultobj;
33359 fail:
33360 return NULL;
33361 }
33362
33363
33364 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33365 PyObject *resultobj = NULL;
33366 wxValidator *arg1 = (wxValidator *) 0 ;
33367 wxWindow *result;
33368 PyObject * obj0 = 0 ;
33369 char *kwnames[] = {
33370 (char *) "self", NULL
33371 };
33372
33373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33375 if (SWIG_arg_fail(1)) SWIG_fail;
33376 {
33377 PyThreadState* __tstate = wxPyBeginAllowThreads();
33378 result = (wxWindow *)(arg1)->GetWindow();
33379
33380 wxPyEndAllowThreads(__tstate);
33381 if (PyErr_Occurred()) SWIG_fail;
33382 }
33383 {
33384 resultobj = wxPyMake_wxObject(result, 0);
33385 }
33386 return resultobj;
33387 fail:
33388 return NULL;
33389 }
33390
33391
33392 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33393 PyObject *resultobj = NULL;
33394 wxValidator *arg1 = (wxValidator *) 0 ;
33395 wxWindow *arg2 = (wxWindow *) 0 ;
33396 PyObject * obj0 = 0 ;
33397 PyObject * obj1 = 0 ;
33398 char *kwnames[] = {
33399 (char *) "self",(char *) "window", NULL
33400 };
33401
33402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33404 if (SWIG_arg_fail(1)) SWIG_fail;
33405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33406 if (SWIG_arg_fail(2)) SWIG_fail;
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 (arg1)->SetWindow(arg2);
33410
33411 wxPyEndAllowThreads(__tstate);
33412 if (PyErr_Occurred()) SWIG_fail;
33413 }
33414 Py_INCREF(Py_None); resultobj = Py_None;
33415 return resultobj;
33416 fail:
33417 return NULL;
33418 }
33419
33420
33421 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33422 PyObject *resultobj = NULL;
33423 bool result;
33424 char *kwnames[] = {
33425 NULL
33426 };
33427
33428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33429 {
33430 PyThreadState* __tstate = wxPyBeginAllowThreads();
33431 result = (bool)wxValidator::IsSilent();
33432
33433 wxPyEndAllowThreads(__tstate);
33434 if (PyErr_Occurred()) SWIG_fail;
33435 }
33436 {
33437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33438 }
33439 return resultobj;
33440 fail:
33441 return NULL;
33442 }
33443
33444
33445 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33446 PyObject *resultobj = NULL;
33447 int arg1 = (int) true ;
33448 PyObject * obj0 = 0 ;
33449 char *kwnames[] = {
33450 (char *) "doIt", NULL
33451 };
33452
33453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33454 if (obj0) {
33455 {
33456 arg1 = static_cast<int >(SWIG_As_int(obj0));
33457 if (SWIG_arg_fail(1)) SWIG_fail;
33458 }
33459 }
33460 {
33461 PyThreadState* __tstate = wxPyBeginAllowThreads();
33462 wxValidator::SetBellOnError(arg1);
33463
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 Py_INCREF(Py_None); resultobj = Py_None;
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33475 PyObject *obj;
33476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33477 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33478 Py_INCREF(obj);
33479 return Py_BuildValue((char *)"");
33480 }
33481 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33482 PyObject *resultobj = NULL;
33483 wxPyValidator *result;
33484 char *kwnames[] = {
33485 NULL
33486 };
33487
33488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 result = (wxPyValidator *)new wxPyValidator();
33492
33493 wxPyEndAllowThreads(__tstate);
33494 if (PyErr_Occurred()) SWIG_fail;
33495 }
33496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33497 return resultobj;
33498 fail:
33499 return NULL;
33500 }
33501
33502
33503 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33504 PyObject *resultobj = NULL;
33505 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33506 PyObject *arg2 = (PyObject *) 0 ;
33507 PyObject *arg3 = (PyObject *) 0 ;
33508 int arg4 = (int) true ;
33509 PyObject * obj0 = 0 ;
33510 PyObject * obj1 = 0 ;
33511 PyObject * obj2 = 0 ;
33512 PyObject * obj3 = 0 ;
33513 char *kwnames[] = {
33514 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33515 };
33516
33517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33519 if (SWIG_arg_fail(1)) SWIG_fail;
33520 arg2 = obj1;
33521 arg3 = obj2;
33522 if (obj3) {
33523 {
33524 arg4 = static_cast<int >(SWIG_As_int(obj3));
33525 if (SWIG_arg_fail(4)) SWIG_fail;
33526 }
33527 }
33528 {
33529 PyThreadState* __tstate = wxPyBeginAllowThreads();
33530 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33531
33532 wxPyEndAllowThreads(__tstate);
33533 if (PyErr_Occurred()) SWIG_fail;
33534 }
33535 Py_INCREF(Py_None); resultobj = Py_None;
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33543 PyObject *obj;
33544 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33545 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33546 Py_INCREF(obj);
33547 return Py_BuildValue((char *)"");
33548 }
33549 static int _wrap_DefaultValidator_set(PyObject *) {
33550 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33551 return 1;
33552 }
33553
33554
33555 static PyObject *_wrap_DefaultValidator_get(void) {
33556 PyObject *pyobj = NULL;
33557
33558 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33559 return pyobj;
33560 }
33561
33562
33563 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33564 PyObject *resultobj = NULL;
33565 wxString const &arg1_defvalue = wxPyEmptyString ;
33566 wxString *arg1 = (wxString *) &arg1_defvalue ;
33567 long arg2 = (long) 0 ;
33568 wxMenu *result;
33569 bool temp1 = false ;
33570 PyObject * obj0 = 0 ;
33571 PyObject * obj1 = 0 ;
33572 char *kwnames[] = {
33573 (char *) "title",(char *) "style", NULL
33574 };
33575
33576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33577 if (obj0) {
33578 {
33579 arg1 = wxString_in_helper(obj0);
33580 if (arg1 == NULL) SWIG_fail;
33581 temp1 = true;
33582 }
33583 }
33584 if (obj1) {
33585 {
33586 arg2 = static_cast<long >(SWIG_As_long(obj1));
33587 if (SWIG_arg_fail(2)) SWIG_fail;
33588 }
33589 }
33590 {
33591 if (!wxPyCheckForApp()) SWIG_fail;
33592 PyThreadState* __tstate = wxPyBeginAllowThreads();
33593 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33594
33595 wxPyEndAllowThreads(__tstate);
33596 if (PyErr_Occurred()) SWIG_fail;
33597 }
33598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33599 {
33600 if (temp1)
33601 delete arg1;
33602 }
33603 return resultobj;
33604 fail:
33605 {
33606 if (temp1)
33607 delete arg1;
33608 }
33609 return NULL;
33610 }
33611
33612
33613 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj = NULL;
33615 wxMenu *arg1 = (wxMenu *) 0 ;
33616 int arg2 ;
33617 wxString *arg3 = 0 ;
33618 wxString const &arg4_defvalue = wxPyEmptyString ;
33619 wxString *arg4 = (wxString *) &arg4_defvalue ;
33620 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33621 wxMenuItem *result;
33622 bool temp3 = false ;
33623 bool temp4 = false ;
33624 PyObject * obj0 = 0 ;
33625 PyObject * obj1 = 0 ;
33626 PyObject * obj2 = 0 ;
33627 PyObject * obj3 = 0 ;
33628 PyObject * obj4 = 0 ;
33629 char *kwnames[] = {
33630 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33631 };
33632
33633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33635 if (SWIG_arg_fail(1)) SWIG_fail;
33636 {
33637 arg2 = static_cast<int >(SWIG_As_int(obj1));
33638 if (SWIG_arg_fail(2)) SWIG_fail;
33639 }
33640 {
33641 arg3 = wxString_in_helper(obj2);
33642 if (arg3 == NULL) SWIG_fail;
33643 temp3 = true;
33644 }
33645 if (obj3) {
33646 {
33647 arg4 = wxString_in_helper(obj3);
33648 if (arg4 == NULL) SWIG_fail;
33649 temp4 = true;
33650 }
33651 }
33652 if (obj4) {
33653 {
33654 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33655 if (SWIG_arg_fail(5)) SWIG_fail;
33656 }
33657 }
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33661
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 {
33666 resultobj = wxPyMake_wxObject(result, (bool)0);
33667 }
33668 {
33669 if (temp3)
33670 delete arg3;
33671 }
33672 {
33673 if (temp4)
33674 delete arg4;
33675 }
33676 return resultobj;
33677 fail:
33678 {
33679 if (temp3)
33680 delete arg3;
33681 }
33682 {
33683 if (temp4)
33684 delete arg4;
33685 }
33686 return NULL;
33687 }
33688
33689
33690 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33691 PyObject *resultobj = NULL;
33692 wxMenu *arg1 = (wxMenu *) 0 ;
33693 wxMenuItem *result;
33694 PyObject * obj0 = 0 ;
33695 char *kwnames[] = {
33696 (char *) "self", NULL
33697 };
33698
33699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33701 if (SWIG_arg_fail(1)) SWIG_fail;
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 result = (wxMenuItem *)(arg1)->AppendSeparator();
33705
33706 wxPyEndAllowThreads(__tstate);
33707 if (PyErr_Occurred()) SWIG_fail;
33708 }
33709 {
33710 resultobj = wxPyMake_wxObject(result, (bool)0);
33711 }
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33719 PyObject *resultobj = NULL;
33720 wxMenu *arg1 = (wxMenu *) 0 ;
33721 int arg2 ;
33722 wxString *arg3 = 0 ;
33723 wxString const &arg4_defvalue = wxPyEmptyString ;
33724 wxString *arg4 = (wxString *) &arg4_defvalue ;
33725 wxMenuItem *result;
33726 bool temp3 = false ;
33727 bool temp4 = false ;
33728 PyObject * obj0 = 0 ;
33729 PyObject * obj1 = 0 ;
33730 PyObject * obj2 = 0 ;
33731 PyObject * obj3 = 0 ;
33732 char *kwnames[] = {
33733 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33734 };
33735
33736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33738 if (SWIG_arg_fail(1)) SWIG_fail;
33739 {
33740 arg2 = static_cast<int >(SWIG_As_int(obj1));
33741 if (SWIG_arg_fail(2)) SWIG_fail;
33742 }
33743 {
33744 arg3 = wxString_in_helper(obj2);
33745 if (arg3 == NULL) SWIG_fail;
33746 temp3 = true;
33747 }
33748 if (obj3) {
33749 {
33750 arg4 = wxString_in_helper(obj3);
33751 if (arg4 == NULL) SWIG_fail;
33752 temp4 = true;
33753 }
33754 }
33755 {
33756 PyThreadState* __tstate = wxPyBeginAllowThreads();
33757 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33758
33759 wxPyEndAllowThreads(__tstate);
33760 if (PyErr_Occurred()) SWIG_fail;
33761 }
33762 {
33763 resultobj = wxPyMake_wxObject(result, (bool)0);
33764 }
33765 {
33766 if (temp3)
33767 delete arg3;
33768 }
33769 {
33770 if (temp4)
33771 delete arg4;
33772 }
33773 return resultobj;
33774 fail:
33775 {
33776 if (temp3)
33777 delete arg3;
33778 }
33779 {
33780 if (temp4)
33781 delete arg4;
33782 }
33783 return NULL;
33784 }
33785
33786
33787 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33788 PyObject *resultobj = NULL;
33789 wxMenu *arg1 = (wxMenu *) 0 ;
33790 int arg2 ;
33791 wxString *arg3 = 0 ;
33792 wxString const &arg4_defvalue = wxPyEmptyString ;
33793 wxString *arg4 = (wxString *) &arg4_defvalue ;
33794 wxMenuItem *result;
33795 bool temp3 = false ;
33796 bool temp4 = false ;
33797 PyObject * obj0 = 0 ;
33798 PyObject * obj1 = 0 ;
33799 PyObject * obj2 = 0 ;
33800 PyObject * obj3 = 0 ;
33801 char *kwnames[] = {
33802 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33803 };
33804
33805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33807 if (SWIG_arg_fail(1)) SWIG_fail;
33808 {
33809 arg2 = static_cast<int >(SWIG_As_int(obj1));
33810 if (SWIG_arg_fail(2)) SWIG_fail;
33811 }
33812 {
33813 arg3 = wxString_in_helper(obj2);
33814 if (arg3 == NULL) SWIG_fail;
33815 temp3 = true;
33816 }
33817 if (obj3) {
33818 {
33819 arg4 = wxString_in_helper(obj3);
33820 if (arg4 == NULL) SWIG_fail;
33821 temp4 = true;
33822 }
33823 }
33824 {
33825 PyThreadState* __tstate = wxPyBeginAllowThreads();
33826 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33827
33828 wxPyEndAllowThreads(__tstate);
33829 if (PyErr_Occurred()) SWIG_fail;
33830 }
33831 {
33832 resultobj = wxPyMake_wxObject(result, (bool)0);
33833 }
33834 {
33835 if (temp3)
33836 delete arg3;
33837 }
33838 {
33839 if (temp4)
33840 delete arg4;
33841 }
33842 return resultobj;
33843 fail:
33844 {
33845 if (temp3)
33846 delete arg3;
33847 }
33848 {
33849 if (temp4)
33850 delete arg4;
33851 }
33852 return NULL;
33853 }
33854
33855
33856 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33857 PyObject *resultobj = NULL;
33858 wxMenu *arg1 = (wxMenu *) 0 ;
33859 int arg2 ;
33860 wxString *arg3 = 0 ;
33861 wxMenu *arg4 = (wxMenu *) 0 ;
33862 wxString const &arg5_defvalue = wxPyEmptyString ;
33863 wxString *arg5 = (wxString *) &arg5_defvalue ;
33864 wxMenuItem *result;
33865 bool temp3 = false ;
33866 bool temp5 = false ;
33867 PyObject * obj0 = 0 ;
33868 PyObject * obj1 = 0 ;
33869 PyObject * obj2 = 0 ;
33870 PyObject * obj3 = 0 ;
33871 PyObject * obj4 = 0 ;
33872 char *kwnames[] = {
33873 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33874 };
33875
33876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33878 if (SWIG_arg_fail(1)) SWIG_fail;
33879 {
33880 arg2 = static_cast<int >(SWIG_As_int(obj1));
33881 if (SWIG_arg_fail(2)) SWIG_fail;
33882 }
33883 {
33884 arg3 = wxString_in_helper(obj2);
33885 if (arg3 == NULL) SWIG_fail;
33886 temp3 = true;
33887 }
33888 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33889 if (SWIG_arg_fail(4)) SWIG_fail;
33890 if (obj4) {
33891 {
33892 arg5 = wxString_in_helper(obj4);
33893 if (arg5 == NULL) SWIG_fail;
33894 temp5 = true;
33895 }
33896 }
33897 {
33898 PyThreadState* __tstate = wxPyBeginAllowThreads();
33899 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33900
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = wxPyMake_wxObject(result, (bool)0);
33906 }
33907 {
33908 if (temp3)
33909 delete arg3;
33910 }
33911 {
33912 if (temp5)
33913 delete arg5;
33914 }
33915 return resultobj;
33916 fail:
33917 {
33918 if (temp3)
33919 delete arg3;
33920 }
33921 {
33922 if (temp5)
33923 delete arg5;
33924 }
33925 return NULL;
33926 }
33927
33928
33929 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj = NULL;
33931 wxMenu *arg1 = (wxMenu *) 0 ;
33932 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33933 wxMenuItem *result;
33934 PyObject * obj0 = 0 ;
33935 PyObject * obj1 = 0 ;
33936 char *kwnames[] = {
33937 (char *) "self",(char *) "item", NULL
33938 };
33939
33940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33942 if (SWIG_arg_fail(1)) SWIG_fail;
33943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33944 if (SWIG_arg_fail(2)) SWIG_fail;
33945 {
33946 PyThreadState* __tstate = wxPyBeginAllowThreads();
33947 result = (wxMenuItem *)(arg1)->Append(arg2);
33948
33949 wxPyEndAllowThreads(__tstate);
33950 if (PyErr_Occurred()) SWIG_fail;
33951 }
33952 {
33953 resultobj = wxPyMake_wxObject(result, (bool)0);
33954 }
33955 return resultobj;
33956 fail:
33957 return NULL;
33958 }
33959
33960
33961 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33962 PyObject *resultobj = NULL;
33963 wxMenu *arg1 = (wxMenu *) 0 ;
33964 PyObject * obj0 = 0 ;
33965 char *kwnames[] = {
33966 (char *) "self", NULL
33967 };
33968
33969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33971 if (SWIG_arg_fail(1)) SWIG_fail;
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 (arg1)->Break();
33975
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 Py_INCREF(Py_None); resultobj = Py_None;
33980 return resultobj;
33981 fail:
33982 return NULL;
33983 }
33984
33985
33986 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33987 PyObject *resultobj = NULL;
33988 wxMenu *arg1 = (wxMenu *) 0 ;
33989 size_t arg2 ;
33990 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33991 wxMenuItem *result;
33992 PyObject * obj0 = 0 ;
33993 PyObject * obj1 = 0 ;
33994 PyObject * obj2 = 0 ;
33995 char *kwnames[] = {
33996 (char *) "self",(char *) "pos",(char *) "item", NULL
33997 };
33998
33999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34001 if (SWIG_arg_fail(1)) SWIG_fail;
34002 {
34003 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34004 if (SWIG_arg_fail(2)) SWIG_fail;
34005 }
34006 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34007 if (SWIG_arg_fail(3)) SWIG_fail;
34008 {
34009 PyThreadState* __tstate = wxPyBeginAllowThreads();
34010 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
34011
34012 wxPyEndAllowThreads(__tstate);
34013 if (PyErr_Occurred()) SWIG_fail;
34014 }
34015 {
34016 resultobj = wxPyMake_wxObject(result, (bool)0);
34017 }
34018 return resultobj;
34019 fail:
34020 return NULL;
34021 }
34022
34023
34024 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34025 PyObject *resultobj = NULL;
34026 wxMenu *arg1 = (wxMenu *) 0 ;
34027 size_t arg2 ;
34028 int arg3 ;
34029 wxString *arg4 = 0 ;
34030 wxString const &arg5_defvalue = wxPyEmptyString ;
34031 wxString *arg5 = (wxString *) &arg5_defvalue ;
34032 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
34033 wxMenuItem *result;
34034 bool temp4 = false ;
34035 bool temp5 = false ;
34036 PyObject * obj0 = 0 ;
34037 PyObject * obj1 = 0 ;
34038 PyObject * obj2 = 0 ;
34039 PyObject * obj3 = 0 ;
34040 PyObject * obj4 = 0 ;
34041 PyObject * obj5 = 0 ;
34042 char *kwnames[] = {
34043 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34044 };
34045
34046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34048 if (SWIG_arg_fail(1)) SWIG_fail;
34049 {
34050 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34051 if (SWIG_arg_fail(2)) SWIG_fail;
34052 }
34053 {
34054 arg3 = static_cast<int >(SWIG_As_int(obj2));
34055 if (SWIG_arg_fail(3)) SWIG_fail;
34056 }
34057 {
34058 arg4 = wxString_in_helper(obj3);
34059 if (arg4 == NULL) SWIG_fail;
34060 temp4 = true;
34061 }
34062 if (obj4) {
34063 {
34064 arg5 = wxString_in_helper(obj4);
34065 if (arg5 == NULL) SWIG_fail;
34066 temp5 = true;
34067 }
34068 }
34069 if (obj5) {
34070 {
34071 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
34072 if (SWIG_arg_fail(6)) SWIG_fail;
34073 }
34074 }
34075 {
34076 PyThreadState* __tstate = wxPyBeginAllowThreads();
34077 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
34078
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 {
34083 resultobj = wxPyMake_wxObject(result, (bool)0);
34084 }
34085 {
34086 if (temp4)
34087 delete arg4;
34088 }
34089 {
34090 if (temp5)
34091 delete arg5;
34092 }
34093 return resultobj;
34094 fail:
34095 {
34096 if (temp4)
34097 delete arg4;
34098 }
34099 {
34100 if (temp5)
34101 delete arg5;
34102 }
34103 return NULL;
34104 }
34105
34106
34107 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = NULL;
34109 wxMenu *arg1 = (wxMenu *) 0 ;
34110 size_t arg2 ;
34111 wxMenuItem *result;
34112 PyObject * obj0 = 0 ;
34113 PyObject * obj1 = 0 ;
34114 char *kwnames[] = {
34115 (char *) "self",(char *) "pos", NULL
34116 };
34117
34118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
34119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34120 if (SWIG_arg_fail(1)) SWIG_fail;
34121 {
34122 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34123 if (SWIG_arg_fail(2)) SWIG_fail;
34124 }
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
34128
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 {
34133 resultobj = wxPyMake_wxObject(result, (bool)0);
34134 }
34135 return resultobj;
34136 fail:
34137 return NULL;
34138 }
34139
34140
34141 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34142 PyObject *resultobj = NULL;
34143 wxMenu *arg1 = (wxMenu *) 0 ;
34144 size_t arg2 ;
34145 int arg3 ;
34146 wxString *arg4 = 0 ;
34147 wxString const &arg5_defvalue = wxPyEmptyString ;
34148 wxString *arg5 = (wxString *) &arg5_defvalue ;
34149 wxMenuItem *result;
34150 bool temp4 = false ;
34151 bool temp5 = false ;
34152 PyObject * obj0 = 0 ;
34153 PyObject * obj1 = 0 ;
34154 PyObject * obj2 = 0 ;
34155 PyObject * obj3 = 0 ;
34156 PyObject * obj4 = 0 ;
34157 char *kwnames[] = {
34158 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34159 };
34160
34161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34163 if (SWIG_arg_fail(1)) SWIG_fail;
34164 {
34165 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34166 if (SWIG_arg_fail(2)) SWIG_fail;
34167 }
34168 {
34169 arg3 = static_cast<int >(SWIG_As_int(obj2));
34170 if (SWIG_arg_fail(3)) SWIG_fail;
34171 }
34172 {
34173 arg4 = wxString_in_helper(obj3);
34174 if (arg4 == NULL) SWIG_fail;
34175 temp4 = true;
34176 }
34177 if (obj4) {
34178 {
34179 arg5 = wxString_in_helper(obj4);
34180 if (arg5 == NULL) SWIG_fail;
34181 temp5 = true;
34182 }
34183 }
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34187
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 {
34192 resultobj = wxPyMake_wxObject(result, (bool)0);
34193 }
34194 {
34195 if (temp4)
34196 delete arg4;
34197 }
34198 {
34199 if (temp5)
34200 delete arg5;
34201 }
34202 return resultobj;
34203 fail:
34204 {
34205 if (temp4)
34206 delete arg4;
34207 }
34208 {
34209 if (temp5)
34210 delete arg5;
34211 }
34212 return NULL;
34213 }
34214
34215
34216 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34217 PyObject *resultobj = NULL;
34218 wxMenu *arg1 = (wxMenu *) 0 ;
34219 size_t arg2 ;
34220 int arg3 ;
34221 wxString *arg4 = 0 ;
34222 wxString const &arg5_defvalue = wxPyEmptyString ;
34223 wxString *arg5 = (wxString *) &arg5_defvalue ;
34224 wxMenuItem *result;
34225 bool temp4 = false ;
34226 bool temp5 = false ;
34227 PyObject * obj0 = 0 ;
34228 PyObject * obj1 = 0 ;
34229 PyObject * obj2 = 0 ;
34230 PyObject * obj3 = 0 ;
34231 PyObject * obj4 = 0 ;
34232 char *kwnames[] = {
34233 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34234 };
34235
34236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34238 if (SWIG_arg_fail(1)) SWIG_fail;
34239 {
34240 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34241 if (SWIG_arg_fail(2)) SWIG_fail;
34242 }
34243 {
34244 arg3 = static_cast<int >(SWIG_As_int(obj2));
34245 if (SWIG_arg_fail(3)) SWIG_fail;
34246 }
34247 {
34248 arg4 = wxString_in_helper(obj3);
34249 if (arg4 == NULL) SWIG_fail;
34250 temp4 = true;
34251 }
34252 if (obj4) {
34253 {
34254 arg5 = wxString_in_helper(obj4);
34255 if (arg5 == NULL) SWIG_fail;
34256 temp5 = true;
34257 }
34258 }
34259 {
34260 PyThreadState* __tstate = wxPyBeginAllowThreads();
34261 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34262
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 {
34267 resultobj = wxPyMake_wxObject(result, (bool)0);
34268 }
34269 {
34270 if (temp4)
34271 delete arg4;
34272 }
34273 {
34274 if (temp5)
34275 delete arg5;
34276 }
34277 return resultobj;
34278 fail:
34279 {
34280 if (temp4)
34281 delete arg4;
34282 }
34283 {
34284 if (temp5)
34285 delete arg5;
34286 }
34287 return NULL;
34288 }
34289
34290
34291 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34292 PyObject *resultobj = NULL;
34293 wxMenu *arg1 = (wxMenu *) 0 ;
34294 size_t arg2 ;
34295 int arg3 ;
34296 wxString *arg4 = 0 ;
34297 wxMenu *arg5 = (wxMenu *) 0 ;
34298 wxString const &arg6_defvalue = wxPyEmptyString ;
34299 wxString *arg6 = (wxString *) &arg6_defvalue ;
34300 wxMenuItem *result;
34301 bool temp4 = false ;
34302 bool temp6 = false ;
34303 PyObject * obj0 = 0 ;
34304 PyObject * obj1 = 0 ;
34305 PyObject * obj2 = 0 ;
34306 PyObject * obj3 = 0 ;
34307 PyObject * obj4 = 0 ;
34308 PyObject * obj5 = 0 ;
34309 char *kwnames[] = {
34310 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34311 };
34312
34313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34315 if (SWIG_arg_fail(1)) SWIG_fail;
34316 {
34317 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34318 if (SWIG_arg_fail(2)) SWIG_fail;
34319 }
34320 {
34321 arg3 = static_cast<int >(SWIG_As_int(obj2));
34322 if (SWIG_arg_fail(3)) SWIG_fail;
34323 }
34324 {
34325 arg4 = wxString_in_helper(obj3);
34326 if (arg4 == NULL) SWIG_fail;
34327 temp4 = true;
34328 }
34329 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34330 if (SWIG_arg_fail(5)) SWIG_fail;
34331 if (obj5) {
34332 {
34333 arg6 = wxString_in_helper(obj5);
34334 if (arg6 == NULL) SWIG_fail;
34335 temp6 = true;
34336 }
34337 }
34338 {
34339 PyThreadState* __tstate = wxPyBeginAllowThreads();
34340 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34341
34342 wxPyEndAllowThreads(__tstate);
34343 if (PyErr_Occurred()) SWIG_fail;
34344 }
34345 {
34346 resultobj = wxPyMake_wxObject(result, (bool)0);
34347 }
34348 {
34349 if (temp4)
34350 delete arg4;
34351 }
34352 {
34353 if (temp6)
34354 delete arg6;
34355 }
34356 return resultobj;
34357 fail:
34358 {
34359 if (temp4)
34360 delete arg4;
34361 }
34362 {
34363 if (temp6)
34364 delete arg6;
34365 }
34366 return NULL;
34367 }
34368
34369
34370 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34371 PyObject *resultobj = NULL;
34372 wxMenu *arg1 = (wxMenu *) 0 ;
34373 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34374 wxMenuItem *result;
34375 PyObject * obj0 = 0 ;
34376 PyObject * obj1 = 0 ;
34377 char *kwnames[] = {
34378 (char *) "self",(char *) "item", NULL
34379 };
34380
34381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34383 if (SWIG_arg_fail(1)) SWIG_fail;
34384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34385 if (SWIG_arg_fail(2)) SWIG_fail;
34386 {
34387 PyThreadState* __tstate = wxPyBeginAllowThreads();
34388 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34389
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 {
34394 resultobj = wxPyMake_wxObject(result, (bool)0);
34395 }
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj = NULL;
34404 wxMenu *arg1 = (wxMenu *) 0 ;
34405 int arg2 ;
34406 wxString *arg3 = 0 ;
34407 wxString const &arg4_defvalue = wxPyEmptyString ;
34408 wxString *arg4 = (wxString *) &arg4_defvalue ;
34409 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34410 wxMenuItem *result;
34411 bool temp3 = false ;
34412 bool temp4 = false ;
34413 PyObject * obj0 = 0 ;
34414 PyObject * obj1 = 0 ;
34415 PyObject * obj2 = 0 ;
34416 PyObject * obj3 = 0 ;
34417 PyObject * obj4 = 0 ;
34418 char *kwnames[] = {
34419 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34420 };
34421
34422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34424 if (SWIG_arg_fail(1)) SWIG_fail;
34425 {
34426 arg2 = static_cast<int >(SWIG_As_int(obj1));
34427 if (SWIG_arg_fail(2)) SWIG_fail;
34428 }
34429 {
34430 arg3 = wxString_in_helper(obj2);
34431 if (arg3 == NULL) SWIG_fail;
34432 temp3 = true;
34433 }
34434 if (obj3) {
34435 {
34436 arg4 = wxString_in_helper(obj3);
34437 if (arg4 == NULL) SWIG_fail;
34438 temp4 = true;
34439 }
34440 }
34441 if (obj4) {
34442 {
34443 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34444 if (SWIG_arg_fail(5)) SWIG_fail;
34445 }
34446 }
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34450
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 {
34455 resultobj = wxPyMake_wxObject(result, (bool)0);
34456 }
34457 {
34458 if (temp3)
34459 delete arg3;
34460 }
34461 {
34462 if (temp4)
34463 delete arg4;
34464 }
34465 return resultobj;
34466 fail:
34467 {
34468 if (temp3)
34469 delete arg3;
34470 }
34471 {
34472 if (temp4)
34473 delete arg4;
34474 }
34475 return NULL;
34476 }
34477
34478
34479 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34480 PyObject *resultobj = NULL;
34481 wxMenu *arg1 = (wxMenu *) 0 ;
34482 wxMenuItem *result;
34483 PyObject * obj0 = 0 ;
34484 char *kwnames[] = {
34485 (char *) "self", NULL
34486 };
34487
34488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34490 if (SWIG_arg_fail(1)) SWIG_fail;
34491 {
34492 PyThreadState* __tstate = wxPyBeginAllowThreads();
34493 result = (wxMenuItem *)(arg1)->PrependSeparator();
34494
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 {
34499 resultobj = wxPyMake_wxObject(result, (bool)0);
34500 }
34501 return resultobj;
34502 fail:
34503 return NULL;
34504 }
34505
34506
34507 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34508 PyObject *resultobj = NULL;
34509 wxMenu *arg1 = (wxMenu *) 0 ;
34510 int arg2 ;
34511 wxString *arg3 = 0 ;
34512 wxString const &arg4_defvalue = wxPyEmptyString ;
34513 wxString *arg4 = (wxString *) &arg4_defvalue ;
34514 wxMenuItem *result;
34515 bool temp3 = false ;
34516 bool temp4 = false ;
34517 PyObject * obj0 = 0 ;
34518 PyObject * obj1 = 0 ;
34519 PyObject * obj2 = 0 ;
34520 PyObject * obj3 = 0 ;
34521 char *kwnames[] = {
34522 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34523 };
34524
34525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34527 if (SWIG_arg_fail(1)) SWIG_fail;
34528 {
34529 arg2 = static_cast<int >(SWIG_As_int(obj1));
34530 if (SWIG_arg_fail(2)) SWIG_fail;
34531 }
34532 {
34533 arg3 = wxString_in_helper(obj2);
34534 if (arg3 == NULL) SWIG_fail;
34535 temp3 = true;
34536 }
34537 if (obj3) {
34538 {
34539 arg4 = wxString_in_helper(obj3);
34540 if (arg4 == NULL) SWIG_fail;
34541 temp4 = true;
34542 }
34543 }
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34547
34548 wxPyEndAllowThreads(__tstate);
34549 if (PyErr_Occurred()) SWIG_fail;
34550 }
34551 {
34552 resultobj = wxPyMake_wxObject(result, (bool)0);
34553 }
34554 {
34555 if (temp3)
34556 delete arg3;
34557 }
34558 {
34559 if (temp4)
34560 delete arg4;
34561 }
34562 return resultobj;
34563 fail:
34564 {
34565 if (temp3)
34566 delete arg3;
34567 }
34568 {
34569 if (temp4)
34570 delete arg4;
34571 }
34572 return NULL;
34573 }
34574
34575
34576 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34577 PyObject *resultobj = NULL;
34578 wxMenu *arg1 = (wxMenu *) 0 ;
34579 int arg2 ;
34580 wxString *arg3 = 0 ;
34581 wxString const &arg4_defvalue = wxPyEmptyString ;
34582 wxString *arg4 = (wxString *) &arg4_defvalue ;
34583 wxMenuItem *result;
34584 bool temp3 = false ;
34585 bool temp4 = false ;
34586 PyObject * obj0 = 0 ;
34587 PyObject * obj1 = 0 ;
34588 PyObject * obj2 = 0 ;
34589 PyObject * obj3 = 0 ;
34590 char *kwnames[] = {
34591 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34592 };
34593
34594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34596 if (SWIG_arg_fail(1)) SWIG_fail;
34597 {
34598 arg2 = static_cast<int >(SWIG_As_int(obj1));
34599 if (SWIG_arg_fail(2)) SWIG_fail;
34600 }
34601 {
34602 arg3 = wxString_in_helper(obj2);
34603 if (arg3 == NULL) SWIG_fail;
34604 temp3 = true;
34605 }
34606 if (obj3) {
34607 {
34608 arg4 = wxString_in_helper(obj3);
34609 if (arg4 == NULL) SWIG_fail;
34610 temp4 = true;
34611 }
34612 }
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34616
34617 wxPyEndAllowThreads(__tstate);
34618 if (PyErr_Occurred()) SWIG_fail;
34619 }
34620 {
34621 resultobj = wxPyMake_wxObject(result, (bool)0);
34622 }
34623 {
34624 if (temp3)
34625 delete arg3;
34626 }
34627 {
34628 if (temp4)
34629 delete arg4;
34630 }
34631 return resultobj;
34632 fail:
34633 {
34634 if (temp3)
34635 delete arg3;
34636 }
34637 {
34638 if (temp4)
34639 delete arg4;
34640 }
34641 return NULL;
34642 }
34643
34644
34645 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34646 PyObject *resultobj = NULL;
34647 wxMenu *arg1 = (wxMenu *) 0 ;
34648 int arg2 ;
34649 wxString *arg3 = 0 ;
34650 wxMenu *arg4 = (wxMenu *) 0 ;
34651 wxString const &arg5_defvalue = wxPyEmptyString ;
34652 wxString *arg5 = (wxString *) &arg5_defvalue ;
34653 wxMenuItem *result;
34654 bool temp3 = false ;
34655 bool temp5 = false ;
34656 PyObject * obj0 = 0 ;
34657 PyObject * obj1 = 0 ;
34658 PyObject * obj2 = 0 ;
34659 PyObject * obj3 = 0 ;
34660 PyObject * obj4 = 0 ;
34661 char *kwnames[] = {
34662 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34663 };
34664
34665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34667 if (SWIG_arg_fail(1)) SWIG_fail;
34668 {
34669 arg2 = static_cast<int >(SWIG_As_int(obj1));
34670 if (SWIG_arg_fail(2)) SWIG_fail;
34671 }
34672 {
34673 arg3 = wxString_in_helper(obj2);
34674 if (arg3 == NULL) SWIG_fail;
34675 temp3 = true;
34676 }
34677 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34678 if (SWIG_arg_fail(4)) SWIG_fail;
34679 if (obj4) {
34680 {
34681 arg5 = wxString_in_helper(obj4);
34682 if (arg5 == NULL) SWIG_fail;
34683 temp5 = true;
34684 }
34685 }
34686 {
34687 PyThreadState* __tstate = wxPyBeginAllowThreads();
34688 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34689
34690 wxPyEndAllowThreads(__tstate);
34691 if (PyErr_Occurred()) SWIG_fail;
34692 }
34693 {
34694 resultobj = wxPyMake_wxObject(result, (bool)0);
34695 }
34696 {
34697 if (temp3)
34698 delete arg3;
34699 }
34700 {
34701 if (temp5)
34702 delete arg5;
34703 }
34704 return resultobj;
34705 fail:
34706 {
34707 if (temp3)
34708 delete arg3;
34709 }
34710 {
34711 if (temp5)
34712 delete arg5;
34713 }
34714 return NULL;
34715 }
34716
34717
34718 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34719 PyObject *resultobj = NULL;
34720 wxMenu *arg1 = (wxMenu *) 0 ;
34721 int arg2 ;
34722 wxMenuItem *result;
34723 PyObject * obj0 = 0 ;
34724 PyObject * obj1 = 0 ;
34725 char *kwnames[] = {
34726 (char *) "self",(char *) "id", NULL
34727 };
34728
34729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34731 if (SWIG_arg_fail(1)) SWIG_fail;
34732 {
34733 arg2 = static_cast<int >(SWIG_As_int(obj1));
34734 if (SWIG_arg_fail(2)) SWIG_fail;
34735 }
34736 {
34737 PyThreadState* __tstate = wxPyBeginAllowThreads();
34738 result = (wxMenuItem *)(arg1)->Remove(arg2);
34739
34740 wxPyEndAllowThreads(__tstate);
34741 if (PyErr_Occurred()) SWIG_fail;
34742 }
34743 {
34744 resultobj = wxPyMake_wxObject(result, (bool)0);
34745 }
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34753 PyObject *resultobj = NULL;
34754 wxMenu *arg1 = (wxMenu *) 0 ;
34755 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34756 wxMenuItem *result;
34757 PyObject * obj0 = 0 ;
34758 PyObject * obj1 = 0 ;
34759 char *kwnames[] = {
34760 (char *) "self",(char *) "item", NULL
34761 };
34762
34763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34765 if (SWIG_arg_fail(1)) SWIG_fail;
34766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34767 if (SWIG_arg_fail(2)) SWIG_fail;
34768 {
34769 PyThreadState* __tstate = wxPyBeginAllowThreads();
34770 result = (wxMenuItem *)(arg1)->Remove(arg2);
34771
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = wxPyMake_wxObject(result, (bool)0);
34777 }
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34785 PyObject *resultobj = NULL;
34786 wxMenu *arg1 = (wxMenu *) 0 ;
34787 int arg2 ;
34788 bool result;
34789 PyObject * obj0 = 0 ;
34790 PyObject * obj1 = 0 ;
34791 char *kwnames[] = {
34792 (char *) "self",(char *) "id", NULL
34793 };
34794
34795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34797 if (SWIG_arg_fail(1)) SWIG_fail;
34798 {
34799 arg2 = static_cast<int >(SWIG_As_int(obj1));
34800 if (SWIG_arg_fail(2)) SWIG_fail;
34801 }
34802 {
34803 PyThreadState* __tstate = wxPyBeginAllowThreads();
34804 result = (bool)(arg1)->Delete(arg2);
34805
34806 wxPyEndAllowThreads(__tstate);
34807 if (PyErr_Occurred()) SWIG_fail;
34808 }
34809 {
34810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34811 }
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34819 PyObject *resultobj = NULL;
34820 wxMenu *arg1 = (wxMenu *) 0 ;
34821 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34822 bool result;
34823 PyObject * obj0 = 0 ;
34824 PyObject * obj1 = 0 ;
34825 char *kwnames[] = {
34826 (char *) "self",(char *) "item", NULL
34827 };
34828
34829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34831 if (SWIG_arg_fail(1)) SWIG_fail;
34832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34833 if (SWIG_arg_fail(2)) SWIG_fail;
34834 {
34835 PyThreadState* __tstate = wxPyBeginAllowThreads();
34836 result = (bool)(arg1)->Delete(arg2);
34837
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 {
34842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34843 }
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34851 PyObject *resultobj = NULL;
34852 wxMenu *arg1 = (wxMenu *) 0 ;
34853 PyObject * obj0 = 0 ;
34854 char *kwnames[] = {
34855 (char *) "self", NULL
34856 };
34857
34858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34860 if (SWIG_arg_fail(1)) SWIG_fail;
34861 {
34862 PyThreadState* __tstate = wxPyBeginAllowThreads();
34863 wxMenu_Destroy(arg1);
34864
34865 wxPyEndAllowThreads(__tstate);
34866 if (PyErr_Occurred()) SWIG_fail;
34867 }
34868 Py_INCREF(Py_None); resultobj = Py_None;
34869 return resultobj;
34870 fail:
34871 return NULL;
34872 }
34873
34874
34875 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34876 PyObject *resultobj = NULL;
34877 wxMenu *arg1 = (wxMenu *) 0 ;
34878 int arg2 ;
34879 bool result;
34880 PyObject * obj0 = 0 ;
34881 PyObject * obj1 = 0 ;
34882 char *kwnames[] = {
34883 (char *) "self",(char *) "id", NULL
34884 };
34885
34886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34888 if (SWIG_arg_fail(1)) SWIG_fail;
34889 {
34890 arg2 = static_cast<int >(SWIG_As_int(obj1));
34891 if (SWIG_arg_fail(2)) SWIG_fail;
34892 }
34893 {
34894 PyThreadState* __tstate = wxPyBeginAllowThreads();
34895 result = (bool)(arg1)->Destroy(arg2);
34896
34897 wxPyEndAllowThreads(__tstate);
34898 if (PyErr_Occurred()) SWIG_fail;
34899 }
34900 {
34901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34902 }
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34910 PyObject *resultobj = NULL;
34911 wxMenu *arg1 = (wxMenu *) 0 ;
34912 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34913 bool result;
34914 PyObject * obj0 = 0 ;
34915 PyObject * obj1 = 0 ;
34916 char *kwnames[] = {
34917 (char *) "self",(char *) "item", NULL
34918 };
34919
34920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34922 if (SWIG_arg_fail(1)) SWIG_fail;
34923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34924 if (SWIG_arg_fail(2)) SWIG_fail;
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 result = (bool)(arg1)->Destroy(arg2);
34928
34929 wxPyEndAllowThreads(__tstate);
34930 if (PyErr_Occurred()) SWIG_fail;
34931 }
34932 {
34933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34934 }
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34942 PyObject *resultobj = NULL;
34943 wxMenu *arg1 = (wxMenu *) 0 ;
34944 size_t result;
34945 PyObject * obj0 = 0 ;
34946 char *kwnames[] = {
34947 (char *) "self", NULL
34948 };
34949
34950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34952 if (SWIG_arg_fail(1)) SWIG_fail;
34953 {
34954 PyThreadState* __tstate = wxPyBeginAllowThreads();
34955 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34956
34957 wxPyEndAllowThreads(__tstate);
34958 if (PyErr_Occurred()) SWIG_fail;
34959 }
34960 {
34961 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34962 }
34963 return resultobj;
34964 fail:
34965 return NULL;
34966 }
34967
34968
34969 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34970 PyObject *resultobj = NULL;
34971 wxMenu *arg1 = (wxMenu *) 0 ;
34972 PyObject *result;
34973 PyObject * obj0 = 0 ;
34974 char *kwnames[] = {
34975 (char *) "self", NULL
34976 };
34977
34978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34980 if (SWIG_arg_fail(1)) SWIG_fail;
34981 {
34982 PyThreadState* __tstate = wxPyBeginAllowThreads();
34983 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34984
34985 wxPyEndAllowThreads(__tstate);
34986 if (PyErr_Occurred()) SWIG_fail;
34987 }
34988 resultobj = result;
34989 return resultobj;
34990 fail:
34991 return NULL;
34992 }
34993
34994
34995 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34996 PyObject *resultobj = NULL;
34997 wxMenu *arg1 = (wxMenu *) 0 ;
34998 wxString *arg2 = 0 ;
34999 int result;
35000 bool temp2 = false ;
35001 PyObject * obj0 = 0 ;
35002 PyObject * obj1 = 0 ;
35003 char *kwnames[] = {
35004 (char *) "self",(char *) "item", NULL
35005 };
35006
35007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
35008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35009 if (SWIG_arg_fail(1)) SWIG_fail;
35010 {
35011 arg2 = wxString_in_helper(obj1);
35012 if (arg2 == NULL) SWIG_fail;
35013 temp2 = true;
35014 }
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
35018
35019 wxPyEndAllowThreads(__tstate);
35020 if (PyErr_Occurred()) SWIG_fail;
35021 }
35022 {
35023 resultobj = SWIG_From_int(static_cast<int >(result));
35024 }
35025 {
35026 if (temp2)
35027 delete arg2;
35028 }
35029 return resultobj;
35030 fail:
35031 {
35032 if (temp2)
35033 delete arg2;
35034 }
35035 return NULL;
35036 }
35037
35038
35039 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35040 PyObject *resultobj = NULL;
35041 wxMenu *arg1 = (wxMenu *) 0 ;
35042 int arg2 ;
35043 wxMenuItem *result;
35044 PyObject * obj0 = 0 ;
35045 PyObject * obj1 = 0 ;
35046 char *kwnames[] = {
35047 (char *) "self",(char *) "id", NULL
35048 };
35049
35050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35052 if (SWIG_arg_fail(1)) SWIG_fail;
35053 {
35054 arg2 = static_cast<int >(SWIG_As_int(obj1));
35055 if (SWIG_arg_fail(2)) SWIG_fail;
35056 }
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
35060
35061 wxPyEndAllowThreads(__tstate);
35062 if (PyErr_Occurred()) SWIG_fail;
35063 }
35064 {
35065 resultobj = wxPyMake_wxObject(result, (bool)0);
35066 }
35067 return resultobj;
35068 fail:
35069 return NULL;
35070 }
35071
35072
35073 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
35074 PyObject *resultobj = NULL;
35075 wxMenu *arg1 = (wxMenu *) 0 ;
35076 size_t arg2 ;
35077 wxMenuItem *result;
35078 PyObject * obj0 = 0 ;
35079 PyObject * obj1 = 0 ;
35080 char *kwnames[] = {
35081 (char *) "self",(char *) "position", NULL
35082 };
35083
35084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
35085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35086 if (SWIG_arg_fail(1)) SWIG_fail;
35087 {
35088 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35089 if (SWIG_arg_fail(2)) SWIG_fail;
35090 }
35091 {
35092 PyThreadState* __tstate = wxPyBeginAllowThreads();
35093 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
35094
35095 wxPyEndAllowThreads(__tstate);
35096 if (PyErr_Occurred()) SWIG_fail;
35097 }
35098 {
35099 resultobj = wxPyMake_wxObject(result, (bool)0);
35100 }
35101 return resultobj;
35102 fail:
35103 return NULL;
35104 }
35105
35106
35107 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35108 PyObject *resultobj = NULL;
35109 wxMenu *arg1 = (wxMenu *) 0 ;
35110 int arg2 ;
35111 bool arg3 ;
35112 PyObject * obj0 = 0 ;
35113 PyObject * obj1 = 0 ;
35114 PyObject * obj2 = 0 ;
35115 char *kwnames[] = {
35116 (char *) "self",(char *) "id",(char *) "enable", NULL
35117 };
35118
35119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35121 if (SWIG_arg_fail(1)) SWIG_fail;
35122 {
35123 arg2 = static_cast<int >(SWIG_As_int(obj1));
35124 if (SWIG_arg_fail(2)) SWIG_fail;
35125 }
35126 {
35127 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35128 if (SWIG_arg_fail(3)) SWIG_fail;
35129 }
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 (arg1)->Enable(arg2,arg3);
35133
35134 wxPyEndAllowThreads(__tstate);
35135 if (PyErr_Occurred()) SWIG_fail;
35136 }
35137 Py_INCREF(Py_None); resultobj = Py_None;
35138 return resultobj;
35139 fail:
35140 return NULL;
35141 }
35142
35143
35144 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35145 PyObject *resultobj = NULL;
35146 wxMenu *arg1 = (wxMenu *) 0 ;
35147 int arg2 ;
35148 bool result;
35149 PyObject * obj0 = 0 ;
35150 PyObject * obj1 = 0 ;
35151 char *kwnames[] = {
35152 (char *) "self",(char *) "id", NULL
35153 };
35154
35155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35157 if (SWIG_arg_fail(1)) SWIG_fail;
35158 {
35159 arg2 = static_cast<int >(SWIG_As_int(obj1));
35160 if (SWIG_arg_fail(2)) SWIG_fail;
35161 }
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35165
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 {
35170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35171 }
35172 return resultobj;
35173 fail:
35174 return NULL;
35175 }
35176
35177
35178 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35179 PyObject *resultobj = NULL;
35180 wxMenu *arg1 = (wxMenu *) 0 ;
35181 int arg2 ;
35182 bool arg3 ;
35183 PyObject * obj0 = 0 ;
35184 PyObject * obj1 = 0 ;
35185 PyObject * obj2 = 0 ;
35186 char *kwnames[] = {
35187 (char *) "self",(char *) "id",(char *) "check", NULL
35188 };
35189
35190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35192 if (SWIG_arg_fail(1)) SWIG_fail;
35193 {
35194 arg2 = static_cast<int >(SWIG_As_int(obj1));
35195 if (SWIG_arg_fail(2)) SWIG_fail;
35196 }
35197 {
35198 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35199 if (SWIG_arg_fail(3)) SWIG_fail;
35200 }
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 (arg1)->Check(arg2,arg3);
35204
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 Py_INCREF(Py_None); resultobj = Py_None;
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35216 PyObject *resultobj = NULL;
35217 wxMenu *arg1 = (wxMenu *) 0 ;
35218 int arg2 ;
35219 bool result;
35220 PyObject * obj0 = 0 ;
35221 PyObject * obj1 = 0 ;
35222 char *kwnames[] = {
35223 (char *) "self",(char *) "id", NULL
35224 };
35225
35226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35228 if (SWIG_arg_fail(1)) SWIG_fail;
35229 {
35230 arg2 = static_cast<int >(SWIG_As_int(obj1));
35231 if (SWIG_arg_fail(2)) SWIG_fail;
35232 }
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35236
35237 wxPyEndAllowThreads(__tstate);
35238 if (PyErr_Occurred()) SWIG_fail;
35239 }
35240 {
35241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35242 }
35243 return resultobj;
35244 fail:
35245 return NULL;
35246 }
35247
35248
35249 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35250 PyObject *resultobj = NULL;
35251 wxMenu *arg1 = (wxMenu *) 0 ;
35252 int arg2 ;
35253 wxString *arg3 = 0 ;
35254 bool temp3 = false ;
35255 PyObject * obj0 = 0 ;
35256 PyObject * obj1 = 0 ;
35257 PyObject * obj2 = 0 ;
35258 char *kwnames[] = {
35259 (char *) "self",(char *) "id",(char *) "label", NULL
35260 };
35261
35262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35264 if (SWIG_arg_fail(1)) SWIG_fail;
35265 {
35266 arg2 = static_cast<int >(SWIG_As_int(obj1));
35267 if (SWIG_arg_fail(2)) SWIG_fail;
35268 }
35269 {
35270 arg3 = wxString_in_helper(obj2);
35271 if (arg3 == NULL) SWIG_fail;
35272 temp3 = true;
35273 }
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35277
35278 wxPyEndAllowThreads(__tstate);
35279 if (PyErr_Occurred()) SWIG_fail;
35280 }
35281 Py_INCREF(Py_None); resultobj = Py_None;
35282 {
35283 if (temp3)
35284 delete arg3;
35285 }
35286 return resultobj;
35287 fail:
35288 {
35289 if (temp3)
35290 delete arg3;
35291 }
35292 return NULL;
35293 }
35294
35295
35296 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj = NULL;
35298 wxMenu *arg1 = (wxMenu *) 0 ;
35299 int arg2 ;
35300 wxString result;
35301 PyObject * obj0 = 0 ;
35302 PyObject * obj1 = 0 ;
35303 char *kwnames[] = {
35304 (char *) "self",(char *) "id", NULL
35305 };
35306
35307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35309 if (SWIG_arg_fail(1)) SWIG_fail;
35310 {
35311 arg2 = static_cast<int >(SWIG_As_int(obj1));
35312 if (SWIG_arg_fail(2)) SWIG_fail;
35313 }
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35317
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 {
35322 #if wxUSE_UNICODE
35323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35324 #else
35325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35326 #endif
35327 }
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj = NULL;
35336 wxMenu *arg1 = (wxMenu *) 0 ;
35337 int arg2 ;
35338 wxString *arg3 = 0 ;
35339 bool temp3 = false ;
35340 PyObject * obj0 = 0 ;
35341 PyObject * obj1 = 0 ;
35342 PyObject * obj2 = 0 ;
35343 char *kwnames[] = {
35344 (char *) "self",(char *) "id",(char *) "helpString", NULL
35345 };
35346
35347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35349 if (SWIG_arg_fail(1)) SWIG_fail;
35350 {
35351 arg2 = static_cast<int >(SWIG_As_int(obj1));
35352 if (SWIG_arg_fail(2)) SWIG_fail;
35353 }
35354 {
35355 arg3 = wxString_in_helper(obj2);
35356 if (arg3 == NULL) SWIG_fail;
35357 temp3 = true;
35358 }
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35362
35363 wxPyEndAllowThreads(__tstate);
35364 if (PyErr_Occurred()) SWIG_fail;
35365 }
35366 Py_INCREF(Py_None); resultobj = Py_None;
35367 {
35368 if (temp3)
35369 delete arg3;
35370 }
35371 return resultobj;
35372 fail:
35373 {
35374 if (temp3)
35375 delete arg3;
35376 }
35377 return NULL;
35378 }
35379
35380
35381 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35382 PyObject *resultobj = NULL;
35383 wxMenu *arg1 = (wxMenu *) 0 ;
35384 int arg2 ;
35385 wxString result;
35386 PyObject * obj0 = 0 ;
35387 PyObject * obj1 = 0 ;
35388 char *kwnames[] = {
35389 (char *) "self",(char *) "id", NULL
35390 };
35391
35392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35394 if (SWIG_arg_fail(1)) SWIG_fail;
35395 {
35396 arg2 = static_cast<int >(SWIG_As_int(obj1));
35397 if (SWIG_arg_fail(2)) SWIG_fail;
35398 }
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35402
35403 wxPyEndAllowThreads(__tstate);
35404 if (PyErr_Occurred()) SWIG_fail;
35405 }
35406 {
35407 #if wxUSE_UNICODE
35408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35409 #else
35410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35411 #endif
35412 }
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35420 PyObject *resultobj = NULL;
35421 wxMenu *arg1 = (wxMenu *) 0 ;
35422 wxString *arg2 = 0 ;
35423 bool temp2 = false ;
35424 PyObject * obj0 = 0 ;
35425 PyObject * obj1 = 0 ;
35426 char *kwnames[] = {
35427 (char *) "self",(char *) "title", NULL
35428 };
35429
35430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35432 if (SWIG_arg_fail(1)) SWIG_fail;
35433 {
35434 arg2 = wxString_in_helper(obj1);
35435 if (arg2 == NULL) SWIG_fail;
35436 temp2 = true;
35437 }
35438 {
35439 PyThreadState* __tstate = wxPyBeginAllowThreads();
35440 (arg1)->SetTitle((wxString const &)*arg2);
35441
35442 wxPyEndAllowThreads(__tstate);
35443 if (PyErr_Occurred()) SWIG_fail;
35444 }
35445 Py_INCREF(Py_None); resultobj = Py_None;
35446 {
35447 if (temp2)
35448 delete arg2;
35449 }
35450 return resultobj;
35451 fail:
35452 {
35453 if (temp2)
35454 delete arg2;
35455 }
35456 return NULL;
35457 }
35458
35459
35460 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35461 PyObject *resultobj = NULL;
35462 wxMenu *arg1 = (wxMenu *) 0 ;
35463 wxString result;
35464 PyObject * obj0 = 0 ;
35465 char *kwnames[] = {
35466 (char *) "self", NULL
35467 };
35468
35469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35471 if (SWIG_arg_fail(1)) SWIG_fail;
35472 {
35473 PyThreadState* __tstate = wxPyBeginAllowThreads();
35474 result = ((wxMenu const *)arg1)->GetTitle();
35475
35476 wxPyEndAllowThreads(__tstate);
35477 if (PyErr_Occurred()) SWIG_fail;
35478 }
35479 {
35480 #if wxUSE_UNICODE
35481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35482 #else
35483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35484 #endif
35485 }
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35493 PyObject *resultobj = NULL;
35494 wxMenu *arg1 = (wxMenu *) 0 ;
35495 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35496 PyObject * obj0 = 0 ;
35497 PyObject * obj1 = 0 ;
35498 char *kwnames[] = {
35499 (char *) "self",(char *) "handler", NULL
35500 };
35501
35502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35504 if (SWIG_arg_fail(1)) SWIG_fail;
35505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35506 if (SWIG_arg_fail(2)) SWIG_fail;
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 (arg1)->SetEventHandler(arg2);
35510
35511 wxPyEndAllowThreads(__tstate);
35512 if (PyErr_Occurred()) SWIG_fail;
35513 }
35514 Py_INCREF(Py_None); resultobj = Py_None;
35515 return resultobj;
35516 fail:
35517 return NULL;
35518 }
35519
35520
35521 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35522 PyObject *resultobj = NULL;
35523 wxMenu *arg1 = (wxMenu *) 0 ;
35524 wxEvtHandler *result;
35525 PyObject * obj0 = 0 ;
35526 char *kwnames[] = {
35527 (char *) "self", NULL
35528 };
35529
35530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35532 if (SWIG_arg_fail(1)) SWIG_fail;
35533 {
35534 PyThreadState* __tstate = wxPyBeginAllowThreads();
35535 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35536
35537 wxPyEndAllowThreads(__tstate);
35538 if (PyErr_Occurred()) SWIG_fail;
35539 }
35540 {
35541 resultobj = wxPyMake_wxObject(result, 0);
35542 }
35543 return resultobj;
35544 fail:
35545 return NULL;
35546 }
35547
35548
35549 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35550 PyObject *resultobj = NULL;
35551 wxMenu *arg1 = (wxMenu *) 0 ;
35552 wxWindow *arg2 = (wxWindow *) 0 ;
35553 PyObject * obj0 = 0 ;
35554 PyObject * obj1 = 0 ;
35555 char *kwnames[] = {
35556 (char *) "self",(char *) "win", NULL
35557 };
35558
35559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35561 if (SWIG_arg_fail(1)) SWIG_fail;
35562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35563 if (SWIG_arg_fail(2)) SWIG_fail;
35564 {
35565 PyThreadState* __tstate = wxPyBeginAllowThreads();
35566 (arg1)->SetInvokingWindow(arg2);
35567
35568 wxPyEndAllowThreads(__tstate);
35569 if (PyErr_Occurred()) SWIG_fail;
35570 }
35571 Py_INCREF(Py_None); resultobj = Py_None;
35572 return resultobj;
35573 fail:
35574 return NULL;
35575 }
35576
35577
35578 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35579 PyObject *resultobj = NULL;
35580 wxMenu *arg1 = (wxMenu *) 0 ;
35581 wxWindow *result;
35582 PyObject * obj0 = 0 ;
35583 char *kwnames[] = {
35584 (char *) "self", NULL
35585 };
35586
35587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35589 if (SWIG_arg_fail(1)) SWIG_fail;
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35593
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 {
35598 resultobj = wxPyMake_wxObject(result, 0);
35599 }
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35607 PyObject *resultobj = NULL;
35608 wxMenu *arg1 = (wxMenu *) 0 ;
35609 long result;
35610 PyObject * obj0 = 0 ;
35611 char *kwnames[] = {
35612 (char *) "self", NULL
35613 };
35614
35615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35617 if (SWIG_arg_fail(1)) SWIG_fail;
35618 {
35619 PyThreadState* __tstate = wxPyBeginAllowThreads();
35620 result = (long)((wxMenu const *)arg1)->GetStyle();
35621
35622 wxPyEndAllowThreads(__tstate);
35623 if (PyErr_Occurred()) SWIG_fail;
35624 }
35625 {
35626 resultobj = SWIG_From_long(static_cast<long >(result));
35627 }
35628 return resultobj;
35629 fail:
35630 return NULL;
35631 }
35632
35633
35634 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35635 PyObject *resultobj = NULL;
35636 wxMenu *arg1 = (wxMenu *) 0 ;
35637 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35638 PyObject * obj0 = 0 ;
35639 PyObject * obj1 = 0 ;
35640 char *kwnames[] = {
35641 (char *) "self",(char *) "source", NULL
35642 };
35643
35644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35646 if (SWIG_arg_fail(1)) SWIG_fail;
35647 if (obj1) {
35648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35649 if (SWIG_arg_fail(2)) SWIG_fail;
35650 }
35651 {
35652 PyThreadState* __tstate = wxPyBeginAllowThreads();
35653 (arg1)->UpdateUI(arg2);
35654
35655 wxPyEndAllowThreads(__tstate);
35656 if (PyErr_Occurred()) SWIG_fail;
35657 }
35658 Py_INCREF(Py_None); resultobj = Py_None;
35659 return resultobj;
35660 fail:
35661 return NULL;
35662 }
35663
35664
35665 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35666 PyObject *resultobj = NULL;
35667 wxMenu *arg1 = (wxMenu *) 0 ;
35668 wxMenuBar *result;
35669 PyObject * obj0 = 0 ;
35670 char *kwnames[] = {
35671 (char *) "self", NULL
35672 };
35673
35674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35676 if (SWIG_arg_fail(1)) SWIG_fail;
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35680
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 {
35685 resultobj = wxPyMake_wxObject(result, (bool)0);
35686 }
35687 return resultobj;
35688 fail:
35689 return NULL;
35690 }
35691
35692
35693 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35694 PyObject *resultobj = NULL;
35695 wxMenu *arg1 = (wxMenu *) 0 ;
35696 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35697 PyObject * obj0 = 0 ;
35698 PyObject * obj1 = 0 ;
35699 char *kwnames[] = {
35700 (char *) "self",(char *) "menubar", NULL
35701 };
35702
35703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35705 if (SWIG_arg_fail(1)) SWIG_fail;
35706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35707 if (SWIG_arg_fail(2)) SWIG_fail;
35708 {
35709 PyThreadState* __tstate = wxPyBeginAllowThreads();
35710 (arg1)->Attach(arg2);
35711
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 Py_INCREF(Py_None); resultobj = Py_None;
35716 return resultobj;
35717 fail:
35718 return NULL;
35719 }
35720
35721
35722 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35723 PyObject *resultobj = NULL;
35724 wxMenu *arg1 = (wxMenu *) 0 ;
35725 PyObject * obj0 = 0 ;
35726 char *kwnames[] = {
35727 (char *) "self", NULL
35728 };
35729
35730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35732 if (SWIG_arg_fail(1)) SWIG_fail;
35733 {
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 (arg1)->Detach();
35736
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 Py_INCREF(Py_None); resultobj = Py_None;
35741 return resultobj;
35742 fail:
35743 return NULL;
35744 }
35745
35746
35747 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35748 PyObject *resultobj = NULL;
35749 wxMenu *arg1 = (wxMenu *) 0 ;
35750 bool result;
35751 PyObject * obj0 = 0 ;
35752 char *kwnames[] = {
35753 (char *) "self", NULL
35754 };
35755
35756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35758 if (SWIG_arg_fail(1)) SWIG_fail;
35759 {
35760 PyThreadState* __tstate = wxPyBeginAllowThreads();
35761 result = (bool)((wxMenu const *)arg1)->IsAttached();
35762
35763 wxPyEndAllowThreads(__tstate);
35764 if (PyErr_Occurred()) SWIG_fail;
35765 }
35766 {
35767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35768 }
35769 return resultobj;
35770 fail:
35771 return NULL;
35772 }
35773
35774
35775 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35776 PyObject *resultobj = NULL;
35777 wxMenu *arg1 = (wxMenu *) 0 ;
35778 wxMenu *arg2 = (wxMenu *) 0 ;
35779 PyObject * obj0 = 0 ;
35780 PyObject * obj1 = 0 ;
35781 char *kwnames[] = {
35782 (char *) "self",(char *) "parent", NULL
35783 };
35784
35785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35787 if (SWIG_arg_fail(1)) SWIG_fail;
35788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35789 if (SWIG_arg_fail(2)) SWIG_fail;
35790 {
35791 PyThreadState* __tstate = wxPyBeginAllowThreads();
35792 (arg1)->SetParent(arg2);
35793
35794 wxPyEndAllowThreads(__tstate);
35795 if (PyErr_Occurred()) SWIG_fail;
35796 }
35797 Py_INCREF(Py_None); resultobj = Py_None;
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35805 PyObject *resultobj = NULL;
35806 wxMenu *arg1 = (wxMenu *) 0 ;
35807 wxMenu *result;
35808 PyObject * obj0 = 0 ;
35809 char *kwnames[] = {
35810 (char *) "self", NULL
35811 };
35812
35813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35815 if (SWIG_arg_fail(1)) SWIG_fail;
35816 {
35817 PyThreadState* __tstate = wxPyBeginAllowThreads();
35818 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35819
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 {
35824 resultobj = wxPyMake_wxObject(result, 0);
35825 }
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35833 PyObject *obj;
35834 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35835 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35836 Py_INCREF(obj);
35837 return Py_BuildValue((char *)"");
35838 }
35839 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35840 PyObject *resultobj = NULL;
35841 long arg1 = (long) 0 ;
35842 wxMenuBar *result;
35843 PyObject * obj0 = 0 ;
35844 char *kwnames[] = {
35845 (char *) "style", NULL
35846 };
35847
35848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35849 if (obj0) {
35850 {
35851 arg1 = static_cast<long >(SWIG_As_long(obj0));
35852 if (SWIG_arg_fail(1)) SWIG_fail;
35853 }
35854 }
35855 {
35856 if (!wxPyCheckForApp()) SWIG_fail;
35857 PyThreadState* __tstate = wxPyBeginAllowThreads();
35858 result = (wxMenuBar *)new wxMenuBar(arg1);
35859
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35864 return resultobj;
35865 fail:
35866 return NULL;
35867 }
35868
35869
35870 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35871 PyObject *resultobj = NULL;
35872 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35873 wxMenu *arg2 = (wxMenu *) 0 ;
35874 wxString *arg3 = 0 ;
35875 bool result;
35876 bool temp3 = false ;
35877 PyObject * obj0 = 0 ;
35878 PyObject * obj1 = 0 ;
35879 PyObject * obj2 = 0 ;
35880 char *kwnames[] = {
35881 (char *) "self",(char *) "menu",(char *) "title", NULL
35882 };
35883
35884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35886 if (SWIG_arg_fail(1)) SWIG_fail;
35887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35888 if (SWIG_arg_fail(2)) SWIG_fail;
35889 {
35890 arg3 = wxString_in_helper(obj2);
35891 if (arg3 == NULL) SWIG_fail;
35892 temp3 = true;
35893 }
35894 {
35895 PyThreadState* __tstate = wxPyBeginAllowThreads();
35896 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35897
35898 wxPyEndAllowThreads(__tstate);
35899 if (PyErr_Occurred()) SWIG_fail;
35900 }
35901 {
35902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35903 }
35904 {
35905 if (temp3)
35906 delete arg3;
35907 }
35908 return resultobj;
35909 fail:
35910 {
35911 if (temp3)
35912 delete arg3;
35913 }
35914 return NULL;
35915 }
35916
35917
35918 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35919 PyObject *resultobj = NULL;
35920 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35921 size_t arg2 ;
35922 wxMenu *arg3 = (wxMenu *) 0 ;
35923 wxString *arg4 = 0 ;
35924 bool result;
35925 bool temp4 = false ;
35926 PyObject * obj0 = 0 ;
35927 PyObject * obj1 = 0 ;
35928 PyObject * obj2 = 0 ;
35929 PyObject * obj3 = 0 ;
35930 char *kwnames[] = {
35931 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35932 };
35933
35934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35936 if (SWIG_arg_fail(1)) SWIG_fail;
35937 {
35938 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35939 if (SWIG_arg_fail(2)) SWIG_fail;
35940 }
35941 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35942 if (SWIG_arg_fail(3)) SWIG_fail;
35943 {
35944 arg4 = wxString_in_helper(obj3);
35945 if (arg4 == NULL) SWIG_fail;
35946 temp4 = true;
35947 }
35948 {
35949 PyThreadState* __tstate = wxPyBeginAllowThreads();
35950 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35951
35952 wxPyEndAllowThreads(__tstate);
35953 if (PyErr_Occurred()) SWIG_fail;
35954 }
35955 {
35956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35957 }
35958 {
35959 if (temp4)
35960 delete arg4;
35961 }
35962 return resultobj;
35963 fail:
35964 {
35965 if (temp4)
35966 delete arg4;
35967 }
35968 return NULL;
35969 }
35970
35971
35972 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35973 PyObject *resultobj = NULL;
35974 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35975 size_t result;
35976 PyObject * obj0 = 0 ;
35977 char *kwnames[] = {
35978 (char *) "self", NULL
35979 };
35980
35981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35983 if (SWIG_arg_fail(1)) SWIG_fail;
35984 {
35985 PyThreadState* __tstate = wxPyBeginAllowThreads();
35986 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35987
35988 wxPyEndAllowThreads(__tstate);
35989 if (PyErr_Occurred()) SWIG_fail;
35990 }
35991 {
35992 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35993 }
35994 return resultobj;
35995 fail:
35996 return NULL;
35997 }
35998
35999
36000 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36001 PyObject *resultobj = NULL;
36002 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36003 size_t arg2 ;
36004 wxMenu *result;
36005 PyObject * obj0 = 0 ;
36006 PyObject * obj1 = 0 ;
36007 char *kwnames[] = {
36008 (char *) "self",(char *) "pos", NULL
36009 };
36010
36011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
36012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36013 if (SWIG_arg_fail(1)) SWIG_fail;
36014 {
36015 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36016 if (SWIG_arg_fail(2)) SWIG_fail;
36017 }
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
36021
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 {
36026 resultobj = wxPyMake_wxObject(result, 0);
36027 }
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj = NULL;
36036 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36037 size_t arg2 ;
36038 wxMenu *arg3 = (wxMenu *) 0 ;
36039 wxString *arg4 = 0 ;
36040 wxMenu *result;
36041 bool temp4 = false ;
36042 PyObject * obj0 = 0 ;
36043 PyObject * obj1 = 0 ;
36044 PyObject * obj2 = 0 ;
36045 PyObject * obj3 = 0 ;
36046 char *kwnames[] = {
36047 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
36048 };
36049
36050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36052 if (SWIG_arg_fail(1)) SWIG_fail;
36053 {
36054 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36055 if (SWIG_arg_fail(2)) SWIG_fail;
36056 }
36057 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36058 if (SWIG_arg_fail(3)) SWIG_fail;
36059 {
36060 arg4 = wxString_in_helper(obj3);
36061 if (arg4 == NULL) SWIG_fail;
36062 temp4 = true;
36063 }
36064 {
36065 PyThreadState* __tstate = wxPyBeginAllowThreads();
36066 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
36067
36068 wxPyEndAllowThreads(__tstate);
36069 if (PyErr_Occurred()) SWIG_fail;
36070 }
36071 {
36072 resultobj = wxPyMake_wxObject(result, 0);
36073 }
36074 {
36075 if (temp4)
36076 delete arg4;
36077 }
36078 return resultobj;
36079 fail:
36080 {
36081 if (temp4)
36082 delete arg4;
36083 }
36084 return NULL;
36085 }
36086
36087
36088 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
36089 PyObject *resultobj = NULL;
36090 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36091 size_t arg2 ;
36092 wxMenu *result;
36093 PyObject * obj0 = 0 ;
36094 PyObject * obj1 = 0 ;
36095 char *kwnames[] = {
36096 (char *) "self",(char *) "pos", NULL
36097 };
36098
36099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
36100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36101 if (SWIG_arg_fail(1)) SWIG_fail;
36102 {
36103 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36104 if (SWIG_arg_fail(2)) SWIG_fail;
36105 }
36106 {
36107 PyThreadState* __tstate = wxPyBeginAllowThreads();
36108 result = (wxMenu *)(arg1)->Remove(arg2);
36109
36110 wxPyEndAllowThreads(__tstate);
36111 if (PyErr_Occurred()) SWIG_fail;
36112 }
36113 {
36114 resultobj = wxPyMake_wxObject(result, 0);
36115 }
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
36123 PyObject *resultobj = NULL;
36124 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36125 size_t arg2 ;
36126 bool arg3 ;
36127 PyObject * obj0 = 0 ;
36128 PyObject * obj1 = 0 ;
36129 PyObject * obj2 = 0 ;
36130 char *kwnames[] = {
36131 (char *) "self",(char *) "pos",(char *) "enable", NULL
36132 };
36133
36134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36136 if (SWIG_arg_fail(1)) SWIG_fail;
36137 {
36138 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36139 if (SWIG_arg_fail(2)) SWIG_fail;
36140 }
36141 {
36142 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36143 if (SWIG_arg_fail(3)) SWIG_fail;
36144 }
36145 {
36146 PyThreadState* __tstate = wxPyBeginAllowThreads();
36147 (arg1)->EnableTop(arg2,arg3);
36148
36149 wxPyEndAllowThreads(__tstate);
36150 if (PyErr_Occurred()) SWIG_fail;
36151 }
36152 Py_INCREF(Py_None); resultobj = Py_None;
36153 return resultobj;
36154 fail:
36155 return NULL;
36156 }
36157
36158
36159 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36160 PyObject *resultobj = NULL;
36161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36162 size_t arg2 ;
36163 bool result;
36164 PyObject * obj0 = 0 ;
36165 PyObject * obj1 = 0 ;
36166 char *kwnames[] = {
36167 (char *) "self",(char *) "pos", NULL
36168 };
36169
36170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36172 if (SWIG_arg_fail(1)) SWIG_fail;
36173 {
36174 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36175 if (SWIG_arg_fail(2)) SWIG_fail;
36176 }
36177 {
36178 PyThreadState* __tstate = wxPyBeginAllowThreads();
36179 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36180
36181 wxPyEndAllowThreads(__tstate);
36182 if (PyErr_Occurred()) SWIG_fail;
36183 }
36184 {
36185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36186 }
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36194 PyObject *resultobj = NULL;
36195 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36196 size_t arg2 ;
36197 wxString *arg3 = 0 ;
36198 bool temp3 = false ;
36199 PyObject * obj0 = 0 ;
36200 PyObject * obj1 = 0 ;
36201 PyObject * obj2 = 0 ;
36202 char *kwnames[] = {
36203 (char *) "self",(char *) "pos",(char *) "label", NULL
36204 };
36205
36206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36208 if (SWIG_arg_fail(1)) SWIG_fail;
36209 {
36210 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36211 if (SWIG_arg_fail(2)) SWIG_fail;
36212 }
36213 {
36214 arg3 = wxString_in_helper(obj2);
36215 if (arg3 == NULL) SWIG_fail;
36216 temp3 = true;
36217 }
36218 {
36219 PyThreadState* __tstate = wxPyBeginAllowThreads();
36220 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36221
36222 wxPyEndAllowThreads(__tstate);
36223 if (PyErr_Occurred()) SWIG_fail;
36224 }
36225 Py_INCREF(Py_None); resultobj = Py_None;
36226 {
36227 if (temp3)
36228 delete arg3;
36229 }
36230 return resultobj;
36231 fail:
36232 {
36233 if (temp3)
36234 delete arg3;
36235 }
36236 return NULL;
36237 }
36238
36239
36240 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36241 PyObject *resultobj = NULL;
36242 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36243 size_t arg2 ;
36244 wxString result;
36245 PyObject * obj0 = 0 ;
36246 PyObject * obj1 = 0 ;
36247 char *kwnames[] = {
36248 (char *) "self",(char *) "pos", NULL
36249 };
36250
36251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36253 if (SWIG_arg_fail(1)) SWIG_fail;
36254 {
36255 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36256 if (SWIG_arg_fail(2)) SWIG_fail;
36257 }
36258 {
36259 PyThreadState* __tstate = wxPyBeginAllowThreads();
36260 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36261
36262 wxPyEndAllowThreads(__tstate);
36263 if (PyErr_Occurred()) SWIG_fail;
36264 }
36265 {
36266 #if wxUSE_UNICODE
36267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36268 #else
36269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36270 #endif
36271 }
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36279 PyObject *resultobj = NULL;
36280 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36281 wxString *arg2 = 0 ;
36282 wxString *arg3 = 0 ;
36283 int result;
36284 bool temp2 = false ;
36285 bool temp3 = false ;
36286 PyObject * obj0 = 0 ;
36287 PyObject * obj1 = 0 ;
36288 PyObject * obj2 = 0 ;
36289 char *kwnames[] = {
36290 (char *) "self",(char *) "menu",(char *) "item", NULL
36291 };
36292
36293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36295 if (SWIG_arg_fail(1)) SWIG_fail;
36296 {
36297 arg2 = wxString_in_helper(obj1);
36298 if (arg2 == NULL) SWIG_fail;
36299 temp2 = true;
36300 }
36301 {
36302 arg3 = wxString_in_helper(obj2);
36303 if (arg3 == NULL) SWIG_fail;
36304 temp3 = true;
36305 }
36306 {
36307 PyThreadState* __tstate = wxPyBeginAllowThreads();
36308 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36309
36310 wxPyEndAllowThreads(__tstate);
36311 if (PyErr_Occurred()) SWIG_fail;
36312 }
36313 {
36314 resultobj = SWIG_From_int(static_cast<int >(result));
36315 }
36316 {
36317 if (temp2)
36318 delete arg2;
36319 }
36320 {
36321 if (temp3)
36322 delete arg3;
36323 }
36324 return resultobj;
36325 fail:
36326 {
36327 if (temp2)
36328 delete arg2;
36329 }
36330 {
36331 if (temp3)
36332 delete arg3;
36333 }
36334 return NULL;
36335 }
36336
36337
36338 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36339 PyObject *resultobj = NULL;
36340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36341 int arg2 ;
36342 wxMenuItem *result;
36343 PyObject * obj0 = 0 ;
36344 PyObject * obj1 = 0 ;
36345 char *kwnames[] = {
36346 (char *) "self",(char *) "id", NULL
36347 };
36348
36349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36351 if (SWIG_arg_fail(1)) SWIG_fail;
36352 {
36353 arg2 = static_cast<int >(SWIG_As_int(obj1));
36354 if (SWIG_arg_fail(2)) SWIG_fail;
36355 }
36356 {
36357 PyThreadState* __tstate = wxPyBeginAllowThreads();
36358 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36359
36360 wxPyEndAllowThreads(__tstate);
36361 if (PyErr_Occurred()) SWIG_fail;
36362 }
36363 {
36364 resultobj = wxPyMake_wxObject(result, (bool)0);
36365 }
36366 return resultobj;
36367 fail:
36368 return NULL;
36369 }
36370
36371
36372 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36373 PyObject *resultobj = NULL;
36374 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36375 wxString *arg2 = 0 ;
36376 int result;
36377 bool temp2 = false ;
36378 PyObject * obj0 = 0 ;
36379 PyObject * obj1 = 0 ;
36380 char *kwnames[] = {
36381 (char *) "self",(char *) "title", NULL
36382 };
36383
36384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36386 if (SWIG_arg_fail(1)) SWIG_fail;
36387 {
36388 arg2 = wxString_in_helper(obj1);
36389 if (arg2 == NULL) SWIG_fail;
36390 temp2 = true;
36391 }
36392 {
36393 PyThreadState* __tstate = wxPyBeginAllowThreads();
36394 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36395
36396 wxPyEndAllowThreads(__tstate);
36397 if (PyErr_Occurred()) SWIG_fail;
36398 }
36399 {
36400 resultobj = SWIG_From_int(static_cast<int >(result));
36401 }
36402 {
36403 if (temp2)
36404 delete arg2;
36405 }
36406 return resultobj;
36407 fail:
36408 {
36409 if (temp2)
36410 delete arg2;
36411 }
36412 return NULL;
36413 }
36414
36415
36416 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36417 PyObject *resultobj = NULL;
36418 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36419 int arg2 ;
36420 bool arg3 ;
36421 PyObject * obj0 = 0 ;
36422 PyObject * obj1 = 0 ;
36423 PyObject * obj2 = 0 ;
36424 char *kwnames[] = {
36425 (char *) "self",(char *) "id",(char *) "enable", NULL
36426 };
36427
36428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36430 if (SWIG_arg_fail(1)) SWIG_fail;
36431 {
36432 arg2 = static_cast<int >(SWIG_As_int(obj1));
36433 if (SWIG_arg_fail(2)) SWIG_fail;
36434 }
36435 {
36436 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36437 if (SWIG_arg_fail(3)) SWIG_fail;
36438 }
36439 {
36440 PyThreadState* __tstate = wxPyBeginAllowThreads();
36441 (arg1)->Enable(arg2,arg3);
36442
36443 wxPyEndAllowThreads(__tstate);
36444 if (PyErr_Occurred()) SWIG_fail;
36445 }
36446 Py_INCREF(Py_None); resultobj = Py_None;
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj = NULL;
36455 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36456 int arg2 ;
36457 bool arg3 ;
36458 PyObject * obj0 = 0 ;
36459 PyObject * obj1 = 0 ;
36460 PyObject * obj2 = 0 ;
36461 char *kwnames[] = {
36462 (char *) "self",(char *) "id",(char *) "check", NULL
36463 };
36464
36465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36467 if (SWIG_arg_fail(1)) SWIG_fail;
36468 {
36469 arg2 = static_cast<int >(SWIG_As_int(obj1));
36470 if (SWIG_arg_fail(2)) SWIG_fail;
36471 }
36472 {
36473 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36474 if (SWIG_arg_fail(3)) SWIG_fail;
36475 }
36476 {
36477 PyThreadState* __tstate = wxPyBeginAllowThreads();
36478 (arg1)->Check(arg2,arg3);
36479
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 Py_INCREF(Py_None); resultobj = Py_None;
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36491 PyObject *resultobj = NULL;
36492 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36493 int arg2 ;
36494 bool result;
36495 PyObject * obj0 = 0 ;
36496 PyObject * obj1 = 0 ;
36497 char *kwnames[] = {
36498 (char *) "self",(char *) "id", NULL
36499 };
36500
36501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36503 if (SWIG_arg_fail(1)) SWIG_fail;
36504 {
36505 arg2 = static_cast<int >(SWIG_As_int(obj1));
36506 if (SWIG_arg_fail(2)) SWIG_fail;
36507 }
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36511
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 {
36516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36517 }
36518 return resultobj;
36519 fail:
36520 return NULL;
36521 }
36522
36523
36524 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36525 PyObject *resultobj = NULL;
36526 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36527 int arg2 ;
36528 bool result;
36529 PyObject * obj0 = 0 ;
36530 PyObject * obj1 = 0 ;
36531 char *kwnames[] = {
36532 (char *) "self",(char *) "id", NULL
36533 };
36534
36535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36537 if (SWIG_arg_fail(1)) SWIG_fail;
36538 {
36539 arg2 = static_cast<int >(SWIG_As_int(obj1));
36540 if (SWIG_arg_fail(2)) SWIG_fail;
36541 }
36542 {
36543 PyThreadState* __tstate = wxPyBeginAllowThreads();
36544 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36545
36546 wxPyEndAllowThreads(__tstate);
36547 if (PyErr_Occurred()) SWIG_fail;
36548 }
36549 {
36550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36551 }
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36559 PyObject *resultobj = NULL;
36560 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36561 int arg2 ;
36562 wxString *arg3 = 0 ;
36563 bool temp3 = false ;
36564 PyObject * obj0 = 0 ;
36565 PyObject * obj1 = 0 ;
36566 PyObject * obj2 = 0 ;
36567 char *kwnames[] = {
36568 (char *) "self",(char *) "id",(char *) "label", NULL
36569 };
36570
36571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36573 if (SWIG_arg_fail(1)) SWIG_fail;
36574 {
36575 arg2 = static_cast<int >(SWIG_As_int(obj1));
36576 if (SWIG_arg_fail(2)) SWIG_fail;
36577 }
36578 {
36579 arg3 = wxString_in_helper(obj2);
36580 if (arg3 == NULL) SWIG_fail;
36581 temp3 = true;
36582 }
36583 {
36584 PyThreadState* __tstate = wxPyBeginAllowThreads();
36585 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36586
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 Py_INCREF(Py_None); resultobj = Py_None;
36591 {
36592 if (temp3)
36593 delete arg3;
36594 }
36595 return resultobj;
36596 fail:
36597 {
36598 if (temp3)
36599 delete arg3;
36600 }
36601 return NULL;
36602 }
36603
36604
36605 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36606 PyObject *resultobj = NULL;
36607 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36608 int arg2 ;
36609 wxString result;
36610 PyObject * obj0 = 0 ;
36611 PyObject * obj1 = 0 ;
36612 char *kwnames[] = {
36613 (char *) "self",(char *) "id", NULL
36614 };
36615
36616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36618 if (SWIG_arg_fail(1)) SWIG_fail;
36619 {
36620 arg2 = static_cast<int >(SWIG_As_int(obj1));
36621 if (SWIG_arg_fail(2)) SWIG_fail;
36622 }
36623 {
36624 PyThreadState* __tstate = wxPyBeginAllowThreads();
36625 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36626
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 #if wxUSE_UNICODE
36632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36633 #else
36634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36635 #endif
36636 }
36637 return resultobj;
36638 fail:
36639 return NULL;
36640 }
36641
36642
36643 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36644 PyObject *resultobj = NULL;
36645 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36646 int arg2 ;
36647 wxString *arg3 = 0 ;
36648 bool temp3 = false ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 PyObject * obj2 = 0 ;
36652 char *kwnames[] = {
36653 (char *) "self",(char *) "id",(char *) "helpString", NULL
36654 };
36655
36656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36658 if (SWIG_arg_fail(1)) SWIG_fail;
36659 {
36660 arg2 = static_cast<int >(SWIG_As_int(obj1));
36661 if (SWIG_arg_fail(2)) SWIG_fail;
36662 }
36663 {
36664 arg3 = wxString_in_helper(obj2);
36665 if (arg3 == NULL) SWIG_fail;
36666 temp3 = true;
36667 }
36668 {
36669 PyThreadState* __tstate = wxPyBeginAllowThreads();
36670 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36671
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 Py_INCREF(Py_None); resultobj = Py_None;
36676 {
36677 if (temp3)
36678 delete arg3;
36679 }
36680 return resultobj;
36681 fail:
36682 {
36683 if (temp3)
36684 delete arg3;
36685 }
36686 return NULL;
36687 }
36688
36689
36690 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36691 PyObject *resultobj = NULL;
36692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36693 int arg2 ;
36694 wxString result;
36695 PyObject * obj0 = 0 ;
36696 PyObject * obj1 = 0 ;
36697 char *kwnames[] = {
36698 (char *) "self",(char *) "id", NULL
36699 };
36700
36701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36703 if (SWIG_arg_fail(1)) SWIG_fail;
36704 {
36705 arg2 = static_cast<int >(SWIG_As_int(obj1));
36706 if (SWIG_arg_fail(2)) SWIG_fail;
36707 }
36708 {
36709 PyThreadState* __tstate = wxPyBeginAllowThreads();
36710 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36711
36712 wxPyEndAllowThreads(__tstate);
36713 if (PyErr_Occurred()) SWIG_fail;
36714 }
36715 {
36716 #if wxUSE_UNICODE
36717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36718 #else
36719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36720 #endif
36721 }
36722 return resultobj;
36723 fail:
36724 return NULL;
36725 }
36726
36727
36728 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36729 PyObject *resultobj = NULL;
36730 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36731 wxFrame *result;
36732 PyObject * obj0 = 0 ;
36733 char *kwnames[] = {
36734 (char *) "self", NULL
36735 };
36736
36737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36739 if (SWIG_arg_fail(1)) SWIG_fail;
36740 {
36741 PyThreadState* __tstate = wxPyBeginAllowThreads();
36742 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36743
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 {
36748 resultobj = wxPyMake_wxObject(result, (bool)0);
36749 }
36750 return resultobj;
36751 fail:
36752 return NULL;
36753 }
36754
36755
36756 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36757 PyObject *resultobj = NULL;
36758 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36759 bool result;
36760 PyObject * obj0 = 0 ;
36761 char *kwnames[] = {
36762 (char *) "self", NULL
36763 };
36764
36765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36767 if (SWIG_arg_fail(1)) SWIG_fail;
36768 {
36769 PyThreadState* __tstate = wxPyBeginAllowThreads();
36770 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36771
36772 wxPyEndAllowThreads(__tstate);
36773 if (PyErr_Occurred()) SWIG_fail;
36774 }
36775 {
36776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36777 }
36778 return resultobj;
36779 fail:
36780 return NULL;
36781 }
36782
36783
36784 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36785 PyObject *resultobj = NULL;
36786 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36787 wxFrame *arg2 = (wxFrame *) 0 ;
36788 PyObject * obj0 = 0 ;
36789 PyObject * obj1 = 0 ;
36790 char *kwnames[] = {
36791 (char *) "self",(char *) "frame", NULL
36792 };
36793
36794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36796 if (SWIG_arg_fail(1)) SWIG_fail;
36797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36798 if (SWIG_arg_fail(2)) SWIG_fail;
36799 {
36800 PyThreadState* __tstate = wxPyBeginAllowThreads();
36801 (arg1)->Attach(arg2);
36802
36803 wxPyEndAllowThreads(__tstate);
36804 if (PyErr_Occurred()) SWIG_fail;
36805 }
36806 Py_INCREF(Py_None); resultobj = Py_None;
36807 return resultobj;
36808 fail:
36809 return NULL;
36810 }
36811
36812
36813 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36814 PyObject *resultobj = NULL;
36815 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36816 PyObject * obj0 = 0 ;
36817 char *kwnames[] = {
36818 (char *) "self", NULL
36819 };
36820
36821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36823 if (SWIG_arg_fail(1)) SWIG_fail;
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 (arg1)->Detach();
36827
36828 wxPyEndAllowThreads(__tstate);
36829 if (PyErr_Occurred()) SWIG_fail;
36830 }
36831 Py_INCREF(Py_None); resultobj = Py_None;
36832 return resultobj;
36833 fail:
36834 return NULL;
36835 }
36836
36837
36838 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36839 PyObject *resultobj = NULL;
36840 bool arg1 ;
36841 PyObject * obj0 = 0 ;
36842 char *kwnames[] = {
36843 (char *) "enable", NULL
36844 };
36845
36846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36847 {
36848 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36849 if (SWIG_arg_fail(1)) SWIG_fail;
36850 }
36851 {
36852 PyThreadState* __tstate = wxPyBeginAllowThreads();
36853 wxMenuBar_SetAutoWindowMenu(arg1);
36854
36855 wxPyEndAllowThreads(__tstate);
36856 if (PyErr_Occurred()) SWIG_fail;
36857 }
36858 Py_INCREF(Py_None); resultobj = Py_None;
36859 return resultobj;
36860 fail:
36861 return NULL;
36862 }
36863
36864
36865 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36866 PyObject *resultobj = NULL;
36867 bool result;
36868 char *kwnames[] = {
36869 NULL
36870 };
36871
36872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36873 {
36874 PyThreadState* __tstate = wxPyBeginAllowThreads();
36875 result = (bool)wxMenuBar_GetAutoWindowMenu();
36876
36877 wxPyEndAllowThreads(__tstate);
36878 if (PyErr_Occurred()) SWIG_fail;
36879 }
36880 {
36881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36882 }
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36890 PyObject *obj;
36891 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36892 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36893 Py_INCREF(obj);
36894 return Py_BuildValue((char *)"");
36895 }
36896 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36897 PyObject *resultobj = NULL;
36898 wxMenu *arg1 = (wxMenu *) NULL ;
36899 int arg2 = (int) wxID_ANY ;
36900 wxString const &arg3_defvalue = wxPyEmptyString ;
36901 wxString *arg3 = (wxString *) &arg3_defvalue ;
36902 wxString const &arg4_defvalue = wxPyEmptyString ;
36903 wxString *arg4 = (wxString *) &arg4_defvalue ;
36904 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36905 wxMenu *arg6 = (wxMenu *) NULL ;
36906 wxMenuItem *result;
36907 bool temp3 = false ;
36908 bool temp4 = false ;
36909 PyObject * obj0 = 0 ;
36910 PyObject * obj1 = 0 ;
36911 PyObject * obj2 = 0 ;
36912 PyObject * obj3 = 0 ;
36913 PyObject * obj4 = 0 ;
36914 PyObject * obj5 = 0 ;
36915 char *kwnames[] = {
36916 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36917 };
36918
36919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36920 if (obj0) {
36921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36922 if (SWIG_arg_fail(1)) SWIG_fail;
36923 }
36924 if (obj1) {
36925 {
36926 arg2 = static_cast<int >(SWIG_As_int(obj1));
36927 if (SWIG_arg_fail(2)) SWIG_fail;
36928 }
36929 }
36930 if (obj2) {
36931 {
36932 arg3 = wxString_in_helper(obj2);
36933 if (arg3 == NULL) SWIG_fail;
36934 temp3 = true;
36935 }
36936 }
36937 if (obj3) {
36938 {
36939 arg4 = wxString_in_helper(obj3);
36940 if (arg4 == NULL) SWIG_fail;
36941 temp4 = true;
36942 }
36943 }
36944 if (obj4) {
36945 {
36946 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36947 if (SWIG_arg_fail(5)) SWIG_fail;
36948 }
36949 }
36950 if (obj5) {
36951 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36952 if (SWIG_arg_fail(6)) SWIG_fail;
36953 }
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36957
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 {
36962 resultobj = wxPyMake_wxObject(result, (bool)1);
36963 }
36964 {
36965 if (temp3)
36966 delete arg3;
36967 }
36968 {
36969 if (temp4)
36970 delete arg4;
36971 }
36972 return resultobj;
36973 fail:
36974 {
36975 if (temp3)
36976 delete arg3;
36977 }
36978 {
36979 if (temp4)
36980 delete arg4;
36981 }
36982 return NULL;
36983 }
36984
36985
36986 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36987 PyObject *resultobj = NULL;
36988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36989 wxMenu *result;
36990 PyObject * obj0 = 0 ;
36991 char *kwnames[] = {
36992 (char *) "self", NULL
36993 };
36994
36995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36997 if (SWIG_arg_fail(1)) SWIG_fail;
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
37001
37002 wxPyEndAllowThreads(__tstate);
37003 if (PyErr_Occurred()) SWIG_fail;
37004 }
37005 {
37006 resultobj = wxPyMake_wxObject(result, 0);
37007 }
37008 return resultobj;
37009 fail:
37010 return NULL;
37011 }
37012
37013
37014 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37015 PyObject *resultobj = NULL;
37016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37017 wxMenu *arg2 = (wxMenu *) 0 ;
37018 PyObject * obj0 = 0 ;
37019 PyObject * obj1 = 0 ;
37020 char *kwnames[] = {
37021 (char *) "self",(char *) "menu", NULL
37022 };
37023
37024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
37025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37026 if (SWIG_arg_fail(1)) SWIG_fail;
37027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37028 if (SWIG_arg_fail(2)) SWIG_fail;
37029 {
37030 PyThreadState* __tstate = wxPyBeginAllowThreads();
37031 (arg1)->SetMenu(arg2);
37032
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 Py_INCREF(Py_None); resultobj = Py_None;
37037 return resultobj;
37038 fail:
37039 return NULL;
37040 }
37041
37042
37043 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
37044 PyObject *resultobj = NULL;
37045 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37046 int arg2 ;
37047 PyObject * obj0 = 0 ;
37048 PyObject * obj1 = 0 ;
37049 char *kwnames[] = {
37050 (char *) "self",(char *) "id", NULL
37051 };
37052
37053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
37054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37055 if (SWIG_arg_fail(1)) SWIG_fail;
37056 {
37057 arg2 = static_cast<int >(SWIG_As_int(obj1));
37058 if (SWIG_arg_fail(2)) SWIG_fail;
37059 }
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 (arg1)->SetId(arg2);
37063
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 Py_INCREF(Py_None); resultobj = Py_None;
37068 return resultobj;
37069 fail:
37070 return NULL;
37071 }
37072
37073
37074 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
37075 PyObject *resultobj = NULL;
37076 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37077 int result;
37078 PyObject * obj0 = 0 ;
37079 char *kwnames[] = {
37080 (char *) "self", NULL
37081 };
37082
37083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
37084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37085 if (SWIG_arg_fail(1)) SWIG_fail;
37086 {
37087 PyThreadState* __tstate = wxPyBeginAllowThreads();
37088 result = (int)((wxMenuItem const *)arg1)->GetId();
37089
37090 wxPyEndAllowThreads(__tstate);
37091 if (PyErr_Occurred()) SWIG_fail;
37092 }
37093 {
37094 resultobj = SWIG_From_int(static_cast<int >(result));
37095 }
37096 return resultobj;
37097 fail:
37098 return NULL;
37099 }
37100
37101
37102 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
37103 PyObject *resultobj = NULL;
37104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37105 bool result;
37106 PyObject * obj0 = 0 ;
37107 char *kwnames[] = {
37108 (char *) "self", NULL
37109 };
37110
37111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
37112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37113 if (SWIG_arg_fail(1)) SWIG_fail;
37114 {
37115 PyThreadState* __tstate = wxPyBeginAllowThreads();
37116 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
37117
37118 wxPyEndAllowThreads(__tstate);
37119 if (PyErr_Occurred()) SWIG_fail;
37120 }
37121 {
37122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37123 }
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj = NULL;
37132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37133 wxString *arg2 = 0 ;
37134 bool temp2 = false ;
37135 PyObject * obj0 = 0 ;
37136 PyObject * obj1 = 0 ;
37137 char *kwnames[] = {
37138 (char *) "self",(char *) "str", NULL
37139 };
37140
37141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37143 if (SWIG_arg_fail(1)) SWIG_fail;
37144 {
37145 arg2 = wxString_in_helper(obj1);
37146 if (arg2 == NULL) SWIG_fail;
37147 temp2 = true;
37148 }
37149 {
37150 PyThreadState* __tstate = wxPyBeginAllowThreads();
37151 (arg1)->SetText((wxString const &)*arg2);
37152
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 Py_INCREF(Py_None); resultobj = Py_None;
37157 {
37158 if (temp2)
37159 delete arg2;
37160 }
37161 return resultobj;
37162 fail:
37163 {
37164 if (temp2)
37165 delete arg2;
37166 }
37167 return NULL;
37168 }
37169
37170
37171 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37172 PyObject *resultobj = NULL;
37173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37174 wxString result;
37175 PyObject * obj0 = 0 ;
37176 char *kwnames[] = {
37177 (char *) "self", NULL
37178 };
37179
37180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37182 if (SWIG_arg_fail(1)) SWIG_fail;
37183 {
37184 PyThreadState* __tstate = wxPyBeginAllowThreads();
37185 result = ((wxMenuItem const *)arg1)->GetLabel();
37186
37187 wxPyEndAllowThreads(__tstate);
37188 if (PyErr_Occurred()) SWIG_fail;
37189 }
37190 {
37191 #if wxUSE_UNICODE
37192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37193 #else
37194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37195 #endif
37196 }
37197 return resultobj;
37198 fail:
37199 return NULL;
37200 }
37201
37202
37203 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37204 PyObject *resultobj = NULL;
37205 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37206 wxString *result;
37207 PyObject * obj0 = 0 ;
37208 char *kwnames[] = {
37209 (char *) "self", NULL
37210 };
37211
37212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37214 if (SWIG_arg_fail(1)) SWIG_fail;
37215 {
37216 PyThreadState* __tstate = wxPyBeginAllowThreads();
37217 {
37218 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37219 result = (wxString *) &_result_ref;
37220 }
37221
37222 wxPyEndAllowThreads(__tstate);
37223 if (PyErr_Occurred()) SWIG_fail;
37224 }
37225 {
37226 #if wxUSE_UNICODE
37227 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37228 #else
37229 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37230 #endif
37231 }
37232 return resultobj;
37233 fail:
37234 return NULL;
37235 }
37236
37237
37238 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37239 PyObject *resultobj = NULL;
37240 wxString *arg1 = 0 ;
37241 wxString result;
37242 bool temp1 = false ;
37243 PyObject * obj0 = 0 ;
37244 char *kwnames[] = {
37245 (char *) "text", NULL
37246 };
37247
37248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37249 {
37250 arg1 = wxString_in_helper(obj0);
37251 if (arg1 == NULL) SWIG_fail;
37252 temp1 = true;
37253 }
37254 {
37255 PyThreadState* __tstate = wxPyBeginAllowThreads();
37256 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37257
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 {
37262 #if wxUSE_UNICODE
37263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37264 #else
37265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37266 #endif
37267 }
37268 {
37269 if (temp1)
37270 delete arg1;
37271 }
37272 return resultobj;
37273 fail:
37274 {
37275 if (temp1)
37276 delete arg1;
37277 }
37278 return NULL;
37279 }
37280
37281
37282 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37283 PyObject *resultobj = NULL;
37284 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37285 wxItemKind result;
37286 PyObject * obj0 = 0 ;
37287 char *kwnames[] = {
37288 (char *) "self", NULL
37289 };
37290
37291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37293 if (SWIG_arg_fail(1)) SWIG_fail;
37294 {
37295 PyThreadState* __tstate = wxPyBeginAllowThreads();
37296 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37297
37298 wxPyEndAllowThreads(__tstate);
37299 if (PyErr_Occurred()) SWIG_fail;
37300 }
37301 resultobj = SWIG_From_int((result));
37302 return resultobj;
37303 fail:
37304 return NULL;
37305 }
37306
37307
37308 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37309 PyObject *resultobj = NULL;
37310 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37311 wxItemKind arg2 ;
37312 PyObject * obj0 = 0 ;
37313 PyObject * obj1 = 0 ;
37314 char *kwnames[] = {
37315 (char *) "self",(char *) "kind", NULL
37316 };
37317
37318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37320 if (SWIG_arg_fail(1)) SWIG_fail;
37321 {
37322 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37323 if (SWIG_arg_fail(2)) SWIG_fail;
37324 }
37325 {
37326 PyThreadState* __tstate = wxPyBeginAllowThreads();
37327 (arg1)->SetKind(arg2);
37328
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 Py_INCREF(Py_None); resultobj = Py_None;
37333 return resultobj;
37334 fail:
37335 return NULL;
37336 }
37337
37338
37339 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37340 PyObject *resultobj = NULL;
37341 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37342 bool arg2 ;
37343 PyObject * obj0 = 0 ;
37344 PyObject * obj1 = 0 ;
37345 char *kwnames[] = {
37346 (char *) "self",(char *) "checkable", NULL
37347 };
37348
37349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37351 if (SWIG_arg_fail(1)) SWIG_fail;
37352 {
37353 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37354 if (SWIG_arg_fail(2)) SWIG_fail;
37355 }
37356 {
37357 PyThreadState* __tstate = wxPyBeginAllowThreads();
37358 (arg1)->SetCheckable(arg2);
37359
37360 wxPyEndAllowThreads(__tstate);
37361 if (PyErr_Occurred()) SWIG_fail;
37362 }
37363 Py_INCREF(Py_None); resultobj = Py_None;
37364 return resultobj;
37365 fail:
37366 return NULL;
37367 }
37368
37369
37370 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37371 PyObject *resultobj = NULL;
37372 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37373 bool result;
37374 PyObject * obj0 = 0 ;
37375 char *kwnames[] = {
37376 (char *) "self", NULL
37377 };
37378
37379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37381 if (SWIG_arg_fail(1)) SWIG_fail;
37382 {
37383 PyThreadState* __tstate = wxPyBeginAllowThreads();
37384 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37385
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 {
37390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37391 }
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37399 PyObject *resultobj = NULL;
37400 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37401 bool result;
37402 PyObject * obj0 = 0 ;
37403 char *kwnames[] = {
37404 (char *) "self", NULL
37405 };
37406
37407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37409 if (SWIG_arg_fail(1)) SWIG_fail;
37410 {
37411 PyThreadState* __tstate = wxPyBeginAllowThreads();
37412 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37413
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 {
37418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37419 }
37420 return resultobj;
37421 fail:
37422 return NULL;
37423 }
37424
37425
37426 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37427 PyObject *resultobj = NULL;
37428 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37429 wxMenu *arg2 = (wxMenu *) 0 ;
37430 PyObject * obj0 = 0 ;
37431 PyObject * obj1 = 0 ;
37432 char *kwnames[] = {
37433 (char *) "self",(char *) "menu", NULL
37434 };
37435
37436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37438 if (SWIG_arg_fail(1)) SWIG_fail;
37439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37440 if (SWIG_arg_fail(2)) SWIG_fail;
37441 {
37442 PyThreadState* __tstate = wxPyBeginAllowThreads();
37443 (arg1)->SetSubMenu(arg2);
37444
37445 wxPyEndAllowThreads(__tstate);
37446 if (PyErr_Occurred()) SWIG_fail;
37447 }
37448 Py_INCREF(Py_None); resultobj = Py_None;
37449 return resultobj;
37450 fail:
37451 return NULL;
37452 }
37453
37454
37455 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37456 PyObject *resultobj = NULL;
37457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37458 wxMenu *result;
37459 PyObject * obj0 = 0 ;
37460 char *kwnames[] = {
37461 (char *) "self", NULL
37462 };
37463
37464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37466 if (SWIG_arg_fail(1)) SWIG_fail;
37467 {
37468 PyThreadState* __tstate = wxPyBeginAllowThreads();
37469 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37470
37471 wxPyEndAllowThreads(__tstate);
37472 if (PyErr_Occurred()) SWIG_fail;
37473 }
37474 {
37475 resultobj = wxPyMake_wxObject(result, 0);
37476 }
37477 return resultobj;
37478 fail:
37479 return NULL;
37480 }
37481
37482
37483 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37484 PyObject *resultobj = NULL;
37485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37486 bool arg2 = (bool) true ;
37487 PyObject * obj0 = 0 ;
37488 PyObject * obj1 = 0 ;
37489 char *kwnames[] = {
37490 (char *) "self",(char *) "enable", NULL
37491 };
37492
37493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37495 if (SWIG_arg_fail(1)) SWIG_fail;
37496 if (obj1) {
37497 {
37498 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37499 if (SWIG_arg_fail(2)) SWIG_fail;
37500 }
37501 }
37502 {
37503 PyThreadState* __tstate = wxPyBeginAllowThreads();
37504 (arg1)->Enable(arg2);
37505
37506 wxPyEndAllowThreads(__tstate);
37507 if (PyErr_Occurred()) SWIG_fail;
37508 }
37509 Py_INCREF(Py_None); resultobj = Py_None;
37510 return resultobj;
37511 fail:
37512 return NULL;
37513 }
37514
37515
37516 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37517 PyObject *resultobj = NULL;
37518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37519 bool result;
37520 PyObject * obj0 = 0 ;
37521 char *kwnames[] = {
37522 (char *) "self", NULL
37523 };
37524
37525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37527 if (SWIG_arg_fail(1)) SWIG_fail;
37528 {
37529 PyThreadState* __tstate = wxPyBeginAllowThreads();
37530 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37531
37532 wxPyEndAllowThreads(__tstate);
37533 if (PyErr_Occurred()) SWIG_fail;
37534 }
37535 {
37536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37537 }
37538 return resultobj;
37539 fail:
37540 return NULL;
37541 }
37542
37543
37544 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37545 PyObject *resultobj = NULL;
37546 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37547 bool arg2 = (bool) true ;
37548 PyObject * obj0 = 0 ;
37549 PyObject * obj1 = 0 ;
37550 char *kwnames[] = {
37551 (char *) "self",(char *) "check", NULL
37552 };
37553
37554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37556 if (SWIG_arg_fail(1)) SWIG_fail;
37557 if (obj1) {
37558 {
37559 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37560 if (SWIG_arg_fail(2)) SWIG_fail;
37561 }
37562 }
37563 {
37564 PyThreadState* __tstate = wxPyBeginAllowThreads();
37565 (arg1)->Check(arg2);
37566
37567 wxPyEndAllowThreads(__tstate);
37568 if (PyErr_Occurred()) SWIG_fail;
37569 }
37570 Py_INCREF(Py_None); resultobj = Py_None;
37571 return resultobj;
37572 fail:
37573 return NULL;
37574 }
37575
37576
37577 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37578 PyObject *resultobj = NULL;
37579 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37580 bool result;
37581 PyObject * obj0 = 0 ;
37582 char *kwnames[] = {
37583 (char *) "self", NULL
37584 };
37585
37586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37588 if (SWIG_arg_fail(1)) SWIG_fail;
37589 {
37590 PyThreadState* __tstate = wxPyBeginAllowThreads();
37591 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37592
37593 wxPyEndAllowThreads(__tstate);
37594 if (PyErr_Occurred()) SWIG_fail;
37595 }
37596 {
37597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37598 }
37599 return resultobj;
37600 fail:
37601 return NULL;
37602 }
37603
37604
37605 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37606 PyObject *resultobj = NULL;
37607 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37608 PyObject * obj0 = 0 ;
37609 char *kwnames[] = {
37610 (char *) "self", NULL
37611 };
37612
37613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37615 if (SWIG_arg_fail(1)) SWIG_fail;
37616 {
37617 PyThreadState* __tstate = wxPyBeginAllowThreads();
37618 (arg1)->Toggle();
37619
37620 wxPyEndAllowThreads(__tstate);
37621 if (PyErr_Occurred()) SWIG_fail;
37622 }
37623 Py_INCREF(Py_None); resultobj = Py_None;
37624 return resultobj;
37625 fail:
37626 return NULL;
37627 }
37628
37629
37630 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37631 PyObject *resultobj = NULL;
37632 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37633 wxString *arg2 = 0 ;
37634 bool temp2 = false ;
37635 PyObject * obj0 = 0 ;
37636 PyObject * obj1 = 0 ;
37637 char *kwnames[] = {
37638 (char *) "self",(char *) "str", NULL
37639 };
37640
37641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37643 if (SWIG_arg_fail(1)) SWIG_fail;
37644 {
37645 arg2 = wxString_in_helper(obj1);
37646 if (arg2 == NULL) SWIG_fail;
37647 temp2 = true;
37648 }
37649 {
37650 PyThreadState* __tstate = wxPyBeginAllowThreads();
37651 (arg1)->SetHelp((wxString const &)*arg2);
37652
37653 wxPyEndAllowThreads(__tstate);
37654 if (PyErr_Occurred()) SWIG_fail;
37655 }
37656 Py_INCREF(Py_None); resultobj = Py_None;
37657 {
37658 if (temp2)
37659 delete arg2;
37660 }
37661 return resultobj;
37662 fail:
37663 {
37664 if (temp2)
37665 delete arg2;
37666 }
37667 return NULL;
37668 }
37669
37670
37671 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37672 PyObject *resultobj = NULL;
37673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37674 wxString *result;
37675 PyObject * obj0 = 0 ;
37676 char *kwnames[] = {
37677 (char *) "self", NULL
37678 };
37679
37680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37682 if (SWIG_arg_fail(1)) SWIG_fail;
37683 {
37684 PyThreadState* __tstate = wxPyBeginAllowThreads();
37685 {
37686 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37687 result = (wxString *) &_result_ref;
37688 }
37689
37690 wxPyEndAllowThreads(__tstate);
37691 if (PyErr_Occurred()) SWIG_fail;
37692 }
37693 {
37694 #if wxUSE_UNICODE
37695 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37696 #else
37697 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37698 #endif
37699 }
37700 return resultobj;
37701 fail:
37702 return NULL;
37703 }
37704
37705
37706 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37707 PyObject *resultobj = NULL;
37708 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37709 wxAcceleratorEntry *result;
37710 PyObject * obj0 = 0 ;
37711 char *kwnames[] = {
37712 (char *) "self", NULL
37713 };
37714
37715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37717 if (SWIG_arg_fail(1)) SWIG_fail;
37718 {
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37721
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37726 return resultobj;
37727 fail:
37728 return NULL;
37729 }
37730
37731
37732 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37733 PyObject *resultobj = NULL;
37734 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37735 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37736 PyObject * obj0 = 0 ;
37737 PyObject * obj1 = 0 ;
37738 char *kwnames[] = {
37739 (char *) "self",(char *) "accel", NULL
37740 };
37741
37742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37744 if (SWIG_arg_fail(1)) SWIG_fail;
37745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37746 if (SWIG_arg_fail(2)) SWIG_fail;
37747 {
37748 PyThreadState* __tstate = wxPyBeginAllowThreads();
37749 (arg1)->SetAccel(arg2);
37750
37751 wxPyEndAllowThreads(__tstate);
37752 if (PyErr_Occurred()) SWIG_fail;
37753 }
37754 Py_INCREF(Py_None); resultobj = Py_None;
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37762 PyObject *resultobj = NULL;
37763 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37764 wxBitmap *arg2 = 0 ;
37765 PyObject * obj0 = 0 ;
37766 PyObject * obj1 = 0 ;
37767 char *kwnames[] = {
37768 (char *) "self",(char *) "bitmap", NULL
37769 };
37770
37771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37773 if (SWIG_arg_fail(1)) SWIG_fail;
37774 {
37775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37776 if (SWIG_arg_fail(2)) SWIG_fail;
37777 if (arg2 == NULL) {
37778 SWIG_null_ref("wxBitmap");
37779 }
37780 if (SWIG_arg_fail(2)) SWIG_fail;
37781 }
37782 {
37783 PyThreadState* __tstate = wxPyBeginAllowThreads();
37784 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37785
37786 wxPyEndAllowThreads(__tstate);
37787 if (PyErr_Occurred()) SWIG_fail;
37788 }
37789 Py_INCREF(Py_None); resultobj = Py_None;
37790 return resultobj;
37791 fail:
37792 return NULL;
37793 }
37794
37795
37796 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37797 PyObject *resultobj = NULL;
37798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37799 wxBitmap *result;
37800 PyObject * obj0 = 0 ;
37801 char *kwnames[] = {
37802 (char *) "self", NULL
37803 };
37804
37805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37807 if (SWIG_arg_fail(1)) SWIG_fail;
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 {
37811 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37812 result = (wxBitmap *) &_result_ref;
37813 }
37814
37815 wxPyEndAllowThreads(__tstate);
37816 if (PyErr_Occurred()) SWIG_fail;
37817 }
37818 {
37819 wxBitmap* resultptr = new wxBitmap(*result);
37820 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37821 }
37822 return resultobj;
37823 fail:
37824 return NULL;
37825 }
37826
37827
37828 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37829 PyObject *resultobj = NULL;
37830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37831 wxFont *arg2 = 0 ;
37832 PyObject * obj0 = 0 ;
37833 PyObject * obj1 = 0 ;
37834 char *kwnames[] = {
37835 (char *) "self",(char *) "font", NULL
37836 };
37837
37838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37840 if (SWIG_arg_fail(1)) SWIG_fail;
37841 {
37842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37843 if (SWIG_arg_fail(2)) SWIG_fail;
37844 if (arg2 == NULL) {
37845 SWIG_null_ref("wxFont");
37846 }
37847 if (SWIG_arg_fail(2)) SWIG_fail;
37848 }
37849 {
37850 PyThreadState* __tstate = wxPyBeginAllowThreads();
37851 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37852
37853 wxPyEndAllowThreads(__tstate);
37854 if (PyErr_Occurred()) SWIG_fail;
37855 }
37856 Py_INCREF(Py_None); resultobj = Py_None;
37857 return resultobj;
37858 fail:
37859 return NULL;
37860 }
37861
37862
37863 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37864 PyObject *resultobj = NULL;
37865 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37866 wxFont result;
37867 PyObject * obj0 = 0 ;
37868 char *kwnames[] = {
37869 (char *) "self", NULL
37870 };
37871
37872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37874 if (SWIG_arg_fail(1)) SWIG_fail;
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = wxMenuItem_GetFont(arg1);
37878
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 {
37883 wxFont * resultptr;
37884 resultptr = new wxFont(static_cast<wxFont & >(result));
37885 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37886 }
37887 return resultobj;
37888 fail:
37889 return NULL;
37890 }
37891
37892
37893 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37894 PyObject *resultobj = NULL;
37895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37896 wxColour *arg2 = 0 ;
37897 wxColour temp2 ;
37898 PyObject * obj0 = 0 ;
37899 PyObject * obj1 = 0 ;
37900 char *kwnames[] = {
37901 (char *) "self",(char *) "colText", NULL
37902 };
37903
37904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37906 if (SWIG_arg_fail(1)) SWIG_fail;
37907 {
37908 arg2 = &temp2;
37909 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37910 }
37911 {
37912 PyThreadState* __tstate = wxPyBeginAllowThreads();
37913 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37914
37915 wxPyEndAllowThreads(__tstate);
37916 if (PyErr_Occurred()) SWIG_fail;
37917 }
37918 Py_INCREF(Py_None); resultobj = Py_None;
37919 return resultobj;
37920 fail:
37921 return NULL;
37922 }
37923
37924
37925 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37926 PyObject *resultobj = NULL;
37927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37928 wxColour result;
37929 PyObject * obj0 = 0 ;
37930 char *kwnames[] = {
37931 (char *) "self", NULL
37932 };
37933
37934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37936 if (SWIG_arg_fail(1)) SWIG_fail;
37937 {
37938 PyThreadState* __tstate = wxPyBeginAllowThreads();
37939 result = wxMenuItem_GetTextColour(arg1);
37940
37941 wxPyEndAllowThreads(__tstate);
37942 if (PyErr_Occurred()) SWIG_fail;
37943 }
37944 {
37945 wxColour * resultptr;
37946 resultptr = new wxColour(static_cast<wxColour & >(result));
37947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37948 }
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37956 PyObject *resultobj = NULL;
37957 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37958 wxColour *arg2 = 0 ;
37959 wxColour temp2 ;
37960 PyObject * obj0 = 0 ;
37961 PyObject * obj1 = 0 ;
37962 char *kwnames[] = {
37963 (char *) "self",(char *) "colBack", NULL
37964 };
37965
37966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37968 if (SWIG_arg_fail(1)) SWIG_fail;
37969 {
37970 arg2 = &temp2;
37971 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37972 }
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37976
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 Py_INCREF(Py_None); resultobj = Py_None;
37981 return resultobj;
37982 fail:
37983 return NULL;
37984 }
37985
37986
37987 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37988 PyObject *resultobj = NULL;
37989 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37990 wxColour result;
37991 PyObject * obj0 = 0 ;
37992 char *kwnames[] = {
37993 (char *) "self", NULL
37994 };
37995
37996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37998 if (SWIG_arg_fail(1)) SWIG_fail;
37999 {
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = wxMenuItem_GetBackgroundColour(arg1);
38002
38003 wxPyEndAllowThreads(__tstate);
38004 if (PyErr_Occurred()) SWIG_fail;
38005 }
38006 {
38007 wxColour * resultptr;
38008 resultptr = new wxColour(static_cast<wxColour & >(result));
38009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
38010 }
38011 return resultobj;
38012 fail:
38013 return NULL;
38014 }
38015
38016
38017 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
38018 PyObject *resultobj = NULL;
38019 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38020 wxBitmap *arg2 = 0 ;
38021 wxBitmap const &arg3_defvalue = wxNullBitmap ;
38022 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
38023 PyObject * obj0 = 0 ;
38024 PyObject * obj1 = 0 ;
38025 PyObject * obj2 = 0 ;
38026 char *kwnames[] = {
38027 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
38028 };
38029
38030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
38031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38032 if (SWIG_arg_fail(1)) SWIG_fail;
38033 {
38034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
38035 if (SWIG_arg_fail(2)) SWIG_fail;
38036 if (arg2 == NULL) {
38037 SWIG_null_ref("wxBitmap");
38038 }
38039 if (SWIG_arg_fail(2)) SWIG_fail;
38040 }
38041 if (obj2) {
38042 {
38043 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
38044 if (SWIG_arg_fail(3)) SWIG_fail;
38045 if (arg3 == NULL) {
38046 SWIG_null_ref("wxBitmap");
38047 }
38048 if (SWIG_arg_fail(3)) SWIG_fail;
38049 }
38050 }
38051 {
38052 PyThreadState* __tstate = wxPyBeginAllowThreads();
38053 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
38054
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 Py_INCREF(Py_None); resultobj = Py_None;
38059 return resultobj;
38060 fail:
38061 return NULL;
38062 }
38063
38064
38065 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
38066 PyObject *resultobj = NULL;
38067 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38068 wxBitmap *arg2 = 0 ;
38069 PyObject * obj0 = 0 ;
38070 PyObject * obj1 = 0 ;
38071 char *kwnames[] = {
38072 (char *) "self",(char *) "bmpDisabled", NULL
38073 };
38074
38075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
38076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38077 if (SWIG_arg_fail(1)) SWIG_fail;
38078 {
38079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
38080 if (SWIG_arg_fail(2)) SWIG_fail;
38081 if (arg2 == NULL) {
38082 SWIG_null_ref("wxBitmap");
38083 }
38084 if (SWIG_arg_fail(2)) SWIG_fail;
38085 }
38086 {
38087 PyThreadState* __tstate = wxPyBeginAllowThreads();
38088 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
38089
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 Py_INCREF(Py_None); resultobj = Py_None;
38094 return resultobj;
38095 fail:
38096 return NULL;
38097 }
38098
38099
38100 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
38101 PyObject *resultobj = NULL;
38102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38103 wxBitmap *result;
38104 PyObject * obj0 = 0 ;
38105 char *kwnames[] = {
38106 (char *) "self", NULL
38107 };
38108
38109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
38110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38111 if (SWIG_arg_fail(1)) SWIG_fail;
38112 {
38113 PyThreadState* __tstate = wxPyBeginAllowThreads();
38114 {
38115 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
38116 result = (wxBitmap *) &_result_ref;
38117 }
38118
38119 wxPyEndAllowThreads(__tstate);
38120 if (PyErr_Occurred()) SWIG_fail;
38121 }
38122 {
38123 wxBitmap* resultptr = new wxBitmap(*result);
38124 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38133 PyObject *resultobj = NULL;
38134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38135 int arg2 ;
38136 PyObject * obj0 = 0 ;
38137 PyObject * obj1 = 0 ;
38138 char *kwnames[] = {
38139 (char *) "self",(char *) "nWidth", NULL
38140 };
38141
38142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38144 if (SWIG_arg_fail(1)) SWIG_fail;
38145 {
38146 arg2 = static_cast<int >(SWIG_As_int(obj1));
38147 if (SWIG_arg_fail(2)) SWIG_fail;
38148 }
38149 {
38150 PyThreadState* __tstate = wxPyBeginAllowThreads();
38151 wxMenuItem_SetMarginWidth(arg1,arg2);
38152
38153 wxPyEndAllowThreads(__tstate);
38154 if (PyErr_Occurred()) SWIG_fail;
38155 }
38156 Py_INCREF(Py_None); resultobj = Py_None;
38157 return resultobj;
38158 fail:
38159 return NULL;
38160 }
38161
38162
38163 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38164 PyObject *resultobj = NULL;
38165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38166 int result;
38167 PyObject * obj0 = 0 ;
38168 char *kwnames[] = {
38169 (char *) "self", NULL
38170 };
38171
38172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38174 if (SWIG_arg_fail(1)) SWIG_fail;
38175 {
38176 PyThreadState* __tstate = wxPyBeginAllowThreads();
38177 result = (int)wxMenuItem_GetMarginWidth(arg1);
38178
38179 wxPyEndAllowThreads(__tstate);
38180 if (PyErr_Occurred()) SWIG_fail;
38181 }
38182 {
38183 resultobj = SWIG_From_int(static_cast<int >(result));
38184 }
38185 return resultobj;
38186 fail:
38187 return NULL;
38188 }
38189
38190
38191 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38192 PyObject *resultobj = NULL;
38193 int result;
38194 char *kwnames[] = {
38195 NULL
38196 };
38197
38198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38199 {
38200 PyThreadState* __tstate = wxPyBeginAllowThreads();
38201 result = (int)wxMenuItem_GetDefaultMarginWidth();
38202
38203 wxPyEndAllowThreads(__tstate);
38204 if (PyErr_Occurred()) SWIG_fail;
38205 }
38206 {
38207 resultobj = SWIG_From_int(static_cast<int >(result));
38208 }
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj = NULL;
38217 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38218 bool result;
38219 PyObject * obj0 = 0 ;
38220 char *kwnames[] = {
38221 (char *) "self", NULL
38222 };
38223
38224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38226 if (SWIG_arg_fail(1)) SWIG_fail;
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
38230
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 {
38235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38236 }
38237 return resultobj;
38238 fail:
38239 return NULL;
38240 }
38241
38242
38243 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38244 PyObject *resultobj = NULL;
38245 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38246 bool arg2 = (bool) true ;
38247 PyObject * obj0 = 0 ;
38248 PyObject * obj1 = 0 ;
38249 char *kwnames[] = {
38250 (char *) "self",(char *) "ownerDrawn", NULL
38251 };
38252
38253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38255 if (SWIG_arg_fail(1)) SWIG_fail;
38256 if (obj1) {
38257 {
38258 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38259 if (SWIG_arg_fail(2)) SWIG_fail;
38260 }
38261 }
38262 {
38263 PyThreadState* __tstate = wxPyBeginAllowThreads();
38264 wxMenuItem_SetOwnerDrawn(arg1,arg2);
38265
38266 wxPyEndAllowThreads(__tstate);
38267 if (PyErr_Occurred()) SWIG_fail;
38268 }
38269 Py_INCREF(Py_None); resultobj = Py_None;
38270 return resultobj;
38271 fail:
38272 return NULL;
38273 }
38274
38275
38276 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38277 PyObject *resultobj = NULL;
38278 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38279 PyObject * obj0 = 0 ;
38280 char *kwnames[] = {
38281 (char *) "self", NULL
38282 };
38283
38284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38286 if (SWIG_arg_fail(1)) SWIG_fail;
38287 {
38288 PyThreadState* __tstate = wxPyBeginAllowThreads();
38289 wxMenuItem_ResetOwnerDrawn(arg1);
38290
38291 wxPyEndAllowThreads(__tstate);
38292 if (PyErr_Occurred()) SWIG_fail;
38293 }
38294 Py_INCREF(Py_None); resultobj = Py_None;
38295 return resultobj;
38296 fail:
38297 return NULL;
38298 }
38299
38300
38301 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38302 PyObject *obj;
38303 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38304 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38305 Py_INCREF(obj);
38306 return Py_BuildValue((char *)"");
38307 }
38308 static int _wrap_ControlNameStr_set(PyObject *) {
38309 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38310 return 1;
38311 }
38312
38313
38314 static PyObject *_wrap_ControlNameStr_get(void) {
38315 PyObject *pyobj = NULL;
38316
38317 {
38318 #if wxUSE_UNICODE
38319 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38320 #else
38321 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38322 #endif
38323 }
38324 return pyobj;
38325 }
38326
38327
38328 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38329 PyObject *resultobj = NULL;
38330 wxWindow *arg1 = (wxWindow *) 0 ;
38331 int arg2 = (int) -1 ;
38332 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38333 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38334 wxSize const &arg4_defvalue = wxDefaultSize ;
38335 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38336 long arg5 = (long) 0 ;
38337 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38338 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38339 wxString const &arg7_defvalue = wxPyControlNameStr ;
38340 wxString *arg7 = (wxString *) &arg7_defvalue ;
38341 wxControl *result;
38342 wxPoint temp3 ;
38343 wxSize temp4 ;
38344 bool temp7 = false ;
38345 PyObject * obj0 = 0 ;
38346 PyObject * obj1 = 0 ;
38347 PyObject * obj2 = 0 ;
38348 PyObject * obj3 = 0 ;
38349 PyObject * obj4 = 0 ;
38350 PyObject * obj5 = 0 ;
38351 PyObject * obj6 = 0 ;
38352 char *kwnames[] = {
38353 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38354 };
38355
38356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38358 if (SWIG_arg_fail(1)) SWIG_fail;
38359 if (obj1) {
38360 {
38361 arg2 = static_cast<int >(SWIG_As_int(obj1));
38362 if (SWIG_arg_fail(2)) SWIG_fail;
38363 }
38364 }
38365 if (obj2) {
38366 {
38367 arg3 = &temp3;
38368 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38369 }
38370 }
38371 if (obj3) {
38372 {
38373 arg4 = &temp4;
38374 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38375 }
38376 }
38377 if (obj4) {
38378 {
38379 arg5 = static_cast<long >(SWIG_As_long(obj4));
38380 if (SWIG_arg_fail(5)) SWIG_fail;
38381 }
38382 }
38383 if (obj5) {
38384 {
38385 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38386 if (SWIG_arg_fail(6)) SWIG_fail;
38387 if (arg6 == NULL) {
38388 SWIG_null_ref("wxValidator");
38389 }
38390 if (SWIG_arg_fail(6)) SWIG_fail;
38391 }
38392 }
38393 if (obj6) {
38394 {
38395 arg7 = wxString_in_helper(obj6);
38396 if (arg7 == NULL) SWIG_fail;
38397 temp7 = true;
38398 }
38399 }
38400 {
38401 if (!wxPyCheckForApp()) SWIG_fail;
38402 PyThreadState* __tstate = wxPyBeginAllowThreads();
38403 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38404
38405 wxPyEndAllowThreads(__tstate);
38406 if (PyErr_Occurred()) SWIG_fail;
38407 }
38408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38409 {
38410 if (temp7)
38411 delete arg7;
38412 }
38413 return resultobj;
38414 fail:
38415 {
38416 if (temp7)
38417 delete arg7;
38418 }
38419 return NULL;
38420 }
38421
38422
38423 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38424 PyObject *resultobj = NULL;
38425 wxControl *result;
38426 char *kwnames[] = {
38427 NULL
38428 };
38429
38430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38431 {
38432 if (!wxPyCheckForApp()) SWIG_fail;
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (wxControl *)new wxControl();
38435
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38440 return resultobj;
38441 fail:
38442 return NULL;
38443 }
38444
38445
38446 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38447 PyObject *resultobj = NULL;
38448 wxControl *arg1 = (wxControl *) 0 ;
38449 wxWindow *arg2 = (wxWindow *) 0 ;
38450 int arg3 = (int) -1 ;
38451 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38452 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38453 wxSize const &arg5_defvalue = wxDefaultSize ;
38454 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38455 long arg6 = (long) 0 ;
38456 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38457 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38458 wxString const &arg8_defvalue = wxPyControlNameStr ;
38459 wxString *arg8 = (wxString *) &arg8_defvalue ;
38460 bool result;
38461 wxPoint temp4 ;
38462 wxSize temp5 ;
38463 bool temp8 = false ;
38464 PyObject * obj0 = 0 ;
38465 PyObject * obj1 = 0 ;
38466 PyObject * obj2 = 0 ;
38467 PyObject * obj3 = 0 ;
38468 PyObject * obj4 = 0 ;
38469 PyObject * obj5 = 0 ;
38470 PyObject * obj6 = 0 ;
38471 PyObject * obj7 = 0 ;
38472 char *kwnames[] = {
38473 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38474 };
38475
38476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38478 if (SWIG_arg_fail(1)) SWIG_fail;
38479 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38480 if (SWIG_arg_fail(2)) SWIG_fail;
38481 if (obj2) {
38482 {
38483 arg3 = static_cast<int >(SWIG_As_int(obj2));
38484 if (SWIG_arg_fail(3)) SWIG_fail;
38485 }
38486 }
38487 if (obj3) {
38488 {
38489 arg4 = &temp4;
38490 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38491 }
38492 }
38493 if (obj4) {
38494 {
38495 arg5 = &temp5;
38496 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38497 }
38498 }
38499 if (obj5) {
38500 {
38501 arg6 = static_cast<long >(SWIG_As_long(obj5));
38502 if (SWIG_arg_fail(6)) SWIG_fail;
38503 }
38504 }
38505 if (obj6) {
38506 {
38507 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38508 if (SWIG_arg_fail(7)) SWIG_fail;
38509 if (arg7 == NULL) {
38510 SWIG_null_ref("wxValidator");
38511 }
38512 if (SWIG_arg_fail(7)) SWIG_fail;
38513 }
38514 }
38515 if (obj7) {
38516 {
38517 arg8 = wxString_in_helper(obj7);
38518 if (arg8 == NULL) SWIG_fail;
38519 temp8 = true;
38520 }
38521 }
38522 {
38523 PyThreadState* __tstate = wxPyBeginAllowThreads();
38524 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38525
38526 wxPyEndAllowThreads(__tstate);
38527 if (PyErr_Occurred()) SWIG_fail;
38528 }
38529 {
38530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38531 }
38532 {
38533 if (temp8)
38534 delete arg8;
38535 }
38536 return resultobj;
38537 fail:
38538 {
38539 if (temp8)
38540 delete arg8;
38541 }
38542 return NULL;
38543 }
38544
38545
38546 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38547 PyObject *resultobj = NULL;
38548 wxControl *arg1 = (wxControl *) 0 ;
38549 wxCommandEvent *arg2 = 0 ;
38550 PyObject * obj0 = 0 ;
38551 PyObject * obj1 = 0 ;
38552 char *kwnames[] = {
38553 (char *) "self",(char *) "event", NULL
38554 };
38555
38556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38558 if (SWIG_arg_fail(1)) SWIG_fail;
38559 {
38560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38561 if (SWIG_arg_fail(2)) SWIG_fail;
38562 if (arg2 == NULL) {
38563 SWIG_null_ref("wxCommandEvent");
38564 }
38565 if (SWIG_arg_fail(2)) SWIG_fail;
38566 }
38567 {
38568 PyThreadState* __tstate = wxPyBeginAllowThreads();
38569 (arg1)->Command(*arg2);
38570
38571 wxPyEndAllowThreads(__tstate);
38572 if (PyErr_Occurred()) SWIG_fail;
38573 }
38574 Py_INCREF(Py_None); resultobj = Py_None;
38575 return resultobj;
38576 fail:
38577 return NULL;
38578 }
38579
38580
38581 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38582 PyObject *resultobj = NULL;
38583 wxControl *arg1 = (wxControl *) 0 ;
38584 wxString result;
38585 PyObject * obj0 = 0 ;
38586 char *kwnames[] = {
38587 (char *) "self", NULL
38588 };
38589
38590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38592 if (SWIG_arg_fail(1)) SWIG_fail;
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 result = (arg1)->GetLabel();
38596
38597 wxPyEndAllowThreads(__tstate);
38598 if (PyErr_Occurred()) SWIG_fail;
38599 }
38600 {
38601 #if wxUSE_UNICODE
38602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38603 #else
38604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38605 #endif
38606 }
38607 return resultobj;
38608 fail:
38609 return NULL;
38610 }
38611
38612
38613 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38614 PyObject *resultobj = NULL;
38615 wxControl *arg1 = (wxControl *) 0 ;
38616 wxString *arg2 = 0 ;
38617 bool temp2 = false ;
38618 PyObject * obj0 = 0 ;
38619 PyObject * obj1 = 0 ;
38620 char *kwnames[] = {
38621 (char *) "self",(char *) "label", NULL
38622 };
38623
38624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38626 if (SWIG_arg_fail(1)) SWIG_fail;
38627 {
38628 arg2 = wxString_in_helper(obj1);
38629 if (arg2 == NULL) SWIG_fail;
38630 temp2 = true;
38631 }
38632 {
38633 PyThreadState* __tstate = wxPyBeginAllowThreads();
38634 (arg1)->SetLabel((wxString const &)*arg2);
38635
38636 wxPyEndAllowThreads(__tstate);
38637 if (PyErr_Occurred()) SWIG_fail;
38638 }
38639 Py_INCREF(Py_None); resultobj = Py_None;
38640 {
38641 if (temp2)
38642 delete arg2;
38643 }
38644 return resultobj;
38645 fail:
38646 {
38647 if (temp2)
38648 delete arg2;
38649 }
38650 return NULL;
38651 }
38652
38653
38654 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38655 PyObject *resultobj = NULL;
38656 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38657 wxVisualAttributes result;
38658 PyObject * obj0 = 0 ;
38659 char *kwnames[] = {
38660 (char *) "variant", NULL
38661 };
38662
38663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38664 if (obj0) {
38665 {
38666 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38667 if (SWIG_arg_fail(1)) SWIG_fail;
38668 }
38669 }
38670 {
38671 if (!wxPyCheckForApp()) SWIG_fail;
38672 PyThreadState* __tstate = wxPyBeginAllowThreads();
38673 result = wxControl::GetClassDefaultAttributes(arg1);
38674
38675 wxPyEndAllowThreads(__tstate);
38676 if (PyErr_Occurred()) SWIG_fail;
38677 }
38678 {
38679 wxVisualAttributes * resultptr;
38680 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38682 }
38683 return resultobj;
38684 fail:
38685 return NULL;
38686 }
38687
38688
38689 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38690 PyObject *obj;
38691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38692 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38693 Py_INCREF(obj);
38694 return Py_BuildValue((char *)"");
38695 }
38696 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38697 PyObject *resultobj = NULL;
38698 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38699 wxString *arg2 = 0 ;
38700 PyObject *arg3 = (PyObject *) NULL ;
38701 int result;
38702 bool temp2 = false ;
38703 PyObject * obj0 = 0 ;
38704 PyObject * obj1 = 0 ;
38705 PyObject * obj2 = 0 ;
38706 char *kwnames[] = {
38707 (char *) "self",(char *) "item",(char *) "clientData", NULL
38708 };
38709
38710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38712 if (SWIG_arg_fail(1)) SWIG_fail;
38713 {
38714 arg2 = wxString_in_helper(obj1);
38715 if (arg2 == NULL) SWIG_fail;
38716 temp2 = true;
38717 }
38718 if (obj2) {
38719 arg3 = obj2;
38720 }
38721 {
38722 PyThreadState* __tstate = wxPyBeginAllowThreads();
38723 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38724
38725 wxPyEndAllowThreads(__tstate);
38726 if (PyErr_Occurred()) SWIG_fail;
38727 }
38728 {
38729 resultobj = SWIG_From_int(static_cast<int >(result));
38730 }
38731 {
38732 if (temp2)
38733 delete arg2;
38734 }
38735 return resultobj;
38736 fail:
38737 {
38738 if (temp2)
38739 delete arg2;
38740 }
38741 return NULL;
38742 }
38743
38744
38745 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38746 PyObject *resultobj = NULL;
38747 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38748 wxArrayString *arg2 = 0 ;
38749 bool temp2 = false ;
38750 PyObject * obj0 = 0 ;
38751 PyObject * obj1 = 0 ;
38752 char *kwnames[] = {
38753 (char *) "self",(char *) "strings", NULL
38754 };
38755
38756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38758 if (SWIG_arg_fail(1)) SWIG_fail;
38759 {
38760 if (! PySequence_Check(obj1)) {
38761 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38762 SWIG_fail;
38763 }
38764 arg2 = new wxArrayString;
38765 temp2 = true;
38766 int i, len=PySequence_Length(obj1);
38767 for (i=0; i<len; i++) {
38768 PyObject* item = PySequence_GetItem(obj1, i);
38769 wxString* s = wxString_in_helper(item);
38770 if (PyErr_Occurred()) SWIG_fail;
38771 arg2->Add(*s);
38772 delete s;
38773 Py_DECREF(item);
38774 }
38775 }
38776 {
38777 PyThreadState* __tstate = wxPyBeginAllowThreads();
38778 (arg1)->Append((wxArrayString const &)*arg2);
38779
38780 wxPyEndAllowThreads(__tstate);
38781 if (PyErr_Occurred()) SWIG_fail;
38782 }
38783 Py_INCREF(Py_None); resultobj = Py_None;
38784 {
38785 if (temp2) delete arg2;
38786 }
38787 return resultobj;
38788 fail:
38789 {
38790 if (temp2) delete arg2;
38791 }
38792 return NULL;
38793 }
38794
38795
38796 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38797 PyObject *resultobj = NULL;
38798 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38799 wxString *arg2 = 0 ;
38800 int arg3 ;
38801 PyObject *arg4 = (PyObject *) NULL ;
38802 int result;
38803 bool temp2 = false ;
38804 PyObject * obj0 = 0 ;
38805 PyObject * obj1 = 0 ;
38806 PyObject * obj2 = 0 ;
38807 PyObject * obj3 = 0 ;
38808 char *kwnames[] = {
38809 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38810 };
38811
38812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38814 if (SWIG_arg_fail(1)) SWIG_fail;
38815 {
38816 arg2 = wxString_in_helper(obj1);
38817 if (arg2 == NULL) SWIG_fail;
38818 temp2 = true;
38819 }
38820 {
38821 arg3 = static_cast<int >(SWIG_As_int(obj2));
38822 if (SWIG_arg_fail(3)) SWIG_fail;
38823 }
38824 if (obj3) {
38825 arg4 = obj3;
38826 }
38827 {
38828 PyThreadState* __tstate = wxPyBeginAllowThreads();
38829 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38830
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 {
38835 resultobj = SWIG_From_int(static_cast<int >(result));
38836 }
38837 {
38838 if (temp2)
38839 delete arg2;
38840 }
38841 return resultobj;
38842 fail:
38843 {
38844 if (temp2)
38845 delete arg2;
38846 }
38847 return NULL;
38848 }
38849
38850
38851 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38852 PyObject *resultobj = NULL;
38853 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38854 PyObject * obj0 = 0 ;
38855 char *kwnames[] = {
38856 (char *) "self", NULL
38857 };
38858
38859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38861 if (SWIG_arg_fail(1)) SWIG_fail;
38862 {
38863 PyThreadState* __tstate = wxPyBeginAllowThreads();
38864 (arg1)->Clear();
38865
38866 wxPyEndAllowThreads(__tstate);
38867 if (PyErr_Occurred()) SWIG_fail;
38868 }
38869 Py_INCREF(Py_None); resultobj = Py_None;
38870 return resultobj;
38871 fail:
38872 return NULL;
38873 }
38874
38875
38876 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38877 PyObject *resultobj = NULL;
38878 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38879 int arg2 ;
38880 PyObject * obj0 = 0 ;
38881 PyObject * obj1 = 0 ;
38882 char *kwnames[] = {
38883 (char *) "self",(char *) "n", NULL
38884 };
38885
38886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38888 if (SWIG_arg_fail(1)) SWIG_fail;
38889 {
38890 arg2 = static_cast<int >(SWIG_As_int(obj1));
38891 if (SWIG_arg_fail(2)) SWIG_fail;
38892 }
38893 {
38894 PyThreadState* __tstate = wxPyBeginAllowThreads();
38895 (arg1)->Delete(arg2);
38896
38897 wxPyEndAllowThreads(__tstate);
38898 if (PyErr_Occurred()) SWIG_fail;
38899 }
38900 Py_INCREF(Py_None); resultobj = Py_None;
38901 return resultobj;
38902 fail:
38903 return NULL;
38904 }
38905
38906
38907 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38908 PyObject *resultobj = NULL;
38909 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38910 int arg2 ;
38911 PyObject *result;
38912 PyObject * obj0 = 0 ;
38913 PyObject * obj1 = 0 ;
38914 char *kwnames[] = {
38915 (char *) "self",(char *) "n", NULL
38916 };
38917
38918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38920 if (SWIG_arg_fail(1)) SWIG_fail;
38921 {
38922 arg2 = static_cast<int >(SWIG_As_int(obj1));
38923 if (SWIG_arg_fail(2)) SWIG_fail;
38924 }
38925 {
38926 PyThreadState* __tstate = wxPyBeginAllowThreads();
38927 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38928
38929 wxPyEndAllowThreads(__tstate);
38930 if (PyErr_Occurred()) SWIG_fail;
38931 }
38932 resultobj = result;
38933 return resultobj;
38934 fail:
38935 return NULL;
38936 }
38937
38938
38939 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38940 PyObject *resultobj = NULL;
38941 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38942 int arg2 ;
38943 PyObject *arg3 = (PyObject *) 0 ;
38944 PyObject * obj0 = 0 ;
38945 PyObject * obj1 = 0 ;
38946 PyObject * obj2 = 0 ;
38947 char *kwnames[] = {
38948 (char *) "self",(char *) "n",(char *) "clientData", NULL
38949 };
38950
38951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38953 if (SWIG_arg_fail(1)) SWIG_fail;
38954 {
38955 arg2 = static_cast<int >(SWIG_As_int(obj1));
38956 if (SWIG_arg_fail(2)) SWIG_fail;
38957 }
38958 arg3 = obj2;
38959 {
38960 PyThreadState* __tstate = wxPyBeginAllowThreads();
38961 wxItemContainer_SetClientData(arg1,arg2,arg3);
38962
38963 wxPyEndAllowThreads(__tstate);
38964 if (PyErr_Occurred()) SWIG_fail;
38965 }
38966 Py_INCREF(Py_None); resultobj = Py_None;
38967 return resultobj;
38968 fail:
38969 return NULL;
38970 }
38971
38972
38973 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38974 PyObject *resultobj = NULL;
38975 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38976 int result;
38977 PyObject * obj0 = 0 ;
38978 char *kwnames[] = {
38979 (char *) "self", NULL
38980 };
38981
38982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38984 if (SWIG_arg_fail(1)) SWIG_fail;
38985 {
38986 PyThreadState* __tstate = wxPyBeginAllowThreads();
38987 result = (int)((wxItemContainer const *)arg1)->GetCount();
38988
38989 wxPyEndAllowThreads(__tstate);
38990 if (PyErr_Occurred()) SWIG_fail;
38991 }
38992 {
38993 resultobj = SWIG_From_int(static_cast<int >(result));
38994 }
38995 return resultobj;
38996 fail:
38997 return NULL;
38998 }
38999
39000
39001 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
39002 PyObject *resultobj = NULL;
39003 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39004 bool result;
39005 PyObject * obj0 = 0 ;
39006 char *kwnames[] = {
39007 (char *) "self", NULL
39008 };
39009
39010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
39011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39012 if (SWIG_arg_fail(1)) SWIG_fail;
39013 {
39014 PyThreadState* __tstate = wxPyBeginAllowThreads();
39015 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
39016
39017 wxPyEndAllowThreads(__tstate);
39018 if (PyErr_Occurred()) SWIG_fail;
39019 }
39020 {
39021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39022 }
39023 return resultobj;
39024 fail:
39025 return NULL;
39026 }
39027
39028
39029 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
39030 PyObject *resultobj = NULL;
39031 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39032 int arg2 ;
39033 wxString result;
39034 PyObject * obj0 = 0 ;
39035 PyObject * obj1 = 0 ;
39036 char *kwnames[] = {
39037 (char *) "self",(char *) "n", NULL
39038 };
39039
39040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
39041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39042 if (SWIG_arg_fail(1)) SWIG_fail;
39043 {
39044 arg2 = static_cast<int >(SWIG_As_int(obj1));
39045 if (SWIG_arg_fail(2)) SWIG_fail;
39046 }
39047 {
39048 PyThreadState* __tstate = wxPyBeginAllowThreads();
39049 result = ((wxItemContainer const *)arg1)->GetString(arg2);
39050
39051 wxPyEndAllowThreads(__tstate);
39052 if (PyErr_Occurred()) SWIG_fail;
39053 }
39054 {
39055 #if wxUSE_UNICODE
39056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39057 #else
39058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39059 #endif
39060 }
39061 return resultobj;
39062 fail:
39063 return NULL;
39064 }
39065
39066
39067 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
39068 PyObject *resultobj = NULL;
39069 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39070 wxArrayString result;
39071 PyObject * obj0 = 0 ;
39072 char *kwnames[] = {
39073 (char *) "self", NULL
39074 };
39075
39076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
39077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39078 if (SWIG_arg_fail(1)) SWIG_fail;
39079 {
39080 PyThreadState* __tstate = wxPyBeginAllowThreads();
39081 result = ((wxItemContainer const *)arg1)->GetStrings();
39082
39083 wxPyEndAllowThreads(__tstate);
39084 if (PyErr_Occurred()) SWIG_fail;
39085 }
39086 {
39087 resultobj = wxArrayString2PyList_helper(result);
39088 }
39089 return resultobj;
39090 fail:
39091 return NULL;
39092 }
39093
39094
39095 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
39096 PyObject *resultobj = NULL;
39097 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39098 int arg2 ;
39099 wxString *arg3 = 0 ;
39100 bool temp3 = false ;
39101 PyObject * obj0 = 0 ;
39102 PyObject * obj1 = 0 ;
39103 PyObject * obj2 = 0 ;
39104 char *kwnames[] = {
39105 (char *) "self",(char *) "n",(char *) "s", NULL
39106 };
39107
39108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
39109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39110 if (SWIG_arg_fail(1)) SWIG_fail;
39111 {
39112 arg2 = static_cast<int >(SWIG_As_int(obj1));
39113 if (SWIG_arg_fail(2)) SWIG_fail;
39114 }
39115 {
39116 arg3 = wxString_in_helper(obj2);
39117 if (arg3 == NULL) SWIG_fail;
39118 temp3 = true;
39119 }
39120 {
39121 PyThreadState* __tstate = wxPyBeginAllowThreads();
39122 (arg1)->SetString(arg2,(wxString const &)*arg3);
39123
39124 wxPyEndAllowThreads(__tstate);
39125 if (PyErr_Occurred()) SWIG_fail;
39126 }
39127 Py_INCREF(Py_None); resultobj = Py_None;
39128 {
39129 if (temp3)
39130 delete arg3;
39131 }
39132 return resultobj;
39133 fail:
39134 {
39135 if (temp3)
39136 delete arg3;
39137 }
39138 return NULL;
39139 }
39140
39141
39142 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39143 PyObject *resultobj = NULL;
39144 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39145 wxString *arg2 = 0 ;
39146 int result;
39147 bool temp2 = false ;
39148 PyObject * obj0 = 0 ;
39149 PyObject * obj1 = 0 ;
39150 char *kwnames[] = {
39151 (char *) "self",(char *) "s", NULL
39152 };
39153
39154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39156 if (SWIG_arg_fail(1)) SWIG_fail;
39157 {
39158 arg2 = wxString_in_helper(obj1);
39159 if (arg2 == NULL) SWIG_fail;
39160 temp2 = true;
39161 }
39162 {
39163 PyThreadState* __tstate = wxPyBeginAllowThreads();
39164 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39165
39166 wxPyEndAllowThreads(__tstate);
39167 if (PyErr_Occurred()) SWIG_fail;
39168 }
39169 {
39170 resultobj = SWIG_From_int(static_cast<int >(result));
39171 }
39172 {
39173 if (temp2)
39174 delete arg2;
39175 }
39176 return resultobj;
39177 fail:
39178 {
39179 if (temp2)
39180 delete arg2;
39181 }
39182 return NULL;
39183 }
39184
39185
39186 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39187 PyObject *resultobj = NULL;
39188 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39189 int arg2 ;
39190 PyObject * obj0 = 0 ;
39191 PyObject * obj1 = 0 ;
39192 char *kwnames[] = {
39193 (char *) "self",(char *) "n", NULL
39194 };
39195
39196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39198 if (SWIG_arg_fail(1)) SWIG_fail;
39199 {
39200 arg2 = static_cast<int >(SWIG_As_int(obj1));
39201 if (SWIG_arg_fail(2)) SWIG_fail;
39202 }
39203 {
39204 PyThreadState* __tstate = wxPyBeginAllowThreads();
39205 (arg1)->SetSelection(arg2);
39206
39207 wxPyEndAllowThreads(__tstate);
39208 if (PyErr_Occurred()) SWIG_fail;
39209 }
39210 Py_INCREF(Py_None); resultobj = Py_None;
39211 return resultobj;
39212 fail:
39213 return NULL;
39214 }
39215
39216
39217 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39218 PyObject *resultobj = NULL;
39219 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39220 int result;
39221 PyObject * obj0 = 0 ;
39222 char *kwnames[] = {
39223 (char *) "self", NULL
39224 };
39225
39226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39228 if (SWIG_arg_fail(1)) SWIG_fail;
39229 {
39230 PyThreadState* __tstate = wxPyBeginAllowThreads();
39231 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39232
39233 wxPyEndAllowThreads(__tstate);
39234 if (PyErr_Occurred()) SWIG_fail;
39235 }
39236 {
39237 resultobj = SWIG_From_int(static_cast<int >(result));
39238 }
39239 return resultobj;
39240 fail:
39241 return NULL;
39242 }
39243
39244
39245 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39246 PyObject *resultobj = NULL;
39247 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39248 wxString *arg2 = 0 ;
39249 bool result;
39250 bool temp2 = false ;
39251 PyObject * obj0 = 0 ;
39252 PyObject * obj1 = 0 ;
39253 char *kwnames[] = {
39254 (char *) "self",(char *) "s", NULL
39255 };
39256
39257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39259 if (SWIG_arg_fail(1)) SWIG_fail;
39260 {
39261 arg2 = wxString_in_helper(obj1);
39262 if (arg2 == NULL) SWIG_fail;
39263 temp2 = true;
39264 }
39265 {
39266 PyThreadState* __tstate = wxPyBeginAllowThreads();
39267 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39268
39269 wxPyEndAllowThreads(__tstate);
39270 if (PyErr_Occurred()) SWIG_fail;
39271 }
39272 {
39273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39274 }
39275 {
39276 if (temp2)
39277 delete arg2;
39278 }
39279 return resultobj;
39280 fail:
39281 {
39282 if (temp2)
39283 delete arg2;
39284 }
39285 return NULL;
39286 }
39287
39288
39289 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39290 PyObject *resultobj = NULL;
39291 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39292 wxString result;
39293 PyObject * obj0 = 0 ;
39294 char *kwnames[] = {
39295 (char *) "self", NULL
39296 };
39297
39298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39300 if (SWIG_arg_fail(1)) SWIG_fail;
39301 {
39302 PyThreadState* __tstate = wxPyBeginAllowThreads();
39303 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39304
39305 wxPyEndAllowThreads(__tstate);
39306 if (PyErr_Occurred()) SWIG_fail;
39307 }
39308 {
39309 #if wxUSE_UNICODE
39310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39311 #else
39312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39313 #endif
39314 }
39315 return resultobj;
39316 fail:
39317 return NULL;
39318 }
39319
39320
39321 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39322 PyObject *resultobj = NULL;
39323 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39324 int arg2 ;
39325 PyObject * obj0 = 0 ;
39326 PyObject * obj1 = 0 ;
39327 char *kwnames[] = {
39328 (char *) "self",(char *) "n", NULL
39329 };
39330
39331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39333 if (SWIG_arg_fail(1)) SWIG_fail;
39334 {
39335 arg2 = static_cast<int >(SWIG_As_int(obj1));
39336 if (SWIG_arg_fail(2)) SWIG_fail;
39337 }
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 (arg1)->Select(arg2);
39341
39342 wxPyEndAllowThreads(__tstate);
39343 if (PyErr_Occurred()) SWIG_fail;
39344 }
39345 Py_INCREF(Py_None); resultobj = Py_None;
39346 return resultobj;
39347 fail:
39348 return NULL;
39349 }
39350
39351
39352 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39353 PyObject *obj;
39354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39355 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39356 Py_INCREF(obj);
39357 return Py_BuildValue((char *)"");
39358 }
39359 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39360 PyObject *obj;
39361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39362 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39363 Py_INCREF(obj);
39364 return Py_BuildValue((char *)"");
39365 }
39366 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39367 PyObject *resultobj = NULL;
39368 wxSizerItem *result;
39369 char *kwnames[] = {
39370 NULL
39371 };
39372
39373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39374 {
39375 PyThreadState* __tstate = wxPyBeginAllowThreads();
39376 result = (wxSizerItem *)new wxSizerItem();
39377
39378 wxPyEndAllowThreads(__tstate);
39379 if (PyErr_Occurred()) SWIG_fail;
39380 }
39381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39382 return resultobj;
39383 fail:
39384 return NULL;
39385 }
39386
39387
39388 static PyObject *_wrap_delete_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39389 PyObject *resultobj = NULL;
39390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39391 PyObject * obj0 = 0 ;
39392 char *kwnames[] = {
39393 (char *) "self", NULL
39394 };
39395
39396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SizerItem",kwnames,&obj0)) goto fail;
39397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39398 if (SWIG_arg_fail(1)) SWIG_fail;
39399 {
39400 PyThreadState* __tstate = wxPyBeginAllowThreads();
39401 delete arg1;
39402
39403 wxPyEndAllowThreads(__tstate);
39404 if (PyErr_Occurred()) SWIG_fail;
39405 }
39406 Py_INCREF(Py_None); resultobj = Py_None;
39407 return resultobj;
39408 fail:
39409 return NULL;
39410 }
39411
39412
39413 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39414 PyObject *resultobj = NULL;
39415 wxWindow *arg1 = (wxWindow *) 0 ;
39416 int arg2 ;
39417 int arg3 ;
39418 int arg4 ;
39419 PyObject *arg5 = (PyObject *) NULL ;
39420 wxSizerItem *result;
39421 PyObject * obj0 = 0 ;
39422 PyObject * obj1 = 0 ;
39423 PyObject * obj2 = 0 ;
39424 PyObject * obj3 = 0 ;
39425 PyObject * obj4 = 0 ;
39426 char *kwnames[] = {
39427 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39428 };
39429
39430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39432 if (SWIG_arg_fail(1)) SWIG_fail;
39433 {
39434 arg2 = static_cast<int >(SWIG_As_int(obj1));
39435 if (SWIG_arg_fail(2)) SWIG_fail;
39436 }
39437 {
39438 arg3 = static_cast<int >(SWIG_As_int(obj2));
39439 if (SWIG_arg_fail(3)) SWIG_fail;
39440 }
39441 {
39442 arg4 = static_cast<int >(SWIG_As_int(obj3));
39443 if (SWIG_arg_fail(4)) SWIG_fail;
39444 }
39445 if (obj4) {
39446 arg5 = obj4;
39447 }
39448 {
39449 PyThreadState* __tstate = wxPyBeginAllowThreads();
39450 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39451
39452 wxPyEndAllowThreads(__tstate);
39453 if (PyErr_Occurred()) SWIG_fail;
39454 }
39455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39456 return resultobj;
39457 fail:
39458 return NULL;
39459 }
39460
39461
39462 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39463 PyObject *resultobj = NULL;
39464 int arg1 ;
39465 int arg2 ;
39466 int arg3 ;
39467 int arg4 ;
39468 int arg5 ;
39469 PyObject *arg6 = (PyObject *) NULL ;
39470 wxSizerItem *result;
39471 PyObject * obj0 = 0 ;
39472 PyObject * obj1 = 0 ;
39473 PyObject * obj2 = 0 ;
39474 PyObject * obj3 = 0 ;
39475 PyObject * obj4 = 0 ;
39476 PyObject * obj5 = 0 ;
39477 char *kwnames[] = {
39478 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39479 };
39480
39481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39482 {
39483 arg1 = static_cast<int >(SWIG_As_int(obj0));
39484 if (SWIG_arg_fail(1)) SWIG_fail;
39485 }
39486 {
39487 arg2 = static_cast<int >(SWIG_As_int(obj1));
39488 if (SWIG_arg_fail(2)) SWIG_fail;
39489 }
39490 {
39491 arg3 = static_cast<int >(SWIG_As_int(obj2));
39492 if (SWIG_arg_fail(3)) SWIG_fail;
39493 }
39494 {
39495 arg4 = static_cast<int >(SWIG_As_int(obj3));
39496 if (SWIG_arg_fail(4)) SWIG_fail;
39497 }
39498 {
39499 arg5 = static_cast<int >(SWIG_As_int(obj4));
39500 if (SWIG_arg_fail(5)) SWIG_fail;
39501 }
39502 if (obj5) {
39503 arg6 = obj5;
39504 }
39505 {
39506 PyThreadState* __tstate = wxPyBeginAllowThreads();
39507 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39508
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39513 return resultobj;
39514 fail:
39515 return NULL;
39516 }
39517
39518
39519 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39520 PyObject *resultobj = NULL;
39521 wxSizer *arg1 = (wxSizer *) 0 ;
39522 int arg2 ;
39523 int arg3 ;
39524 int arg4 ;
39525 PyObject *arg5 = (PyObject *) NULL ;
39526 wxSizerItem *result;
39527 PyObject * obj0 = 0 ;
39528 PyObject * obj1 = 0 ;
39529 PyObject * obj2 = 0 ;
39530 PyObject * obj3 = 0 ;
39531 PyObject * obj4 = 0 ;
39532 char *kwnames[] = {
39533 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39534 };
39535
39536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
39538 if (SWIG_arg_fail(1)) SWIG_fail;
39539 {
39540 arg2 = static_cast<int >(SWIG_As_int(obj1));
39541 if (SWIG_arg_fail(2)) SWIG_fail;
39542 }
39543 {
39544 arg3 = static_cast<int >(SWIG_As_int(obj2));
39545 if (SWIG_arg_fail(3)) SWIG_fail;
39546 }
39547 {
39548 arg4 = static_cast<int >(SWIG_As_int(obj3));
39549 if (SWIG_arg_fail(4)) SWIG_fail;
39550 }
39551 if (obj4) {
39552 arg5 = obj4;
39553 }
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39557
39558 wxPyEndAllowThreads(__tstate);
39559 if (PyErr_Occurred()) SWIG_fail;
39560 }
39561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39562 return resultobj;
39563 fail:
39564 return NULL;
39565 }
39566
39567
39568 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39569 PyObject *resultobj = NULL;
39570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39571 PyObject * obj0 = 0 ;
39572 char *kwnames[] = {
39573 (char *) "self", NULL
39574 };
39575
39576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39578 if (SWIG_arg_fail(1)) SWIG_fail;
39579 {
39580 PyThreadState* __tstate = wxPyBeginAllowThreads();
39581 (arg1)->DeleteWindows();
39582
39583 wxPyEndAllowThreads(__tstate);
39584 if (PyErr_Occurred()) SWIG_fail;
39585 }
39586 Py_INCREF(Py_None); resultobj = Py_None;
39587 return resultobj;
39588 fail:
39589 return NULL;
39590 }
39591
39592
39593 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39594 PyObject *resultobj = NULL;
39595 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39596 PyObject * obj0 = 0 ;
39597 char *kwnames[] = {
39598 (char *) "self", NULL
39599 };
39600
39601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39603 if (SWIG_arg_fail(1)) SWIG_fail;
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 (arg1)->DetachSizer();
39607
39608 wxPyEndAllowThreads(__tstate);
39609 if (PyErr_Occurred()) SWIG_fail;
39610 }
39611 Py_INCREF(Py_None); resultobj = Py_None;
39612 return resultobj;
39613 fail:
39614 return NULL;
39615 }
39616
39617
39618 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39619 PyObject *resultobj = NULL;
39620 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39621 wxSize result;
39622 PyObject * obj0 = 0 ;
39623 char *kwnames[] = {
39624 (char *) "self", NULL
39625 };
39626
39627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39629 if (SWIG_arg_fail(1)) SWIG_fail;
39630 {
39631 PyThreadState* __tstate = wxPyBeginAllowThreads();
39632 result = (arg1)->GetSize();
39633
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 {
39638 wxSize * resultptr;
39639 resultptr = new wxSize(static_cast<wxSize & >(result));
39640 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39641 }
39642 return resultobj;
39643 fail:
39644 return NULL;
39645 }
39646
39647
39648 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39649 PyObject *resultobj = NULL;
39650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39651 wxSize result;
39652 PyObject * obj0 = 0 ;
39653 char *kwnames[] = {
39654 (char *) "self", NULL
39655 };
39656
39657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39659 if (SWIG_arg_fail(1)) SWIG_fail;
39660 {
39661 PyThreadState* __tstate = wxPyBeginAllowThreads();
39662 result = (arg1)->CalcMin();
39663
39664 wxPyEndAllowThreads(__tstate);
39665 if (PyErr_Occurred()) SWIG_fail;
39666 }
39667 {
39668 wxSize * resultptr;
39669 resultptr = new wxSize(static_cast<wxSize & >(result));
39670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39671 }
39672 return resultobj;
39673 fail:
39674 return NULL;
39675 }
39676
39677
39678 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39679 PyObject *resultobj = NULL;
39680 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39681 wxPoint *arg2 = 0 ;
39682 wxSize *arg3 = 0 ;
39683 wxPoint temp2 ;
39684 wxSize temp3 ;
39685 PyObject * obj0 = 0 ;
39686 PyObject * obj1 = 0 ;
39687 PyObject * obj2 = 0 ;
39688 char *kwnames[] = {
39689 (char *) "self",(char *) "pos",(char *) "size", NULL
39690 };
39691
39692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39694 if (SWIG_arg_fail(1)) SWIG_fail;
39695 {
39696 arg2 = &temp2;
39697 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39698 }
39699 {
39700 arg3 = &temp3;
39701 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39702 }
39703 {
39704 PyThreadState* __tstate = wxPyBeginAllowThreads();
39705 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
39706
39707 wxPyEndAllowThreads(__tstate);
39708 if (PyErr_Occurred()) SWIG_fail;
39709 }
39710 Py_INCREF(Py_None); resultobj = Py_None;
39711 return resultobj;
39712 fail:
39713 return NULL;
39714 }
39715
39716
39717 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39718 PyObject *resultobj = NULL;
39719 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39720 wxSize result;
39721 PyObject * obj0 = 0 ;
39722 char *kwnames[] = {
39723 (char *) "self", NULL
39724 };
39725
39726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39728 if (SWIG_arg_fail(1)) SWIG_fail;
39729 {
39730 PyThreadState* __tstate = wxPyBeginAllowThreads();
39731 result = (arg1)->GetMinSize();
39732
39733 wxPyEndAllowThreads(__tstate);
39734 if (PyErr_Occurred()) SWIG_fail;
39735 }
39736 {
39737 wxSize * resultptr;
39738 resultptr = new wxSize(static_cast<wxSize & >(result));
39739 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39740 }
39741 return resultobj;
39742 fail:
39743 return NULL;
39744 }
39745
39746
39747 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39748 PyObject *resultobj = NULL;
39749 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39750 wxSize result;
39751 PyObject * obj0 = 0 ;
39752 char *kwnames[] = {
39753 (char *) "self", NULL
39754 };
39755
39756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39758 if (SWIG_arg_fail(1)) SWIG_fail;
39759 {
39760 PyThreadState* __tstate = wxPyBeginAllowThreads();
39761 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39762
39763 wxPyEndAllowThreads(__tstate);
39764 if (PyErr_Occurred()) SWIG_fail;
39765 }
39766 {
39767 wxSize * resultptr;
39768 resultptr = new wxSize(static_cast<wxSize & >(result));
39769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39770 }
39771 return resultobj;
39772 fail:
39773 return NULL;
39774 }
39775
39776
39777 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39778 PyObject *resultobj = NULL;
39779 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39780 int arg2 ;
39781 int arg3 ;
39782 PyObject * obj0 = 0 ;
39783 PyObject * obj1 = 0 ;
39784 PyObject * obj2 = 0 ;
39785 char *kwnames[] = {
39786 (char *) "self",(char *) "x",(char *) "y", NULL
39787 };
39788
39789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39791 if (SWIG_arg_fail(1)) SWIG_fail;
39792 {
39793 arg2 = static_cast<int >(SWIG_As_int(obj1));
39794 if (SWIG_arg_fail(2)) SWIG_fail;
39795 }
39796 {
39797 arg3 = static_cast<int >(SWIG_As_int(obj2));
39798 if (SWIG_arg_fail(3)) SWIG_fail;
39799 }
39800 {
39801 PyThreadState* __tstate = wxPyBeginAllowThreads();
39802 (arg1)->SetInitSize(arg2,arg3);
39803
39804 wxPyEndAllowThreads(__tstate);
39805 if (PyErr_Occurred()) SWIG_fail;
39806 }
39807 Py_INCREF(Py_None); resultobj = Py_None;
39808 return resultobj;
39809 fail:
39810 return NULL;
39811 }
39812
39813
39814 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39815 PyObject *resultobj = NULL;
39816 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39817 int arg2 ;
39818 int arg3 ;
39819 PyObject * obj0 = 0 ;
39820 PyObject * obj1 = 0 ;
39821 PyObject * obj2 = 0 ;
39822 char *kwnames[] = {
39823 (char *) "self",(char *) "width",(char *) "height", NULL
39824 };
39825
39826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39828 if (SWIG_arg_fail(1)) SWIG_fail;
39829 {
39830 arg2 = static_cast<int >(SWIG_As_int(obj1));
39831 if (SWIG_arg_fail(2)) SWIG_fail;
39832 }
39833 {
39834 arg3 = static_cast<int >(SWIG_As_int(obj2));
39835 if (SWIG_arg_fail(3)) SWIG_fail;
39836 }
39837 {
39838 PyThreadState* __tstate = wxPyBeginAllowThreads();
39839 (arg1)->SetRatio(arg2,arg3);
39840
39841 wxPyEndAllowThreads(__tstate);
39842 if (PyErr_Occurred()) SWIG_fail;
39843 }
39844 Py_INCREF(Py_None); resultobj = Py_None;
39845 return resultobj;
39846 fail:
39847 return NULL;
39848 }
39849
39850
39851 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39852 PyObject *resultobj = NULL;
39853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39854 wxSize *arg2 = 0 ;
39855 wxSize temp2 ;
39856 PyObject * obj0 = 0 ;
39857 PyObject * obj1 = 0 ;
39858 char *kwnames[] = {
39859 (char *) "self",(char *) "size", NULL
39860 };
39861
39862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
39867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39868 }
39869 {
39870 PyThreadState* __tstate = wxPyBeginAllowThreads();
39871 (arg1)->SetRatio((wxSize const &)*arg2);
39872
39873 wxPyEndAllowThreads(__tstate);
39874 if (PyErr_Occurred()) SWIG_fail;
39875 }
39876 Py_INCREF(Py_None); resultobj = Py_None;
39877 return resultobj;
39878 fail:
39879 return NULL;
39880 }
39881
39882
39883 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39884 PyObject *resultobj = NULL;
39885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39886 float arg2 ;
39887 PyObject * obj0 = 0 ;
39888 PyObject * obj1 = 0 ;
39889 char *kwnames[] = {
39890 (char *) "self",(char *) "ratio", NULL
39891 };
39892
39893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39895 if (SWIG_arg_fail(1)) SWIG_fail;
39896 {
39897 arg2 = static_cast<float >(SWIG_As_float(obj1));
39898 if (SWIG_arg_fail(2)) SWIG_fail;
39899 }
39900 {
39901 PyThreadState* __tstate = wxPyBeginAllowThreads();
39902 (arg1)->SetRatio(arg2);
39903
39904 wxPyEndAllowThreads(__tstate);
39905 if (PyErr_Occurred()) SWIG_fail;
39906 }
39907 Py_INCREF(Py_None); resultobj = Py_None;
39908 return resultobj;
39909 fail:
39910 return NULL;
39911 }
39912
39913
39914 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39915 PyObject *resultobj = NULL;
39916 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39917 float result;
39918 PyObject * obj0 = 0 ;
39919 char *kwnames[] = {
39920 (char *) "self", NULL
39921 };
39922
39923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39925 if (SWIG_arg_fail(1)) SWIG_fail;
39926 {
39927 PyThreadState* __tstate = wxPyBeginAllowThreads();
39928 result = (float)(arg1)->GetRatio();
39929
39930 wxPyEndAllowThreads(__tstate);
39931 if (PyErr_Occurred()) SWIG_fail;
39932 }
39933 {
39934 resultobj = SWIG_From_float(static_cast<float >(result));
39935 }
39936 return resultobj;
39937 fail:
39938 return NULL;
39939 }
39940
39941
39942 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39943 PyObject *resultobj = NULL;
39944 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39945 wxRect result;
39946 PyObject * obj0 = 0 ;
39947 char *kwnames[] = {
39948 (char *) "self", NULL
39949 };
39950
39951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39953 if (SWIG_arg_fail(1)) SWIG_fail;
39954 {
39955 PyThreadState* __tstate = wxPyBeginAllowThreads();
39956 result = (arg1)->GetRect();
39957
39958 wxPyEndAllowThreads(__tstate);
39959 if (PyErr_Occurred()) SWIG_fail;
39960 }
39961 {
39962 wxRect * resultptr;
39963 resultptr = new wxRect(static_cast<wxRect & >(result));
39964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39965 }
39966 return resultobj;
39967 fail:
39968 return NULL;
39969 }
39970
39971
39972 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39973 PyObject *resultobj = NULL;
39974 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39975 bool result;
39976 PyObject * obj0 = 0 ;
39977 char *kwnames[] = {
39978 (char *) "self", NULL
39979 };
39980
39981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39983 if (SWIG_arg_fail(1)) SWIG_fail;
39984 {
39985 PyThreadState* __tstate = wxPyBeginAllowThreads();
39986 result = (bool)(arg1)->IsWindow();
39987
39988 wxPyEndAllowThreads(__tstate);
39989 if (PyErr_Occurred()) SWIG_fail;
39990 }
39991 {
39992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39993 }
39994 return resultobj;
39995 fail:
39996 return NULL;
39997 }
39998
39999
40000 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40001 PyObject *resultobj = NULL;
40002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40003 bool result;
40004 PyObject * obj0 = 0 ;
40005 char *kwnames[] = {
40006 (char *) "self", NULL
40007 };
40008
40009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
40010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40011 if (SWIG_arg_fail(1)) SWIG_fail;
40012 {
40013 PyThreadState* __tstate = wxPyBeginAllowThreads();
40014 result = (bool)(arg1)->IsSizer();
40015
40016 wxPyEndAllowThreads(__tstate);
40017 if (PyErr_Occurred()) SWIG_fail;
40018 }
40019 {
40020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40021 }
40022 return resultobj;
40023 fail:
40024 return NULL;
40025 }
40026
40027
40028 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40029 PyObject *resultobj = NULL;
40030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40031 bool result;
40032 PyObject * obj0 = 0 ;
40033 char *kwnames[] = {
40034 (char *) "self", NULL
40035 };
40036
40037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
40042 result = (bool)(arg1)->IsSpacer();
40043
40044 wxPyEndAllowThreads(__tstate);
40045 if (PyErr_Occurred()) SWIG_fail;
40046 }
40047 {
40048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40049 }
40050 return resultobj;
40051 fail:
40052 return NULL;
40053 }
40054
40055
40056 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
40057 PyObject *resultobj = NULL;
40058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40059 int arg2 ;
40060 PyObject * obj0 = 0 ;
40061 PyObject * obj1 = 0 ;
40062 char *kwnames[] = {
40063 (char *) "self",(char *) "proportion", NULL
40064 };
40065
40066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
40067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40068 if (SWIG_arg_fail(1)) SWIG_fail;
40069 {
40070 arg2 = static_cast<int >(SWIG_As_int(obj1));
40071 if (SWIG_arg_fail(2)) SWIG_fail;
40072 }
40073 {
40074 PyThreadState* __tstate = wxPyBeginAllowThreads();
40075 (arg1)->SetProportion(arg2);
40076
40077 wxPyEndAllowThreads(__tstate);
40078 if (PyErr_Occurred()) SWIG_fail;
40079 }
40080 Py_INCREF(Py_None); resultobj = Py_None;
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = NULL;
40089 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40090 int result;
40091 PyObject * obj0 = 0 ;
40092 char *kwnames[] = {
40093 (char *) "self", NULL
40094 };
40095
40096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
40097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40098 if (SWIG_arg_fail(1)) SWIG_fail;
40099 {
40100 PyThreadState* __tstate = wxPyBeginAllowThreads();
40101 result = (int)(arg1)->GetProportion();
40102
40103 wxPyEndAllowThreads(__tstate);
40104 if (PyErr_Occurred()) SWIG_fail;
40105 }
40106 {
40107 resultobj = SWIG_From_int(static_cast<int >(result));
40108 }
40109 return resultobj;
40110 fail:
40111 return NULL;
40112 }
40113
40114
40115 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40116 PyObject *resultobj = NULL;
40117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40118 int arg2 ;
40119 PyObject * obj0 = 0 ;
40120 PyObject * obj1 = 0 ;
40121 char *kwnames[] = {
40122 (char *) "self",(char *) "flag", NULL
40123 };
40124
40125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
40126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40127 if (SWIG_arg_fail(1)) SWIG_fail;
40128 {
40129 arg2 = static_cast<int >(SWIG_As_int(obj1));
40130 if (SWIG_arg_fail(2)) SWIG_fail;
40131 }
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 (arg1)->SetFlag(arg2);
40135
40136 wxPyEndAllowThreads(__tstate);
40137 if (PyErr_Occurred()) SWIG_fail;
40138 }
40139 Py_INCREF(Py_None); resultobj = Py_None;
40140 return resultobj;
40141 fail:
40142 return NULL;
40143 }
40144
40145
40146 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40147 PyObject *resultobj = NULL;
40148 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40149 int result;
40150 PyObject * obj0 = 0 ;
40151 char *kwnames[] = {
40152 (char *) "self", NULL
40153 };
40154
40155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40157 if (SWIG_arg_fail(1)) SWIG_fail;
40158 {
40159 PyThreadState* __tstate = wxPyBeginAllowThreads();
40160 result = (int)(arg1)->GetFlag();
40161
40162 wxPyEndAllowThreads(__tstate);
40163 if (PyErr_Occurred()) SWIG_fail;
40164 }
40165 {
40166 resultobj = SWIG_From_int(static_cast<int >(result));
40167 }
40168 return resultobj;
40169 fail:
40170 return NULL;
40171 }
40172
40173
40174 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40175 PyObject *resultobj = NULL;
40176 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40177 int arg2 ;
40178 PyObject * obj0 = 0 ;
40179 PyObject * obj1 = 0 ;
40180 char *kwnames[] = {
40181 (char *) "self",(char *) "border", NULL
40182 };
40183
40184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40186 if (SWIG_arg_fail(1)) SWIG_fail;
40187 {
40188 arg2 = static_cast<int >(SWIG_As_int(obj1));
40189 if (SWIG_arg_fail(2)) SWIG_fail;
40190 }
40191 {
40192 PyThreadState* __tstate = wxPyBeginAllowThreads();
40193 (arg1)->SetBorder(arg2);
40194
40195 wxPyEndAllowThreads(__tstate);
40196 if (PyErr_Occurred()) SWIG_fail;
40197 }
40198 Py_INCREF(Py_None); resultobj = Py_None;
40199 return resultobj;
40200 fail:
40201 return NULL;
40202 }
40203
40204
40205 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40206 PyObject *resultobj = NULL;
40207 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40208 int result;
40209 PyObject * obj0 = 0 ;
40210 char *kwnames[] = {
40211 (char *) "self", NULL
40212 };
40213
40214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40216 if (SWIG_arg_fail(1)) SWIG_fail;
40217 {
40218 PyThreadState* __tstate = wxPyBeginAllowThreads();
40219 result = (int)(arg1)->GetBorder();
40220
40221 wxPyEndAllowThreads(__tstate);
40222 if (PyErr_Occurred()) SWIG_fail;
40223 }
40224 {
40225 resultobj = SWIG_From_int(static_cast<int >(result));
40226 }
40227 return resultobj;
40228 fail:
40229 return NULL;
40230 }
40231
40232
40233 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40234 PyObject *resultobj = NULL;
40235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40236 wxWindow *result;
40237 PyObject * obj0 = 0 ;
40238 char *kwnames[] = {
40239 (char *) "self", NULL
40240 };
40241
40242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40244 if (SWIG_arg_fail(1)) SWIG_fail;
40245 {
40246 PyThreadState* __tstate = wxPyBeginAllowThreads();
40247 result = (wxWindow *)(arg1)->GetWindow();
40248
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 {
40253 resultobj = wxPyMake_wxObject(result, 0);
40254 }
40255 return resultobj;
40256 fail:
40257 return NULL;
40258 }
40259
40260
40261 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40262 PyObject *resultobj = NULL;
40263 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40264 wxWindow *arg2 = (wxWindow *) 0 ;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 char *kwnames[] = {
40268 (char *) "self",(char *) "window", NULL
40269 };
40270
40271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40275 if (SWIG_arg_fail(2)) SWIG_fail;
40276 {
40277 PyThreadState* __tstate = wxPyBeginAllowThreads();
40278 (arg1)->SetWindow(arg2);
40279
40280 wxPyEndAllowThreads(__tstate);
40281 if (PyErr_Occurred()) SWIG_fail;
40282 }
40283 Py_INCREF(Py_None); resultobj = Py_None;
40284 return resultobj;
40285 fail:
40286 return NULL;
40287 }
40288
40289
40290 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40291 PyObject *resultobj = NULL;
40292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40293 wxSizer *result;
40294 PyObject * obj0 = 0 ;
40295 char *kwnames[] = {
40296 (char *) "self", NULL
40297 };
40298
40299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40301 if (SWIG_arg_fail(1)) SWIG_fail;
40302 {
40303 PyThreadState* __tstate = wxPyBeginAllowThreads();
40304 result = (wxSizer *)(arg1)->GetSizer();
40305
40306 wxPyEndAllowThreads(__tstate);
40307 if (PyErr_Occurred()) SWIG_fail;
40308 }
40309 {
40310 resultobj = wxPyMake_wxObject(result, (bool)0);
40311 }
40312 return resultobj;
40313 fail:
40314 return NULL;
40315 }
40316
40317
40318 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40319 PyObject *resultobj = NULL;
40320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40321 wxSizer *arg2 = (wxSizer *) 0 ;
40322 PyObject * obj0 = 0 ;
40323 PyObject * obj1 = 0 ;
40324 char *kwnames[] = {
40325 (char *) "self",(char *) "sizer", NULL
40326 };
40327
40328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40330 if (SWIG_arg_fail(1)) SWIG_fail;
40331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40332 if (SWIG_arg_fail(2)) SWIG_fail;
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->SetSizer(arg2);
40336
40337 wxPyEndAllowThreads(__tstate);
40338 if (PyErr_Occurred()) SWIG_fail;
40339 }
40340 Py_INCREF(Py_None); resultobj = Py_None;
40341 return resultobj;
40342 fail:
40343 return NULL;
40344 }
40345
40346
40347 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40348 PyObject *resultobj = NULL;
40349 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40350 wxSize *result;
40351 PyObject * obj0 = 0 ;
40352 char *kwnames[] = {
40353 (char *) "self", NULL
40354 };
40355
40356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40358 if (SWIG_arg_fail(1)) SWIG_fail;
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 {
40362 wxSize const &_result_ref = (arg1)->GetSpacer();
40363 result = (wxSize *) &_result_ref;
40364 }
40365
40366 wxPyEndAllowThreads(__tstate);
40367 if (PyErr_Occurred()) SWIG_fail;
40368 }
40369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40370 return resultobj;
40371 fail:
40372 return NULL;
40373 }
40374
40375
40376 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40377 PyObject *resultobj = NULL;
40378 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40379 wxSize *arg2 = 0 ;
40380 wxSize temp2 ;
40381 PyObject * obj0 = 0 ;
40382 PyObject * obj1 = 0 ;
40383 char *kwnames[] = {
40384 (char *) "self",(char *) "size", NULL
40385 };
40386
40387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40389 if (SWIG_arg_fail(1)) SWIG_fail;
40390 {
40391 arg2 = &temp2;
40392 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40393 }
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 (arg1)->SetSpacer((wxSize const &)*arg2);
40397
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 Py_INCREF(Py_None); resultobj = Py_None;
40402 return resultobj;
40403 fail:
40404 return NULL;
40405 }
40406
40407
40408 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40409 PyObject *resultobj = NULL;
40410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40411 bool arg2 ;
40412 PyObject * obj0 = 0 ;
40413 PyObject * obj1 = 0 ;
40414 char *kwnames[] = {
40415 (char *) "self",(char *) "show", NULL
40416 };
40417
40418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40420 if (SWIG_arg_fail(1)) SWIG_fail;
40421 {
40422 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40423 if (SWIG_arg_fail(2)) SWIG_fail;
40424 }
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 (arg1)->Show(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_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40440 PyObject *resultobj = NULL;
40441 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40442 bool result;
40443 PyObject * obj0 = 0 ;
40444 char *kwnames[] = {
40445 (char *) "self", NULL
40446 };
40447
40448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40450 if (SWIG_arg_fail(1)) SWIG_fail;
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 result = (bool)(arg1)->IsShown();
40454
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 {
40459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40460 }
40461 return resultobj;
40462 fail:
40463 return NULL;
40464 }
40465
40466
40467 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40468 PyObject *resultobj = NULL;
40469 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40470 wxPoint result;
40471 PyObject * obj0 = 0 ;
40472 char *kwnames[] = {
40473 (char *) "self", NULL
40474 };
40475
40476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40478 if (SWIG_arg_fail(1)) SWIG_fail;
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 result = (arg1)->GetPosition();
40482
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 wxPoint * resultptr;
40488 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40489 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40490 }
40491 return resultobj;
40492 fail:
40493 return NULL;
40494 }
40495
40496
40497 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj = NULL;
40499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40500 PyObject *result;
40501 PyObject * obj0 = 0 ;
40502 char *kwnames[] = {
40503 (char *) "self", NULL
40504 };
40505
40506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40508 if (SWIG_arg_fail(1)) SWIG_fail;
40509 {
40510 PyThreadState* __tstate = wxPyBeginAllowThreads();
40511 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40512
40513 wxPyEndAllowThreads(__tstate);
40514 if (PyErr_Occurred()) SWIG_fail;
40515 }
40516 resultobj = result;
40517 return resultobj;
40518 fail:
40519 return NULL;
40520 }
40521
40522
40523 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40524 PyObject *resultobj = NULL;
40525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40526 PyObject *arg2 = (PyObject *) 0 ;
40527 PyObject * obj0 = 0 ;
40528 PyObject * obj1 = 0 ;
40529 char *kwnames[] = {
40530 (char *) "self",(char *) "userData", NULL
40531 };
40532
40533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40535 if (SWIG_arg_fail(1)) SWIG_fail;
40536 arg2 = obj1;
40537 {
40538 PyThreadState* __tstate = wxPyBeginAllowThreads();
40539 wxSizerItem_SetUserData(arg1,arg2);
40540
40541 wxPyEndAllowThreads(__tstate);
40542 if (PyErr_Occurred()) SWIG_fail;
40543 }
40544 Py_INCREF(Py_None); resultobj = Py_None;
40545 return resultobj;
40546 fail:
40547 return NULL;
40548 }
40549
40550
40551 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40552 PyObject *obj;
40553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40554 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40555 Py_INCREF(obj);
40556 return Py_BuildValue((char *)"");
40557 }
40558 static PyObject *_wrap_delete_Sizer(PyObject *, PyObject *args, PyObject *kwargs) {
40559 PyObject *resultobj = NULL;
40560 wxSizer *arg1 = (wxSizer *) 0 ;
40561 PyObject * obj0 = 0 ;
40562 char *kwnames[] = {
40563 (char *) "self", NULL
40564 };
40565
40566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sizer",kwnames,&obj0)) goto fail;
40567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40568 if (SWIG_arg_fail(1)) SWIG_fail;
40569 {
40570 PyThreadState* __tstate = wxPyBeginAllowThreads();
40571 delete arg1;
40572
40573 wxPyEndAllowThreads(__tstate);
40574 if (PyErr_Occurred()) SWIG_fail;
40575 }
40576 Py_INCREF(Py_None); resultobj = Py_None;
40577 return resultobj;
40578 fail:
40579 return NULL;
40580 }
40581
40582
40583 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40584 PyObject *resultobj = NULL;
40585 wxSizer *arg1 = (wxSizer *) 0 ;
40586 PyObject *arg2 = (PyObject *) 0 ;
40587 PyObject * obj0 = 0 ;
40588 PyObject * obj1 = 0 ;
40589 char *kwnames[] = {
40590 (char *) "self",(char *) "_self", NULL
40591 };
40592
40593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40595 if (SWIG_arg_fail(1)) SWIG_fail;
40596 arg2 = obj1;
40597 {
40598 PyThreadState* __tstate = wxPyBeginAllowThreads();
40599 wxSizer__setOORInfo(arg1,arg2);
40600
40601 wxPyEndAllowThreads(__tstate);
40602 if (PyErr_Occurred()) SWIG_fail;
40603 }
40604 Py_INCREF(Py_None); resultobj = Py_None;
40605 return resultobj;
40606 fail:
40607 return NULL;
40608 }
40609
40610
40611 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40612 PyObject *resultobj = NULL;
40613 wxSizer *arg1 = (wxSizer *) 0 ;
40614 PyObject *arg2 = (PyObject *) 0 ;
40615 int arg3 = (int) 0 ;
40616 int arg4 = (int) 0 ;
40617 int arg5 = (int) 0 ;
40618 PyObject *arg6 = (PyObject *) NULL ;
40619 wxSizerItem *result;
40620 PyObject * obj0 = 0 ;
40621 PyObject * obj1 = 0 ;
40622 PyObject * obj2 = 0 ;
40623 PyObject * obj3 = 0 ;
40624 PyObject * obj4 = 0 ;
40625 PyObject * obj5 = 0 ;
40626 char *kwnames[] = {
40627 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40628 };
40629
40630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 if (obj2) {
40635 {
40636 arg3 = static_cast<int >(SWIG_As_int(obj2));
40637 if (SWIG_arg_fail(3)) SWIG_fail;
40638 }
40639 }
40640 if (obj3) {
40641 {
40642 arg4 = static_cast<int >(SWIG_As_int(obj3));
40643 if (SWIG_arg_fail(4)) SWIG_fail;
40644 }
40645 }
40646 if (obj4) {
40647 {
40648 arg5 = static_cast<int >(SWIG_As_int(obj4));
40649 if (SWIG_arg_fail(5)) SWIG_fail;
40650 }
40651 }
40652 if (obj5) {
40653 arg6 = obj5;
40654 }
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40658
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40670 PyObject *resultobj = NULL;
40671 wxSizer *arg1 = (wxSizer *) 0 ;
40672 int arg2 ;
40673 PyObject *arg3 = (PyObject *) 0 ;
40674 int arg4 = (int) 0 ;
40675 int arg5 = (int) 0 ;
40676 int arg6 = (int) 0 ;
40677 PyObject *arg7 = (PyObject *) NULL ;
40678 wxSizerItem *result;
40679 PyObject * obj0 = 0 ;
40680 PyObject * obj1 = 0 ;
40681 PyObject * obj2 = 0 ;
40682 PyObject * obj3 = 0 ;
40683 PyObject * obj4 = 0 ;
40684 PyObject * obj5 = 0 ;
40685 PyObject * obj6 = 0 ;
40686 char *kwnames[] = {
40687 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40688 };
40689
40690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40692 if (SWIG_arg_fail(1)) SWIG_fail;
40693 {
40694 arg2 = static_cast<int >(SWIG_As_int(obj1));
40695 if (SWIG_arg_fail(2)) SWIG_fail;
40696 }
40697 arg3 = obj2;
40698 if (obj3) {
40699 {
40700 arg4 = static_cast<int >(SWIG_As_int(obj3));
40701 if (SWIG_arg_fail(4)) SWIG_fail;
40702 }
40703 }
40704 if (obj4) {
40705 {
40706 arg5 = static_cast<int >(SWIG_As_int(obj4));
40707 if (SWIG_arg_fail(5)) SWIG_fail;
40708 }
40709 }
40710 if (obj5) {
40711 {
40712 arg6 = static_cast<int >(SWIG_As_int(obj5));
40713 if (SWIG_arg_fail(6)) SWIG_fail;
40714 }
40715 }
40716 if (obj6) {
40717 arg7 = obj6;
40718 }
40719 {
40720 PyThreadState* __tstate = wxPyBeginAllowThreads();
40721 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40722
40723 wxPyEndAllowThreads(__tstate);
40724 if (PyErr_Occurred()) SWIG_fail;
40725 }
40726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40727 return resultobj;
40728 fail:
40729 return NULL;
40730 }
40731
40732
40733 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40734 PyObject *resultobj = NULL;
40735 wxSizer *arg1 = (wxSizer *) 0 ;
40736 PyObject *arg2 = (PyObject *) 0 ;
40737 int arg3 = (int) 0 ;
40738 int arg4 = (int) 0 ;
40739 int arg5 = (int) 0 ;
40740 PyObject *arg6 = (PyObject *) NULL ;
40741 wxSizerItem *result;
40742 PyObject * obj0 = 0 ;
40743 PyObject * obj1 = 0 ;
40744 PyObject * obj2 = 0 ;
40745 PyObject * obj3 = 0 ;
40746 PyObject * obj4 = 0 ;
40747 PyObject * obj5 = 0 ;
40748 char *kwnames[] = {
40749 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40750 };
40751
40752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40754 if (SWIG_arg_fail(1)) SWIG_fail;
40755 arg2 = obj1;
40756 if (obj2) {
40757 {
40758 arg3 = static_cast<int >(SWIG_As_int(obj2));
40759 if (SWIG_arg_fail(3)) SWIG_fail;
40760 }
40761 }
40762 if (obj3) {
40763 {
40764 arg4 = static_cast<int >(SWIG_As_int(obj3));
40765 if (SWIG_arg_fail(4)) SWIG_fail;
40766 }
40767 }
40768 if (obj4) {
40769 {
40770 arg5 = static_cast<int >(SWIG_As_int(obj4));
40771 if (SWIG_arg_fail(5)) SWIG_fail;
40772 }
40773 }
40774 if (obj5) {
40775 arg6 = obj5;
40776 }
40777 {
40778 PyThreadState* __tstate = wxPyBeginAllowThreads();
40779 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40780
40781 wxPyEndAllowThreads(__tstate);
40782 if (PyErr_Occurred()) SWIG_fail;
40783 }
40784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40785 return resultobj;
40786 fail:
40787 return NULL;
40788 }
40789
40790
40791 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40792 PyObject *resultobj = NULL;
40793 wxSizer *arg1 = (wxSizer *) 0 ;
40794 PyObject *arg2 = (PyObject *) 0 ;
40795 bool result;
40796 PyObject * obj0 = 0 ;
40797 PyObject * obj1 = 0 ;
40798 char *kwnames[] = {
40799 (char *) "self",(char *) "item", NULL
40800 };
40801
40802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40804 if (SWIG_arg_fail(1)) SWIG_fail;
40805 arg2 = obj1;
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 result = (bool)wxSizer_Remove(arg1,arg2);
40809
40810 wxPyEndAllowThreads(__tstate);
40811 if (PyErr_Occurred()) SWIG_fail;
40812 }
40813 {
40814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40815 }
40816 return resultobj;
40817 fail:
40818 return NULL;
40819 }
40820
40821
40822 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40823 PyObject *resultobj = NULL;
40824 wxSizer *arg1 = (wxSizer *) 0 ;
40825 PyObject *arg2 = (PyObject *) 0 ;
40826 bool result;
40827 PyObject * obj0 = 0 ;
40828 PyObject * obj1 = 0 ;
40829 char *kwnames[] = {
40830 (char *) "self",(char *) "item", NULL
40831 };
40832
40833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40835 if (SWIG_arg_fail(1)) SWIG_fail;
40836 arg2 = obj1;
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 result = (bool)wxSizer_Detach(arg1,arg2);
40840
40841 wxPyEndAllowThreads(__tstate);
40842 if (PyErr_Occurred()) SWIG_fail;
40843 }
40844 {
40845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40846 }
40847 return resultobj;
40848 fail:
40849 return NULL;
40850 }
40851
40852
40853 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40854 PyObject *resultobj = NULL;
40855 wxSizer *arg1 = (wxSizer *) 0 ;
40856 PyObject *arg2 = (PyObject *) 0 ;
40857 wxSizerItem *result;
40858 PyObject * obj0 = 0 ;
40859 PyObject * obj1 = 0 ;
40860 char *kwnames[] = {
40861 (char *) "self",(char *) "item", NULL
40862 };
40863
40864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40866 if (SWIG_arg_fail(1)) SWIG_fail;
40867 arg2 = obj1;
40868 {
40869 PyThreadState* __tstate = wxPyBeginAllowThreads();
40870 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40871
40872 wxPyEndAllowThreads(__tstate);
40873 if (PyErr_Occurred()) SWIG_fail;
40874 }
40875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40876 return resultobj;
40877 fail:
40878 return NULL;
40879 }
40880
40881
40882 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40883 PyObject *resultobj = NULL;
40884 wxSizer *arg1 = (wxSizer *) 0 ;
40885 PyObject *arg2 = (PyObject *) 0 ;
40886 wxSize *arg3 = 0 ;
40887 wxSize temp3 ;
40888 PyObject * obj0 = 0 ;
40889 PyObject * obj1 = 0 ;
40890 PyObject * obj2 = 0 ;
40891 char *kwnames[] = {
40892 (char *) "self",(char *) "item",(char *) "size", NULL
40893 };
40894
40895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40897 if (SWIG_arg_fail(1)) SWIG_fail;
40898 arg2 = obj1;
40899 {
40900 arg3 = &temp3;
40901 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40902 }
40903 {
40904 PyThreadState* __tstate = wxPyBeginAllowThreads();
40905 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40906
40907 wxPyEndAllowThreads(__tstate);
40908 if (PyErr_Occurred()) SWIG_fail;
40909 }
40910 Py_INCREF(Py_None); resultobj = Py_None;
40911 return resultobj;
40912 fail:
40913 return NULL;
40914 }
40915
40916
40917 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40918 PyObject *resultobj = NULL;
40919 wxSizer *arg1 = (wxSizer *) 0 ;
40920 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40921 wxSizerItem *result;
40922 PyObject * obj0 = 0 ;
40923 PyObject * obj1 = 0 ;
40924 char *kwnames[] = {
40925 (char *) "self",(char *) "item", NULL
40926 };
40927
40928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40930 if (SWIG_arg_fail(1)) SWIG_fail;
40931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40932 if (SWIG_arg_fail(2)) SWIG_fail;
40933 {
40934 PyThreadState* __tstate = wxPyBeginAllowThreads();
40935 result = (wxSizerItem *)(arg1)->Add(arg2);
40936
40937 wxPyEndAllowThreads(__tstate);
40938 if (PyErr_Occurred()) SWIG_fail;
40939 }
40940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40941 return resultobj;
40942 fail:
40943 return NULL;
40944 }
40945
40946
40947 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40948 PyObject *resultobj = NULL;
40949 wxSizer *arg1 = (wxSizer *) 0 ;
40950 size_t arg2 ;
40951 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40952 wxSizerItem *result;
40953 PyObject * obj0 = 0 ;
40954 PyObject * obj1 = 0 ;
40955 PyObject * obj2 = 0 ;
40956 char *kwnames[] = {
40957 (char *) "self",(char *) "index",(char *) "item", NULL
40958 };
40959
40960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40962 if (SWIG_arg_fail(1)) SWIG_fail;
40963 {
40964 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40965 if (SWIG_arg_fail(2)) SWIG_fail;
40966 }
40967 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40968 if (SWIG_arg_fail(3)) SWIG_fail;
40969 {
40970 PyThreadState* __tstate = wxPyBeginAllowThreads();
40971 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40972
40973 wxPyEndAllowThreads(__tstate);
40974 if (PyErr_Occurred()) SWIG_fail;
40975 }
40976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40977 return resultobj;
40978 fail:
40979 return NULL;
40980 }
40981
40982
40983 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40984 PyObject *resultobj = NULL;
40985 wxSizer *arg1 = (wxSizer *) 0 ;
40986 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40987 wxSizerItem *result;
40988 PyObject * obj0 = 0 ;
40989 PyObject * obj1 = 0 ;
40990 char *kwnames[] = {
40991 (char *) "self",(char *) "item", NULL
40992 };
40993
40994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40996 if (SWIG_arg_fail(1)) SWIG_fail;
40997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40998 if (SWIG_arg_fail(2)) SWIG_fail;
40999 {
41000 PyThreadState* __tstate = wxPyBeginAllowThreads();
41001 result = (wxSizerItem *)(arg1)->Prepend(arg2);
41002
41003 wxPyEndAllowThreads(__tstate);
41004 if (PyErr_Occurred()) SWIG_fail;
41005 }
41006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
41007 return resultobj;
41008 fail:
41009 return NULL;
41010 }
41011
41012
41013 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
41014 PyObject *resultobj = NULL;
41015 wxSizer *arg1 = (wxSizer *) 0 ;
41016 int arg2 ;
41017 int arg3 ;
41018 int arg4 ;
41019 int arg5 ;
41020 PyObject * obj0 = 0 ;
41021 PyObject * obj1 = 0 ;
41022 PyObject * obj2 = 0 ;
41023 PyObject * obj3 = 0 ;
41024 PyObject * obj4 = 0 ;
41025 char *kwnames[] = {
41026 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
41027 };
41028
41029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
41030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41031 if (SWIG_arg_fail(1)) SWIG_fail;
41032 {
41033 arg2 = static_cast<int >(SWIG_As_int(obj1));
41034 if (SWIG_arg_fail(2)) SWIG_fail;
41035 }
41036 {
41037 arg3 = static_cast<int >(SWIG_As_int(obj2));
41038 if (SWIG_arg_fail(3)) SWIG_fail;
41039 }
41040 {
41041 arg4 = static_cast<int >(SWIG_As_int(obj3));
41042 if (SWIG_arg_fail(4)) SWIG_fail;
41043 }
41044 {
41045 arg5 = static_cast<int >(SWIG_As_int(obj4));
41046 if (SWIG_arg_fail(5)) SWIG_fail;
41047 }
41048 {
41049 PyThreadState* __tstate = wxPyBeginAllowThreads();
41050 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
41051
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 Py_INCREF(Py_None); resultobj = Py_None;
41056 return resultobj;
41057 fail:
41058 return NULL;
41059 }
41060
41061
41062 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41063 PyObject *resultobj = NULL;
41064 wxSizer *arg1 = (wxSizer *) 0 ;
41065 wxSize *arg2 = 0 ;
41066 wxSize temp2 ;
41067 PyObject * obj0 = 0 ;
41068 PyObject * obj1 = 0 ;
41069 char *kwnames[] = {
41070 (char *) "self",(char *) "size", NULL
41071 };
41072
41073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
41074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41075 if (SWIG_arg_fail(1)) SWIG_fail;
41076 {
41077 arg2 = &temp2;
41078 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41079 }
41080 {
41081 PyThreadState* __tstate = wxPyBeginAllowThreads();
41082 (arg1)->SetMinSize((wxSize const &)*arg2);
41083
41084 wxPyEndAllowThreads(__tstate);
41085 if (PyErr_Occurred()) SWIG_fail;
41086 }
41087 Py_INCREF(Py_None); resultobj = Py_None;
41088 return resultobj;
41089 fail:
41090 return NULL;
41091 }
41092
41093
41094 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
41095 PyObject *resultobj = NULL;
41096 wxSizer *arg1 = (wxSizer *) 0 ;
41097 wxSize result;
41098 PyObject * obj0 = 0 ;
41099 char *kwnames[] = {
41100 (char *) "self", NULL
41101 };
41102
41103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) 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 {
41107 PyThreadState* __tstate = wxPyBeginAllowThreads();
41108 result = (arg1)->GetSize();
41109
41110 wxPyEndAllowThreads(__tstate);
41111 if (PyErr_Occurred()) SWIG_fail;
41112 }
41113 {
41114 wxSize * resultptr;
41115 resultptr = new wxSize(static_cast<wxSize & >(result));
41116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41117 }
41118 return resultobj;
41119 fail:
41120 return NULL;
41121 }
41122
41123
41124 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41125 PyObject *resultobj = NULL;
41126 wxSizer *arg1 = (wxSizer *) 0 ;
41127 wxPoint result;
41128 PyObject * obj0 = 0 ;
41129 char *kwnames[] = {
41130 (char *) "self", NULL
41131 };
41132
41133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
41134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41135 if (SWIG_arg_fail(1)) SWIG_fail;
41136 {
41137 PyThreadState* __tstate = wxPyBeginAllowThreads();
41138 result = (arg1)->GetPosition();
41139
41140 wxPyEndAllowThreads(__tstate);
41141 if (PyErr_Occurred()) SWIG_fail;
41142 }
41143 {
41144 wxPoint * resultptr;
41145 resultptr = new wxPoint(static_cast<wxPoint & >(result));
41146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
41147 }
41148 return resultobj;
41149 fail:
41150 return NULL;
41151 }
41152
41153
41154 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41155 PyObject *resultobj = NULL;
41156 wxSizer *arg1 = (wxSizer *) 0 ;
41157 wxSize result;
41158 PyObject * obj0 = 0 ;
41159 char *kwnames[] = {
41160 (char *) "self", NULL
41161 };
41162
41163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
41164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41165 if (SWIG_arg_fail(1)) SWIG_fail;
41166 {
41167 PyThreadState* __tstate = wxPyBeginAllowThreads();
41168 result = (arg1)->GetMinSize();
41169
41170 wxPyEndAllowThreads(__tstate);
41171 if (PyErr_Occurred()) SWIG_fail;
41172 }
41173 {
41174 wxSize * resultptr;
41175 resultptr = new wxSize(static_cast<wxSize & >(result));
41176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41177 }
41178 return resultobj;
41179 fail:
41180 return NULL;
41181 }
41182
41183
41184 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41185 PyObject *resultobj = NULL;
41186 wxSizer *arg1 = (wxSizer *) 0 ;
41187 PyObject * obj0 = 0 ;
41188 char *kwnames[] = {
41189 (char *) "self", NULL
41190 };
41191
41192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41194 if (SWIG_arg_fail(1)) SWIG_fail;
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 (arg1)->RecalcSizes();
41198
41199 wxPyEndAllowThreads(__tstate);
41200 if (PyErr_Occurred()) SWIG_fail;
41201 }
41202 Py_INCREF(Py_None); resultobj = Py_None;
41203 return resultobj;
41204 fail:
41205 return NULL;
41206 }
41207
41208
41209 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41210 PyObject *resultobj = NULL;
41211 wxSizer *arg1 = (wxSizer *) 0 ;
41212 wxSize result;
41213 PyObject * obj0 = 0 ;
41214 char *kwnames[] = {
41215 (char *) "self", NULL
41216 };
41217
41218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41220 if (SWIG_arg_fail(1)) SWIG_fail;
41221 {
41222 PyThreadState* __tstate = wxPyBeginAllowThreads();
41223 result = (arg1)->CalcMin();
41224
41225 wxPyEndAllowThreads(__tstate);
41226 if (PyErr_Occurred()) SWIG_fail;
41227 }
41228 {
41229 wxSize * resultptr;
41230 resultptr = new wxSize(static_cast<wxSize & >(result));
41231 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41232 }
41233 return resultobj;
41234 fail:
41235 return NULL;
41236 }
41237
41238
41239 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41240 PyObject *resultobj = NULL;
41241 wxSizer *arg1 = (wxSizer *) 0 ;
41242 PyObject * obj0 = 0 ;
41243 char *kwnames[] = {
41244 (char *) "self", NULL
41245 };
41246
41247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41249 if (SWIG_arg_fail(1)) SWIG_fail;
41250 {
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 (arg1)->Layout();
41253
41254 wxPyEndAllowThreads(__tstate);
41255 if (PyErr_Occurred()) SWIG_fail;
41256 }
41257 Py_INCREF(Py_None); resultobj = Py_None;
41258 return resultobj;
41259 fail:
41260 return NULL;
41261 }
41262
41263
41264 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj = NULL;
41266 wxSizer *arg1 = (wxSizer *) 0 ;
41267 wxWindow *arg2 = (wxWindow *) 0 ;
41268 wxSize result;
41269 PyObject * obj0 = 0 ;
41270 PyObject * obj1 = 0 ;
41271 char *kwnames[] = {
41272 (char *) "self",(char *) "window", NULL
41273 };
41274
41275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41277 if (SWIG_arg_fail(1)) SWIG_fail;
41278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41279 if (SWIG_arg_fail(2)) SWIG_fail;
41280 {
41281 PyThreadState* __tstate = wxPyBeginAllowThreads();
41282 result = (arg1)->Fit(arg2);
41283
41284 wxPyEndAllowThreads(__tstate);
41285 if (PyErr_Occurred()) SWIG_fail;
41286 }
41287 {
41288 wxSize * resultptr;
41289 resultptr = new wxSize(static_cast<wxSize & >(result));
41290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41291 }
41292 return resultobj;
41293 fail:
41294 return NULL;
41295 }
41296
41297
41298 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41299 PyObject *resultobj = NULL;
41300 wxSizer *arg1 = (wxSizer *) 0 ;
41301 wxWindow *arg2 = (wxWindow *) 0 ;
41302 PyObject * obj0 = 0 ;
41303 PyObject * obj1 = 0 ;
41304 char *kwnames[] = {
41305 (char *) "self",(char *) "window", NULL
41306 };
41307
41308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41310 if (SWIG_arg_fail(1)) SWIG_fail;
41311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41312 if (SWIG_arg_fail(2)) SWIG_fail;
41313 {
41314 PyThreadState* __tstate = wxPyBeginAllowThreads();
41315 (arg1)->FitInside(arg2);
41316
41317 wxPyEndAllowThreads(__tstate);
41318 if (PyErr_Occurred()) SWIG_fail;
41319 }
41320 Py_INCREF(Py_None); resultobj = Py_None;
41321 return resultobj;
41322 fail:
41323 return NULL;
41324 }
41325
41326
41327 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41328 PyObject *resultobj = NULL;
41329 wxSizer *arg1 = (wxSizer *) 0 ;
41330 wxWindow *arg2 = (wxWindow *) 0 ;
41331 PyObject * obj0 = 0 ;
41332 PyObject * obj1 = 0 ;
41333 char *kwnames[] = {
41334 (char *) "self",(char *) "window", NULL
41335 };
41336
41337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41339 if (SWIG_arg_fail(1)) SWIG_fail;
41340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41341 if (SWIG_arg_fail(2)) SWIG_fail;
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 (arg1)->SetSizeHints(arg2);
41345
41346 wxPyEndAllowThreads(__tstate);
41347 if (PyErr_Occurred()) SWIG_fail;
41348 }
41349 Py_INCREF(Py_None); resultobj = Py_None;
41350 return resultobj;
41351 fail:
41352 return NULL;
41353 }
41354
41355
41356 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41357 PyObject *resultobj = NULL;
41358 wxSizer *arg1 = (wxSizer *) 0 ;
41359 wxWindow *arg2 = (wxWindow *) 0 ;
41360 PyObject * obj0 = 0 ;
41361 PyObject * obj1 = 0 ;
41362 char *kwnames[] = {
41363 (char *) "self",(char *) "window", NULL
41364 };
41365
41366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41368 if (SWIG_arg_fail(1)) SWIG_fail;
41369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41370 if (SWIG_arg_fail(2)) SWIG_fail;
41371 {
41372 PyThreadState* __tstate = wxPyBeginAllowThreads();
41373 (arg1)->SetVirtualSizeHints(arg2);
41374
41375 wxPyEndAllowThreads(__tstate);
41376 if (PyErr_Occurred()) SWIG_fail;
41377 }
41378 Py_INCREF(Py_None); resultobj = Py_None;
41379 return resultobj;
41380 fail:
41381 return NULL;
41382 }
41383
41384
41385 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41386 PyObject *resultobj = NULL;
41387 wxSizer *arg1 = (wxSizer *) 0 ;
41388 bool arg2 = (bool) false ;
41389 PyObject * obj0 = 0 ;
41390 PyObject * obj1 = 0 ;
41391 char *kwnames[] = {
41392 (char *) "self",(char *) "deleteWindows", NULL
41393 };
41394
41395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41397 if (SWIG_arg_fail(1)) SWIG_fail;
41398 if (obj1) {
41399 {
41400 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41401 if (SWIG_arg_fail(2)) SWIG_fail;
41402 }
41403 }
41404 {
41405 PyThreadState* __tstate = wxPyBeginAllowThreads();
41406 (arg1)->Clear(arg2);
41407
41408 wxPyEndAllowThreads(__tstate);
41409 if (PyErr_Occurred()) SWIG_fail;
41410 }
41411 Py_INCREF(Py_None); resultobj = Py_None;
41412 return resultobj;
41413 fail:
41414 return NULL;
41415 }
41416
41417
41418 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj = NULL;
41420 wxSizer *arg1 = (wxSizer *) 0 ;
41421 PyObject * obj0 = 0 ;
41422 char *kwnames[] = {
41423 (char *) "self", NULL
41424 };
41425
41426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41428 if (SWIG_arg_fail(1)) SWIG_fail;
41429 {
41430 PyThreadState* __tstate = wxPyBeginAllowThreads();
41431 (arg1)->DeleteWindows();
41432
41433 wxPyEndAllowThreads(__tstate);
41434 if (PyErr_Occurred()) SWIG_fail;
41435 }
41436 Py_INCREF(Py_None); resultobj = Py_None;
41437 return resultobj;
41438 fail:
41439 return NULL;
41440 }
41441
41442
41443 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41444 PyObject *resultobj = NULL;
41445 wxSizer *arg1 = (wxSizer *) 0 ;
41446 PyObject *result;
41447 PyObject * obj0 = 0 ;
41448 char *kwnames[] = {
41449 (char *) "self", NULL
41450 };
41451
41452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41454 if (SWIG_arg_fail(1)) SWIG_fail;
41455 {
41456 PyThreadState* __tstate = wxPyBeginAllowThreads();
41457 result = (PyObject *)wxSizer_GetChildren(arg1);
41458
41459 wxPyEndAllowThreads(__tstate);
41460 if (PyErr_Occurred()) SWIG_fail;
41461 }
41462 resultobj = result;
41463 return resultobj;
41464 fail:
41465 return NULL;
41466 }
41467
41468
41469 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41470 PyObject *resultobj = NULL;
41471 wxSizer *arg1 = (wxSizer *) 0 ;
41472 PyObject *arg2 = (PyObject *) 0 ;
41473 bool arg3 = (bool) true ;
41474 bool arg4 = (bool) false ;
41475 bool result;
41476 PyObject * obj0 = 0 ;
41477 PyObject * obj1 = 0 ;
41478 PyObject * obj2 = 0 ;
41479 PyObject * obj3 = 0 ;
41480 char *kwnames[] = {
41481 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41482 };
41483
41484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41486 if (SWIG_arg_fail(1)) SWIG_fail;
41487 arg2 = obj1;
41488 if (obj2) {
41489 {
41490 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41491 if (SWIG_arg_fail(3)) SWIG_fail;
41492 }
41493 }
41494 if (obj3) {
41495 {
41496 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41497 if (SWIG_arg_fail(4)) SWIG_fail;
41498 }
41499 }
41500 {
41501 PyThreadState* __tstate = wxPyBeginAllowThreads();
41502 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41503
41504 wxPyEndAllowThreads(__tstate);
41505 if (PyErr_Occurred()) SWIG_fail;
41506 }
41507 {
41508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41509 }
41510 return resultobj;
41511 fail:
41512 return NULL;
41513 }
41514
41515
41516 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41517 PyObject *resultobj = NULL;
41518 wxSizer *arg1 = (wxSizer *) 0 ;
41519 PyObject *arg2 = (PyObject *) 0 ;
41520 bool result;
41521 PyObject * obj0 = 0 ;
41522 PyObject * obj1 = 0 ;
41523 char *kwnames[] = {
41524 (char *) "self",(char *) "item", NULL
41525 };
41526
41527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41529 if (SWIG_arg_fail(1)) SWIG_fail;
41530 arg2 = obj1;
41531 {
41532 PyThreadState* __tstate = wxPyBeginAllowThreads();
41533 result = (bool)wxSizer_IsShown(arg1,arg2);
41534
41535 wxPyEndAllowThreads(__tstate);
41536 if (PyErr_Occurred()) SWIG_fail;
41537 }
41538 {
41539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41540 }
41541 return resultobj;
41542 fail:
41543 return NULL;
41544 }
41545
41546
41547 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41548 PyObject *resultobj = NULL;
41549 wxSizer *arg1 = (wxSizer *) 0 ;
41550 bool arg2 ;
41551 PyObject * obj0 = 0 ;
41552 PyObject * obj1 = 0 ;
41553 char *kwnames[] = {
41554 (char *) "self",(char *) "show", NULL
41555 };
41556
41557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41559 if (SWIG_arg_fail(1)) SWIG_fail;
41560 {
41561 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41562 if (SWIG_arg_fail(2)) SWIG_fail;
41563 }
41564 {
41565 PyThreadState* __tstate = wxPyBeginAllowThreads();
41566 (arg1)->ShowItems(arg2);
41567
41568 wxPyEndAllowThreads(__tstate);
41569 if (PyErr_Occurred()) SWIG_fail;
41570 }
41571 Py_INCREF(Py_None); resultobj = Py_None;
41572 return resultobj;
41573 fail:
41574 return NULL;
41575 }
41576
41577
41578 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41579 PyObject *obj;
41580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41581 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41582 Py_INCREF(obj);
41583 return Py_BuildValue((char *)"");
41584 }
41585 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41586 PyObject *resultobj = NULL;
41587 wxPySizer *result;
41588 char *kwnames[] = {
41589 NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41593 {
41594 PyThreadState* __tstate = wxPyBeginAllowThreads();
41595 result = (wxPySizer *)new wxPySizer();
41596
41597 wxPyEndAllowThreads(__tstate);
41598 if (PyErr_Occurred()) SWIG_fail;
41599 }
41600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41601 return resultobj;
41602 fail:
41603 return NULL;
41604 }
41605
41606
41607 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41608 PyObject *resultobj = NULL;
41609 wxPySizer *arg1 = (wxPySizer *) 0 ;
41610 PyObject *arg2 = (PyObject *) 0 ;
41611 PyObject *arg3 = (PyObject *) 0 ;
41612 PyObject * obj0 = 0 ;
41613 PyObject * obj1 = 0 ;
41614 PyObject * obj2 = 0 ;
41615 char *kwnames[] = {
41616 (char *) "self",(char *) "self",(char *) "_class", NULL
41617 };
41618
41619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41621 if (SWIG_arg_fail(1)) SWIG_fail;
41622 arg2 = obj1;
41623 arg3 = obj2;
41624 {
41625 PyThreadState* __tstate = wxPyBeginAllowThreads();
41626 (arg1)->_setCallbackInfo(arg2,arg3);
41627
41628 wxPyEndAllowThreads(__tstate);
41629 if (PyErr_Occurred()) SWIG_fail;
41630 }
41631 Py_INCREF(Py_None); resultobj = Py_None;
41632 return resultobj;
41633 fail:
41634 return NULL;
41635 }
41636
41637
41638 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41639 PyObject *obj;
41640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41641 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41642 Py_INCREF(obj);
41643 return Py_BuildValue((char *)"");
41644 }
41645 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41646 PyObject *resultobj = NULL;
41647 int arg1 = (int) wxHORIZONTAL ;
41648 wxBoxSizer *result;
41649 PyObject * obj0 = 0 ;
41650 char *kwnames[] = {
41651 (char *) "orient", NULL
41652 };
41653
41654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41655 if (obj0) {
41656 {
41657 arg1 = static_cast<int >(SWIG_As_int(obj0));
41658 if (SWIG_arg_fail(1)) SWIG_fail;
41659 }
41660 }
41661 {
41662 PyThreadState* __tstate = wxPyBeginAllowThreads();
41663 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41664
41665 wxPyEndAllowThreads(__tstate);
41666 if (PyErr_Occurred()) SWIG_fail;
41667 }
41668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41669 return resultobj;
41670 fail:
41671 return NULL;
41672 }
41673
41674
41675 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41676 PyObject *resultobj = NULL;
41677 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41678 int result;
41679 PyObject * obj0 = 0 ;
41680 char *kwnames[] = {
41681 (char *) "self", NULL
41682 };
41683
41684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41686 if (SWIG_arg_fail(1)) SWIG_fail;
41687 {
41688 PyThreadState* __tstate = wxPyBeginAllowThreads();
41689 result = (int)(arg1)->GetOrientation();
41690
41691 wxPyEndAllowThreads(__tstate);
41692 if (PyErr_Occurred()) SWIG_fail;
41693 }
41694 {
41695 resultobj = SWIG_From_int(static_cast<int >(result));
41696 }
41697 return resultobj;
41698 fail:
41699 return NULL;
41700 }
41701
41702
41703 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41704 PyObject *resultobj = NULL;
41705 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41706 int arg2 ;
41707 PyObject * obj0 = 0 ;
41708 PyObject * obj1 = 0 ;
41709 char *kwnames[] = {
41710 (char *) "self",(char *) "orient", NULL
41711 };
41712
41713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41715 if (SWIG_arg_fail(1)) SWIG_fail;
41716 {
41717 arg2 = static_cast<int >(SWIG_As_int(obj1));
41718 if (SWIG_arg_fail(2)) SWIG_fail;
41719 }
41720 {
41721 PyThreadState* __tstate = wxPyBeginAllowThreads();
41722 (arg1)->SetOrientation(arg2);
41723
41724 wxPyEndAllowThreads(__tstate);
41725 if (PyErr_Occurred()) SWIG_fail;
41726 }
41727 Py_INCREF(Py_None); resultobj = Py_None;
41728 return resultobj;
41729 fail:
41730 return NULL;
41731 }
41732
41733
41734 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41735 PyObject *obj;
41736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41737 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41738 Py_INCREF(obj);
41739 return Py_BuildValue((char *)"");
41740 }
41741 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj = NULL;
41743 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41744 int arg2 = (int) wxHORIZONTAL ;
41745 wxStaticBoxSizer *result;
41746 PyObject * obj0 = 0 ;
41747 PyObject * obj1 = 0 ;
41748 char *kwnames[] = {
41749 (char *) "box",(char *) "orient", NULL
41750 };
41751
41752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41754 if (SWIG_arg_fail(1)) SWIG_fail;
41755 if (obj1) {
41756 {
41757 arg2 = static_cast<int >(SWIG_As_int(obj1));
41758 if (SWIG_arg_fail(2)) SWIG_fail;
41759 }
41760 }
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41764
41765 wxPyEndAllowThreads(__tstate);
41766 if (PyErr_Occurred()) SWIG_fail;
41767 }
41768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41769 return resultobj;
41770 fail:
41771 return NULL;
41772 }
41773
41774
41775 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41776 PyObject *resultobj = NULL;
41777 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41778 wxStaticBox *result;
41779 PyObject * obj0 = 0 ;
41780 char *kwnames[] = {
41781 (char *) "self", NULL
41782 };
41783
41784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41786 if (SWIG_arg_fail(1)) SWIG_fail;
41787 {
41788 PyThreadState* __tstate = wxPyBeginAllowThreads();
41789 result = (wxStaticBox *)(arg1)->GetStaticBox();
41790
41791 wxPyEndAllowThreads(__tstate);
41792 if (PyErr_Occurred()) SWIG_fail;
41793 }
41794 {
41795 resultobj = wxPyMake_wxObject(result, (bool)0);
41796 }
41797 return resultobj;
41798 fail:
41799 return NULL;
41800 }
41801
41802
41803 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41804 PyObject *obj;
41805 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41806 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41807 Py_INCREF(obj);
41808 return Py_BuildValue((char *)"");
41809 }
41810 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41811 PyObject *resultobj = NULL;
41812 int arg1 = (int) 1 ;
41813 int arg2 = (int) 0 ;
41814 int arg3 = (int) 0 ;
41815 int arg4 = (int) 0 ;
41816 wxGridSizer *result;
41817 PyObject * obj0 = 0 ;
41818 PyObject * obj1 = 0 ;
41819 PyObject * obj2 = 0 ;
41820 PyObject * obj3 = 0 ;
41821 char *kwnames[] = {
41822 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41823 };
41824
41825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41826 if (obj0) {
41827 {
41828 arg1 = static_cast<int >(SWIG_As_int(obj0));
41829 if (SWIG_arg_fail(1)) SWIG_fail;
41830 }
41831 }
41832 if (obj1) {
41833 {
41834 arg2 = static_cast<int >(SWIG_As_int(obj1));
41835 if (SWIG_arg_fail(2)) SWIG_fail;
41836 }
41837 }
41838 if (obj2) {
41839 {
41840 arg3 = static_cast<int >(SWIG_As_int(obj2));
41841 if (SWIG_arg_fail(3)) SWIG_fail;
41842 }
41843 }
41844 if (obj3) {
41845 {
41846 arg4 = static_cast<int >(SWIG_As_int(obj3));
41847 if (SWIG_arg_fail(4)) SWIG_fail;
41848 }
41849 }
41850 {
41851 PyThreadState* __tstate = wxPyBeginAllowThreads();
41852 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41853
41854 wxPyEndAllowThreads(__tstate);
41855 if (PyErr_Occurred()) SWIG_fail;
41856 }
41857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41858 return resultobj;
41859 fail:
41860 return NULL;
41861 }
41862
41863
41864 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41865 PyObject *resultobj = NULL;
41866 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41867 int arg2 ;
41868 PyObject * obj0 = 0 ;
41869 PyObject * obj1 = 0 ;
41870 char *kwnames[] = {
41871 (char *) "self",(char *) "cols", NULL
41872 };
41873
41874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41876 if (SWIG_arg_fail(1)) SWIG_fail;
41877 {
41878 arg2 = static_cast<int >(SWIG_As_int(obj1));
41879 if (SWIG_arg_fail(2)) SWIG_fail;
41880 }
41881 {
41882 PyThreadState* __tstate = wxPyBeginAllowThreads();
41883 (arg1)->SetCols(arg2);
41884
41885 wxPyEndAllowThreads(__tstate);
41886 if (PyErr_Occurred()) SWIG_fail;
41887 }
41888 Py_INCREF(Py_None); resultobj = Py_None;
41889 return resultobj;
41890 fail:
41891 return NULL;
41892 }
41893
41894
41895 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41896 PyObject *resultobj = NULL;
41897 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41898 int arg2 ;
41899 PyObject * obj0 = 0 ;
41900 PyObject * obj1 = 0 ;
41901 char *kwnames[] = {
41902 (char *) "self",(char *) "rows", NULL
41903 };
41904
41905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41907 if (SWIG_arg_fail(1)) SWIG_fail;
41908 {
41909 arg2 = static_cast<int >(SWIG_As_int(obj1));
41910 if (SWIG_arg_fail(2)) SWIG_fail;
41911 }
41912 {
41913 PyThreadState* __tstate = wxPyBeginAllowThreads();
41914 (arg1)->SetRows(arg2);
41915
41916 wxPyEndAllowThreads(__tstate);
41917 if (PyErr_Occurred()) SWIG_fail;
41918 }
41919 Py_INCREF(Py_None); resultobj = Py_None;
41920 return resultobj;
41921 fail:
41922 return NULL;
41923 }
41924
41925
41926 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41927 PyObject *resultobj = NULL;
41928 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41929 int arg2 ;
41930 PyObject * obj0 = 0 ;
41931 PyObject * obj1 = 0 ;
41932 char *kwnames[] = {
41933 (char *) "self",(char *) "gap", NULL
41934 };
41935
41936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41938 if (SWIG_arg_fail(1)) SWIG_fail;
41939 {
41940 arg2 = static_cast<int >(SWIG_As_int(obj1));
41941 if (SWIG_arg_fail(2)) SWIG_fail;
41942 }
41943 {
41944 PyThreadState* __tstate = wxPyBeginAllowThreads();
41945 (arg1)->SetVGap(arg2);
41946
41947 wxPyEndAllowThreads(__tstate);
41948 if (PyErr_Occurred()) SWIG_fail;
41949 }
41950 Py_INCREF(Py_None); resultobj = Py_None;
41951 return resultobj;
41952 fail:
41953 return NULL;
41954 }
41955
41956
41957 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41958 PyObject *resultobj = NULL;
41959 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41960 int arg2 ;
41961 PyObject * obj0 = 0 ;
41962 PyObject * obj1 = 0 ;
41963 char *kwnames[] = {
41964 (char *) "self",(char *) "gap", NULL
41965 };
41966
41967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41969 if (SWIG_arg_fail(1)) SWIG_fail;
41970 {
41971 arg2 = static_cast<int >(SWIG_As_int(obj1));
41972 if (SWIG_arg_fail(2)) SWIG_fail;
41973 }
41974 {
41975 PyThreadState* __tstate = wxPyBeginAllowThreads();
41976 (arg1)->SetHGap(arg2);
41977
41978 wxPyEndAllowThreads(__tstate);
41979 if (PyErr_Occurred()) SWIG_fail;
41980 }
41981 Py_INCREF(Py_None); resultobj = Py_None;
41982 return resultobj;
41983 fail:
41984 return NULL;
41985 }
41986
41987
41988 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41989 PyObject *resultobj = NULL;
41990 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41991 int result;
41992 PyObject * obj0 = 0 ;
41993 char *kwnames[] = {
41994 (char *) "self", NULL
41995 };
41996
41997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41999 if (SWIG_arg_fail(1)) SWIG_fail;
42000 {
42001 PyThreadState* __tstate = wxPyBeginAllowThreads();
42002 result = (int)(arg1)->GetCols();
42003
42004 wxPyEndAllowThreads(__tstate);
42005 if (PyErr_Occurred()) SWIG_fail;
42006 }
42007 {
42008 resultobj = SWIG_From_int(static_cast<int >(result));
42009 }
42010 return resultobj;
42011 fail:
42012 return NULL;
42013 }
42014
42015
42016 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
42017 PyObject *resultobj = NULL;
42018 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
42019 int result;
42020 PyObject * obj0 = 0 ;
42021 char *kwnames[] = {
42022 (char *) "self", NULL
42023 };
42024
42025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
42026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
42027 if (SWIG_arg_fail(1)) SWIG_fail;
42028 {
42029 PyThreadState* __tstate = wxPyBeginAllowThreads();
42030 result = (int)(arg1)->GetRows();
42031
42032 wxPyEndAllowThreads(__tstate);
42033 if (PyErr_Occurred()) SWIG_fail;
42034 }
42035 {
42036 resultobj = SWIG_From_int(static_cast<int >(result));
42037 }
42038 return resultobj;
42039 fail:
42040 return NULL;
42041 }
42042
42043
42044 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
42045 PyObject *resultobj = NULL;
42046 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
42047 int result;
42048 PyObject * obj0 = 0 ;
42049 char *kwnames[] = {
42050 (char *) "self", NULL
42051 };
42052
42053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
42054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
42055 if (SWIG_arg_fail(1)) SWIG_fail;
42056 {
42057 PyThreadState* __tstate = wxPyBeginAllowThreads();
42058 result = (int)(arg1)->GetVGap();
42059
42060 wxPyEndAllowThreads(__tstate);
42061 if (PyErr_Occurred()) SWIG_fail;
42062 }
42063 {
42064 resultobj = SWIG_From_int(static_cast<int >(result));
42065 }
42066 return resultobj;
42067 fail:
42068 return NULL;
42069 }
42070
42071
42072 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
42073 PyObject *resultobj = NULL;
42074 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
42075 int result;
42076 PyObject * obj0 = 0 ;
42077 char *kwnames[] = {
42078 (char *) "self", NULL
42079 };
42080
42081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
42082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
42083 if (SWIG_arg_fail(1)) SWIG_fail;
42084 {
42085 PyThreadState* __tstate = wxPyBeginAllowThreads();
42086 result = (int)(arg1)->GetHGap();
42087
42088 wxPyEndAllowThreads(__tstate);
42089 if (PyErr_Occurred()) SWIG_fail;
42090 }
42091 {
42092 resultobj = SWIG_From_int(static_cast<int >(result));
42093 }
42094 return resultobj;
42095 fail:
42096 return NULL;
42097 }
42098
42099
42100 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
42101 PyObject *obj;
42102 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42103 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
42104 Py_INCREF(obj);
42105 return Py_BuildValue((char *)"");
42106 }
42107 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42108 PyObject *resultobj = NULL;
42109 int arg1 = (int) 1 ;
42110 int arg2 = (int) 0 ;
42111 int arg3 = (int) 0 ;
42112 int arg4 = (int) 0 ;
42113 wxFlexGridSizer *result;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 PyObject * obj2 = 0 ;
42117 PyObject * obj3 = 0 ;
42118 char *kwnames[] = {
42119 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
42120 };
42121
42122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42123 if (obj0) {
42124 {
42125 arg1 = static_cast<int >(SWIG_As_int(obj0));
42126 if (SWIG_arg_fail(1)) SWIG_fail;
42127 }
42128 }
42129 if (obj1) {
42130 {
42131 arg2 = static_cast<int >(SWIG_As_int(obj1));
42132 if (SWIG_arg_fail(2)) SWIG_fail;
42133 }
42134 }
42135 if (obj2) {
42136 {
42137 arg3 = static_cast<int >(SWIG_As_int(obj2));
42138 if (SWIG_arg_fail(3)) SWIG_fail;
42139 }
42140 }
42141 if (obj3) {
42142 {
42143 arg4 = static_cast<int >(SWIG_As_int(obj3));
42144 if (SWIG_arg_fail(4)) SWIG_fail;
42145 }
42146 }
42147 {
42148 PyThreadState* __tstate = wxPyBeginAllowThreads();
42149 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
42150
42151 wxPyEndAllowThreads(__tstate);
42152 if (PyErr_Occurred()) SWIG_fail;
42153 }
42154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
42155 return resultobj;
42156 fail:
42157 return NULL;
42158 }
42159
42160
42161 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42162 PyObject *resultobj = NULL;
42163 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42164 size_t arg2 ;
42165 int arg3 = (int) 0 ;
42166 PyObject * obj0 = 0 ;
42167 PyObject * obj1 = 0 ;
42168 PyObject * obj2 = 0 ;
42169 char *kwnames[] = {
42170 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42171 };
42172
42173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42175 if (SWIG_arg_fail(1)) SWIG_fail;
42176 {
42177 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42178 if (SWIG_arg_fail(2)) SWIG_fail;
42179 }
42180 if (obj2) {
42181 {
42182 arg3 = static_cast<int >(SWIG_As_int(obj2));
42183 if (SWIG_arg_fail(3)) SWIG_fail;
42184 }
42185 }
42186 {
42187 PyThreadState* __tstate = wxPyBeginAllowThreads();
42188 (arg1)->AddGrowableRow(arg2,arg3);
42189
42190 wxPyEndAllowThreads(__tstate);
42191 if (PyErr_Occurred()) SWIG_fail;
42192 }
42193 Py_INCREF(Py_None); resultobj = Py_None;
42194 return resultobj;
42195 fail:
42196 return NULL;
42197 }
42198
42199
42200 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42201 PyObject *resultobj = NULL;
42202 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42203 size_t arg2 ;
42204 PyObject * obj0 = 0 ;
42205 PyObject * obj1 = 0 ;
42206 char *kwnames[] = {
42207 (char *) "self",(char *) "idx", NULL
42208 };
42209
42210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42212 if (SWIG_arg_fail(1)) SWIG_fail;
42213 {
42214 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42215 if (SWIG_arg_fail(2)) SWIG_fail;
42216 }
42217 {
42218 PyThreadState* __tstate = wxPyBeginAllowThreads();
42219 (arg1)->RemoveGrowableRow(arg2);
42220
42221 wxPyEndAllowThreads(__tstate);
42222 if (PyErr_Occurred()) SWIG_fail;
42223 }
42224 Py_INCREF(Py_None); resultobj = Py_None;
42225 return resultobj;
42226 fail:
42227 return NULL;
42228 }
42229
42230
42231 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42232 PyObject *resultobj = NULL;
42233 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42234 size_t arg2 ;
42235 int arg3 = (int) 0 ;
42236 PyObject * obj0 = 0 ;
42237 PyObject * obj1 = 0 ;
42238 PyObject * obj2 = 0 ;
42239 char *kwnames[] = {
42240 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42241 };
42242
42243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42245 if (SWIG_arg_fail(1)) SWIG_fail;
42246 {
42247 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42248 if (SWIG_arg_fail(2)) SWIG_fail;
42249 }
42250 if (obj2) {
42251 {
42252 arg3 = static_cast<int >(SWIG_As_int(obj2));
42253 if (SWIG_arg_fail(3)) SWIG_fail;
42254 }
42255 }
42256 {
42257 PyThreadState* __tstate = wxPyBeginAllowThreads();
42258 (arg1)->AddGrowableCol(arg2,arg3);
42259
42260 wxPyEndAllowThreads(__tstate);
42261 if (PyErr_Occurred()) SWIG_fail;
42262 }
42263 Py_INCREF(Py_None); resultobj = Py_None;
42264 return resultobj;
42265 fail:
42266 return NULL;
42267 }
42268
42269
42270 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42271 PyObject *resultobj = NULL;
42272 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42273 size_t arg2 ;
42274 PyObject * obj0 = 0 ;
42275 PyObject * obj1 = 0 ;
42276 char *kwnames[] = {
42277 (char *) "self",(char *) "idx", NULL
42278 };
42279
42280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42282 if (SWIG_arg_fail(1)) SWIG_fail;
42283 {
42284 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42285 if (SWIG_arg_fail(2)) SWIG_fail;
42286 }
42287 {
42288 PyThreadState* __tstate = wxPyBeginAllowThreads();
42289 (arg1)->RemoveGrowableCol(arg2);
42290
42291 wxPyEndAllowThreads(__tstate);
42292 if (PyErr_Occurred()) SWIG_fail;
42293 }
42294 Py_INCREF(Py_None); resultobj = Py_None;
42295 return resultobj;
42296 fail:
42297 return NULL;
42298 }
42299
42300
42301 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42302 PyObject *resultobj = NULL;
42303 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42304 int arg2 ;
42305 PyObject * obj0 = 0 ;
42306 PyObject * obj1 = 0 ;
42307 char *kwnames[] = {
42308 (char *) "self",(char *) "direction", NULL
42309 };
42310
42311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42313 if (SWIG_arg_fail(1)) SWIG_fail;
42314 {
42315 arg2 = static_cast<int >(SWIG_As_int(obj1));
42316 if (SWIG_arg_fail(2)) SWIG_fail;
42317 }
42318 {
42319 PyThreadState* __tstate = wxPyBeginAllowThreads();
42320 (arg1)->SetFlexibleDirection(arg2);
42321
42322 wxPyEndAllowThreads(__tstate);
42323 if (PyErr_Occurred()) SWIG_fail;
42324 }
42325 Py_INCREF(Py_None); resultobj = Py_None;
42326 return resultobj;
42327 fail:
42328 return NULL;
42329 }
42330
42331
42332 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42333 PyObject *resultobj = NULL;
42334 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42335 int result;
42336 PyObject * obj0 = 0 ;
42337 char *kwnames[] = {
42338 (char *) "self", NULL
42339 };
42340
42341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42343 if (SWIG_arg_fail(1)) SWIG_fail;
42344 {
42345 PyThreadState* __tstate = wxPyBeginAllowThreads();
42346 result = (int)(arg1)->GetFlexibleDirection();
42347
42348 wxPyEndAllowThreads(__tstate);
42349 if (PyErr_Occurred()) SWIG_fail;
42350 }
42351 {
42352 resultobj = SWIG_From_int(static_cast<int >(result));
42353 }
42354 return resultobj;
42355 fail:
42356 return NULL;
42357 }
42358
42359
42360 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42361 PyObject *resultobj = NULL;
42362 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42363 wxFlexSizerGrowMode arg2 ;
42364 PyObject * obj0 = 0 ;
42365 PyObject * obj1 = 0 ;
42366 char *kwnames[] = {
42367 (char *) "self",(char *) "mode", NULL
42368 };
42369
42370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42372 if (SWIG_arg_fail(1)) SWIG_fail;
42373 {
42374 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42375 if (SWIG_arg_fail(2)) SWIG_fail;
42376 }
42377 {
42378 PyThreadState* __tstate = wxPyBeginAllowThreads();
42379 (arg1)->SetNonFlexibleGrowMode(arg2);
42380
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 Py_INCREF(Py_None); resultobj = Py_None;
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj = NULL;
42393 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42394 wxFlexSizerGrowMode result;
42395 PyObject * obj0 = 0 ;
42396 char *kwnames[] = {
42397 (char *) "self", NULL
42398 };
42399
42400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42402 if (SWIG_arg_fail(1)) SWIG_fail;
42403 {
42404 PyThreadState* __tstate = wxPyBeginAllowThreads();
42405 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42406
42407 wxPyEndAllowThreads(__tstate);
42408 if (PyErr_Occurred()) SWIG_fail;
42409 }
42410 resultobj = SWIG_From_int((result));
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42418 PyObject *resultobj = NULL;
42419 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42420 wxArrayInt *result;
42421 PyObject * obj0 = 0 ;
42422 char *kwnames[] = {
42423 (char *) "self", NULL
42424 };
42425
42426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42428 if (SWIG_arg_fail(1)) SWIG_fail;
42429 {
42430 PyThreadState* __tstate = wxPyBeginAllowThreads();
42431 {
42432 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42433 result = (wxArrayInt *) &_result_ref;
42434 }
42435
42436 wxPyEndAllowThreads(__tstate);
42437 if (PyErr_Occurred()) SWIG_fail;
42438 }
42439 {
42440 resultobj = PyList_New(0);
42441 size_t idx;
42442 for (idx = 0; idx < result->GetCount(); idx += 1) {
42443 PyObject* val = PyInt_FromLong( result->Item(idx) );
42444 PyList_Append(resultobj, val);
42445 Py_DECREF(val);
42446 }
42447 }
42448 return resultobj;
42449 fail:
42450 return NULL;
42451 }
42452
42453
42454 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42455 PyObject *resultobj = NULL;
42456 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42457 wxArrayInt *result;
42458 PyObject * obj0 = 0 ;
42459 char *kwnames[] = {
42460 (char *) "self", NULL
42461 };
42462
42463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42465 if (SWIG_arg_fail(1)) SWIG_fail;
42466 {
42467 PyThreadState* __tstate = wxPyBeginAllowThreads();
42468 {
42469 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42470 result = (wxArrayInt *) &_result_ref;
42471 }
42472
42473 wxPyEndAllowThreads(__tstate);
42474 if (PyErr_Occurred()) SWIG_fail;
42475 }
42476 {
42477 resultobj = PyList_New(0);
42478 size_t idx;
42479 for (idx = 0; idx < result->GetCount(); idx += 1) {
42480 PyObject* val = PyInt_FromLong( result->Item(idx) );
42481 PyList_Append(resultobj, val);
42482 Py_DECREF(val);
42483 }
42484 }
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42492 PyObject *obj;
42493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42494 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42495 Py_INCREF(obj);
42496 return Py_BuildValue((char *)"");
42497 }
42498 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42499 PyObject *resultobj = NULL;
42500 wxStdDialogButtonSizer *result;
42501 char *kwnames[] = {
42502 NULL
42503 };
42504
42505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42506 {
42507 PyThreadState* __tstate = wxPyBeginAllowThreads();
42508 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42509
42510 wxPyEndAllowThreads(__tstate);
42511 if (PyErr_Occurred()) SWIG_fail;
42512 }
42513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42514 return resultobj;
42515 fail:
42516 return NULL;
42517 }
42518
42519
42520 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42521 PyObject *resultobj = NULL;
42522 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42523 wxButton *arg2 = (wxButton *) 0 ;
42524 PyObject * obj0 = 0 ;
42525 PyObject * obj1 = 0 ;
42526 char *kwnames[] = {
42527 (char *) "self",(char *) "button", NULL
42528 };
42529
42530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42532 if (SWIG_arg_fail(1)) SWIG_fail;
42533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42534 if (SWIG_arg_fail(2)) SWIG_fail;
42535 {
42536 PyThreadState* __tstate = wxPyBeginAllowThreads();
42537 (arg1)->AddButton(arg2);
42538
42539 wxPyEndAllowThreads(__tstate);
42540 if (PyErr_Occurred()) SWIG_fail;
42541 }
42542 Py_INCREF(Py_None); resultobj = Py_None;
42543 return resultobj;
42544 fail:
42545 return NULL;
42546 }
42547
42548
42549 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42550 PyObject *resultobj = NULL;
42551 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42552 PyObject * obj0 = 0 ;
42553 char *kwnames[] = {
42554 (char *) "self", NULL
42555 };
42556
42557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42559 if (SWIG_arg_fail(1)) SWIG_fail;
42560 {
42561 PyThreadState* __tstate = wxPyBeginAllowThreads();
42562 (arg1)->Realize();
42563
42564 wxPyEndAllowThreads(__tstate);
42565 if (PyErr_Occurred()) SWIG_fail;
42566 }
42567 Py_INCREF(Py_None); resultobj = Py_None;
42568 return resultobj;
42569 fail:
42570 return NULL;
42571 }
42572
42573
42574 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42575 PyObject *resultobj = NULL;
42576 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42577 wxButton *arg2 = (wxButton *) 0 ;
42578 PyObject * obj0 = 0 ;
42579 PyObject * obj1 = 0 ;
42580 char *kwnames[] = {
42581 (char *) "self",(char *) "button", NULL
42582 };
42583
42584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42586 if (SWIG_arg_fail(1)) SWIG_fail;
42587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42588 if (SWIG_arg_fail(2)) SWIG_fail;
42589 {
42590 PyThreadState* __tstate = wxPyBeginAllowThreads();
42591 (arg1)->SetAffirmativeButton(arg2);
42592
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 Py_INCREF(Py_None); resultobj = Py_None;
42597 return resultobj;
42598 fail:
42599 return NULL;
42600 }
42601
42602
42603 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42604 PyObject *resultobj = NULL;
42605 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42606 wxButton *arg2 = (wxButton *) 0 ;
42607 PyObject * obj0 = 0 ;
42608 PyObject * obj1 = 0 ;
42609 char *kwnames[] = {
42610 (char *) "self",(char *) "button", NULL
42611 };
42612
42613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42615 if (SWIG_arg_fail(1)) SWIG_fail;
42616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42617 if (SWIG_arg_fail(2)) SWIG_fail;
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 (arg1)->SetNegativeButton(arg2);
42621
42622 wxPyEndAllowThreads(__tstate);
42623 if (PyErr_Occurred()) SWIG_fail;
42624 }
42625 Py_INCREF(Py_None); resultobj = Py_None;
42626 return resultobj;
42627 fail:
42628 return NULL;
42629 }
42630
42631
42632 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42633 PyObject *resultobj = NULL;
42634 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42635 wxButton *arg2 = (wxButton *) 0 ;
42636 PyObject * obj0 = 0 ;
42637 PyObject * obj1 = 0 ;
42638 char *kwnames[] = {
42639 (char *) "self",(char *) "button", NULL
42640 };
42641
42642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42644 if (SWIG_arg_fail(1)) SWIG_fail;
42645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42646 if (SWIG_arg_fail(2)) SWIG_fail;
42647 {
42648 PyThreadState* __tstate = wxPyBeginAllowThreads();
42649 (arg1)->SetCancelButton(arg2);
42650
42651 wxPyEndAllowThreads(__tstate);
42652 if (PyErr_Occurred()) SWIG_fail;
42653 }
42654 Py_INCREF(Py_None); resultobj = Py_None;
42655 return resultobj;
42656 fail:
42657 return NULL;
42658 }
42659
42660
42661 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42662 PyObject *resultobj = NULL;
42663 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42664 wxButton *result;
42665 PyObject * obj0 = 0 ;
42666 char *kwnames[] = {
42667 (char *) "self", NULL
42668 };
42669
42670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42672 if (SWIG_arg_fail(1)) SWIG_fail;
42673 {
42674 PyThreadState* __tstate = wxPyBeginAllowThreads();
42675 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42676
42677 wxPyEndAllowThreads(__tstate);
42678 if (PyErr_Occurred()) SWIG_fail;
42679 }
42680 {
42681 resultobj = wxPyMake_wxObject(result, (bool)0);
42682 }
42683 return resultobj;
42684 fail:
42685 return NULL;
42686 }
42687
42688
42689 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42690 PyObject *resultobj = NULL;
42691 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42692 wxButton *result;
42693 PyObject * obj0 = 0 ;
42694 char *kwnames[] = {
42695 (char *) "self", NULL
42696 };
42697
42698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42700 if (SWIG_arg_fail(1)) SWIG_fail;
42701 {
42702 PyThreadState* __tstate = wxPyBeginAllowThreads();
42703 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42704
42705 wxPyEndAllowThreads(__tstate);
42706 if (PyErr_Occurred()) SWIG_fail;
42707 }
42708 {
42709 resultobj = wxPyMake_wxObject(result, (bool)0);
42710 }
42711 return resultobj;
42712 fail:
42713 return NULL;
42714 }
42715
42716
42717 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42718 PyObject *resultobj = NULL;
42719 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42720 wxButton *result;
42721 PyObject * obj0 = 0 ;
42722 char *kwnames[] = {
42723 (char *) "self", NULL
42724 };
42725
42726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42728 if (SWIG_arg_fail(1)) SWIG_fail;
42729 {
42730 PyThreadState* __tstate = wxPyBeginAllowThreads();
42731 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42732
42733 wxPyEndAllowThreads(__tstate);
42734 if (PyErr_Occurred()) SWIG_fail;
42735 }
42736 {
42737 resultobj = wxPyMake_wxObject(result, (bool)0);
42738 }
42739 return resultobj;
42740 fail:
42741 return NULL;
42742 }
42743
42744
42745 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42746 PyObject *resultobj = NULL;
42747 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42748 wxButton *result;
42749 PyObject * obj0 = 0 ;
42750 char *kwnames[] = {
42751 (char *) "self", NULL
42752 };
42753
42754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42756 if (SWIG_arg_fail(1)) SWIG_fail;
42757 {
42758 PyThreadState* __tstate = wxPyBeginAllowThreads();
42759 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42760
42761 wxPyEndAllowThreads(__tstate);
42762 if (PyErr_Occurred()) SWIG_fail;
42763 }
42764 {
42765 resultobj = wxPyMake_wxObject(result, (bool)0);
42766 }
42767 return resultobj;
42768 fail:
42769 return NULL;
42770 }
42771
42772
42773 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42774 PyObject *resultobj = NULL;
42775 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42776 wxButton *result;
42777 PyObject * obj0 = 0 ;
42778 char *kwnames[] = {
42779 (char *) "self", NULL
42780 };
42781
42782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42784 if (SWIG_arg_fail(1)) SWIG_fail;
42785 {
42786 PyThreadState* __tstate = wxPyBeginAllowThreads();
42787 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42788
42789 wxPyEndAllowThreads(__tstate);
42790 if (PyErr_Occurred()) SWIG_fail;
42791 }
42792 {
42793 resultobj = wxPyMake_wxObject(result, (bool)0);
42794 }
42795 return resultobj;
42796 fail:
42797 return NULL;
42798 }
42799
42800
42801 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42802 PyObject *obj;
42803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42804 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42805 Py_INCREF(obj);
42806 return Py_BuildValue((char *)"");
42807 }
42808 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42809 PyObject *resultobj = NULL;
42810 int arg1 = (int) 0 ;
42811 int arg2 = (int) 0 ;
42812 wxGBPosition *result;
42813 PyObject * obj0 = 0 ;
42814 PyObject * obj1 = 0 ;
42815 char *kwnames[] = {
42816 (char *) "row",(char *) "col", NULL
42817 };
42818
42819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42820 if (obj0) {
42821 {
42822 arg1 = static_cast<int >(SWIG_As_int(obj0));
42823 if (SWIG_arg_fail(1)) SWIG_fail;
42824 }
42825 }
42826 if (obj1) {
42827 {
42828 arg2 = static_cast<int >(SWIG_As_int(obj1));
42829 if (SWIG_arg_fail(2)) SWIG_fail;
42830 }
42831 }
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42835
42836 wxPyEndAllowThreads(__tstate);
42837 if (PyErr_Occurred()) SWIG_fail;
42838 }
42839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 static PyObject *_wrap_delete_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42847 PyObject *resultobj = NULL;
42848 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42849 PyObject * obj0 = 0 ;
42850 char *kwnames[] = {
42851 (char *) "self", NULL
42852 };
42853
42854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBPosition",kwnames,&obj0)) goto fail;
42855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42856 if (SWIG_arg_fail(1)) SWIG_fail;
42857 {
42858 PyThreadState* __tstate = wxPyBeginAllowThreads();
42859 delete arg1;
42860
42861 wxPyEndAllowThreads(__tstate);
42862 if (PyErr_Occurred()) SWIG_fail;
42863 }
42864 Py_INCREF(Py_None); resultobj = Py_None;
42865 return resultobj;
42866 fail:
42867 return NULL;
42868 }
42869
42870
42871 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42872 PyObject *resultobj = NULL;
42873 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42874 int result;
42875 PyObject * obj0 = 0 ;
42876 char *kwnames[] = {
42877 (char *) "self", NULL
42878 };
42879
42880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42882 if (SWIG_arg_fail(1)) SWIG_fail;
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 result = (int)((wxGBPosition const *)arg1)->GetRow();
42886
42887 wxPyEndAllowThreads(__tstate);
42888 if (PyErr_Occurred()) SWIG_fail;
42889 }
42890 {
42891 resultobj = SWIG_From_int(static_cast<int >(result));
42892 }
42893 return resultobj;
42894 fail:
42895 return NULL;
42896 }
42897
42898
42899 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42900 PyObject *resultobj = NULL;
42901 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42902 int result;
42903 PyObject * obj0 = 0 ;
42904 char *kwnames[] = {
42905 (char *) "self", NULL
42906 };
42907
42908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42910 if (SWIG_arg_fail(1)) SWIG_fail;
42911 {
42912 PyThreadState* __tstate = wxPyBeginAllowThreads();
42913 result = (int)((wxGBPosition const *)arg1)->GetCol();
42914
42915 wxPyEndAllowThreads(__tstate);
42916 if (PyErr_Occurred()) SWIG_fail;
42917 }
42918 {
42919 resultobj = SWIG_From_int(static_cast<int >(result));
42920 }
42921 return resultobj;
42922 fail:
42923 return NULL;
42924 }
42925
42926
42927 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj = NULL;
42929 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42930 int arg2 ;
42931 PyObject * obj0 = 0 ;
42932 PyObject * obj1 = 0 ;
42933 char *kwnames[] = {
42934 (char *) "self",(char *) "row", NULL
42935 };
42936
42937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42939 if (SWIG_arg_fail(1)) SWIG_fail;
42940 {
42941 arg2 = static_cast<int >(SWIG_As_int(obj1));
42942 if (SWIG_arg_fail(2)) SWIG_fail;
42943 }
42944 {
42945 PyThreadState* __tstate = wxPyBeginAllowThreads();
42946 (arg1)->SetRow(arg2);
42947
42948 wxPyEndAllowThreads(__tstate);
42949 if (PyErr_Occurred()) SWIG_fail;
42950 }
42951 Py_INCREF(Py_None); resultobj = Py_None;
42952 return resultobj;
42953 fail:
42954 return NULL;
42955 }
42956
42957
42958 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42959 PyObject *resultobj = NULL;
42960 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42961 int arg2 ;
42962 PyObject * obj0 = 0 ;
42963 PyObject * obj1 = 0 ;
42964 char *kwnames[] = {
42965 (char *) "self",(char *) "col", NULL
42966 };
42967
42968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42970 if (SWIG_arg_fail(1)) SWIG_fail;
42971 {
42972 arg2 = static_cast<int >(SWIG_As_int(obj1));
42973 if (SWIG_arg_fail(2)) SWIG_fail;
42974 }
42975 {
42976 PyThreadState* __tstate = wxPyBeginAllowThreads();
42977 (arg1)->SetCol(arg2);
42978
42979 wxPyEndAllowThreads(__tstate);
42980 if (PyErr_Occurred()) SWIG_fail;
42981 }
42982 Py_INCREF(Py_None); resultobj = Py_None;
42983 return resultobj;
42984 fail:
42985 return NULL;
42986 }
42987
42988
42989 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42990 PyObject *resultobj = NULL;
42991 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42992 wxGBPosition *arg2 = 0 ;
42993 bool result;
42994 wxGBPosition temp2 ;
42995 PyObject * obj0 = 0 ;
42996 PyObject * obj1 = 0 ;
42997 char *kwnames[] = {
42998 (char *) "self",(char *) "other", NULL
42999 };
43000
43001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
43002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43003 if (SWIG_arg_fail(1)) SWIG_fail;
43004 {
43005 arg2 = &temp2;
43006 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43007 }
43008 {
43009 PyThreadState* __tstate = wxPyBeginAllowThreads();
43010 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
43011
43012 wxPyEndAllowThreads(__tstate);
43013 if (PyErr_Occurred()) SWIG_fail;
43014 }
43015 {
43016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43017 }
43018 return resultobj;
43019 fail:
43020 return NULL;
43021 }
43022
43023
43024 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43025 PyObject *resultobj = NULL;
43026 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43027 wxGBPosition *arg2 = 0 ;
43028 bool result;
43029 wxGBPosition temp2 ;
43030 PyObject * obj0 = 0 ;
43031 PyObject * obj1 = 0 ;
43032 char *kwnames[] = {
43033 (char *) "self",(char *) "other", NULL
43034 };
43035
43036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
43037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43038 if (SWIG_arg_fail(1)) SWIG_fail;
43039 {
43040 arg2 = &temp2;
43041 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43042 }
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
43046
43047 wxPyEndAllowThreads(__tstate);
43048 if (PyErr_Occurred()) SWIG_fail;
43049 }
43050 {
43051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43052 }
43053 return resultobj;
43054 fail:
43055 return NULL;
43056 }
43057
43058
43059 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43060 PyObject *resultobj = NULL;
43061 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43062 int arg2 = (int) 0 ;
43063 int arg3 = (int) 0 ;
43064 PyObject * obj0 = 0 ;
43065 PyObject * obj1 = 0 ;
43066 PyObject * obj2 = 0 ;
43067 char *kwnames[] = {
43068 (char *) "self",(char *) "row",(char *) "col", NULL
43069 };
43070
43071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43073 if (SWIG_arg_fail(1)) SWIG_fail;
43074 if (obj1) {
43075 {
43076 arg2 = static_cast<int >(SWIG_As_int(obj1));
43077 if (SWIG_arg_fail(2)) SWIG_fail;
43078 }
43079 }
43080 if (obj2) {
43081 {
43082 arg3 = static_cast<int >(SWIG_As_int(obj2));
43083 if (SWIG_arg_fail(3)) SWIG_fail;
43084 }
43085 }
43086 {
43087 PyThreadState* __tstate = wxPyBeginAllowThreads();
43088 wxGBPosition_Set(arg1,arg2,arg3);
43089
43090 wxPyEndAllowThreads(__tstate);
43091 if (PyErr_Occurred()) SWIG_fail;
43092 }
43093 Py_INCREF(Py_None); resultobj = Py_None;
43094 return resultobj;
43095 fail:
43096 return NULL;
43097 }
43098
43099
43100 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43101 PyObject *resultobj = NULL;
43102 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43103 PyObject *result;
43104 PyObject * obj0 = 0 ;
43105 char *kwnames[] = {
43106 (char *) "self", NULL
43107 };
43108
43109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
43110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43111 if (SWIG_arg_fail(1)) SWIG_fail;
43112 {
43113 PyThreadState* __tstate = wxPyBeginAllowThreads();
43114 result = (PyObject *)wxGBPosition_Get(arg1);
43115
43116 wxPyEndAllowThreads(__tstate);
43117 if (PyErr_Occurred()) SWIG_fail;
43118 }
43119 resultobj = result;
43120 return resultobj;
43121 fail:
43122 return NULL;
43123 }
43124
43125
43126 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
43127 PyObject *obj;
43128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43129 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
43130 Py_INCREF(obj);
43131 return Py_BuildValue((char *)"");
43132 }
43133 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43134 PyObject *resultobj = NULL;
43135 int arg1 = (int) 1 ;
43136 int arg2 = (int) 1 ;
43137 wxGBSpan *result;
43138 PyObject * obj0 = 0 ;
43139 PyObject * obj1 = 0 ;
43140 char *kwnames[] = {
43141 (char *) "rowspan",(char *) "colspan", NULL
43142 };
43143
43144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
43145 if (obj0) {
43146 {
43147 arg1 = static_cast<int >(SWIG_As_int(obj0));
43148 if (SWIG_arg_fail(1)) SWIG_fail;
43149 }
43150 }
43151 if (obj1) {
43152 {
43153 arg2 = static_cast<int >(SWIG_As_int(obj1));
43154 if (SWIG_arg_fail(2)) SWIG_fail;
43155 }
43156 }
43157 {
43158 PyThreadState* __tstate = wxPyBeginAllowThreads();
43159 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
43160
43161 wxPyEndAllowThreads(__tstate);
43162 if (PyErr_Occurred()) SWIG_fail;
43163 }
43164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
43165 return resultobj;
43166 fail:
43167 return NULL;
43168 }
43169
43170
43171 static PyObject *_wrap_delete_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43172 PyObject *resultobj = NULL;
43173 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43174 PyObject * obj0 = 0 ;
43175 char *kwnames[] = {
43176 (char *) "self", NULL
43177 };
43178
43179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSpan",kwnames,&obj0)) goto fail;
43180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43181 if (SWIG_arg_fail(1)) SWIG_fail;
43182 {
43183 PyThreadState* __tstate = wxPyBeginAllowThreads();
43184 delete arg1;
43185
43186 wxPyEndAllowThreads(__tstate);
43187 if (PyErr_Occurred()) SWIG_fail;
43188 }
43189 Py_INCREF(Py_None); resultobj = Py_None;
43190 return resultobj;
43191 fail:
43192 return NULL;
43193 }
43194
43195
43196 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43197 PyObject *resultobj = NULL;
43198 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43199 int result;
43200 PyObject * obj0 = 0 ;
43201 char *kwnames[] = {
43202 (char *) "self", NULL
43203 };
43204
43205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
43206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43207 if (SWIG_arg_fail(1)) SWIG_fail;
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
43211
43212 wxPyEndAllowThreads(__tstate);
43213 if (PyErr_Occurred()) SWIG_fail;
43214 }
43215 {
43216 resultobj = SWIG_From_int(static_cast<int >(result));
43217 }
43218 return resultobj;
43219 fail:
43220 return NULL;
43221 }
43222
43223
43224 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43225 PyObject *resultobj = NULL;
43226 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43227 int result;
43228 PyObject * obj0 = 0 ;
43229 char *kwnames[] = {
43230 (char *) "self", NULL
43231 };
43232
43233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43235 if (SWIG_arg_fail(1)) SWIG_fail;
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43239
43240 wxPyEndAllowThreads(__tstate);
43241 if (PyErr_Occurred()) SWIG_fail;
43242 }
43243 {
43244 resultobj = SWIG_From_int(static_cast<int >(result));
43245 }
43246 return resultobj;
43247 fail:
43248 return NULL;
43249 }
43250
43251
43252 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43253 PyObject *resultobj = NULL;
43254 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43255 int arg2 ;
43256 PyObject * obj0 = 0 ;
43257 PyObject * obj1 = 0 ;
43258 char *kwnames[] = {
43259 (char *) "self",(char *) "rowspan", NULL
43260 };
43261
43262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43264 if (SWIG_arg_fail(1)) SWIG_fail;
43265 {
43266 arg2 = static_cast<int >(SWIG_As_int(obj1));
43267 if (SWIG_arg_fail(2)) SWIG_fail;
43268 }
43269 {
43270 PyThreadState* __tstate = wxPyBeginAllowThreads();
43271 (arg1)->SetRowspan(arg2);
43272
43273 wxPyEndAllowThreads(__tstate);
43274 if (PyErr_Occurred()) SWIG_fail;
43275 }
43276 Py_INCREF(Py_None); resultobj = Py_None;
43277 return resultobj;
43278 fail:
43279 return NULL;
43280 }
43281
43282
43283 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43284 PyObject *resultobj = NULL;
43285 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43286 int arg2 ;
43287 PyObject * obj0 = 0 ;
43288 PyObject * obj1 = 0 ;
43289 char *kwnames[] = {
43290 (char *) "self",(char *) "colspan", NULL
43291 };
43292
43293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43295 if (SWIG_arg_fail(1)) SWIG_fail;
43296 {
43297 arg2 = static_cast<int >(SWIG_As_int(obj1));
43298 if (SWIG_arg_fail(2)) SWIG_fail;
43299 }
43300 {
43301 PyThreadState* __tstate = wxPyBeginAllowThreads();
43302 (arg1)->SetColspan(arg2);
43303
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 Py_INCREF(Py_None); resultobj = Py_None;
43308 return resultobj;
43309 fail:
43310 return NULL;
43311 }
43312
43313
43314 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43315 PyObject *resultobj = NULL;
43316 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43317 wxGBSpan *arg2 = 0 ;
43318 bool result;
43319 wxGBSpan temp2 ;
43320 PyObject * obj0 = 0 ;
43321 PyObject * obj1 = 0 ;
43322 char *kwnames[] = {
43323 (char *) "self",(char *) "other", NULL
43324 };
43325
43326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43328 if (SWIG_arg_fail(1)) SWIG_fail;
43329 {
43330 arg2 = &temp2;
43331 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43332 }
43333 {
43334 PyThreadState* __tstate = wxPyBeginAllowThreads();
43335 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43336
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 {
43341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43342 }
43343 return resultobj;
43344 fail:
43345 return NULL;
43346 }
43347
43348
43349 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43350 PyObject *resultobj = NULL;
43351 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43352 wxGBSpan *arg2 = 0 ;
43353 bool result;
43354 wxGBSpan temp2 ;
43355 PyObject * obj0 = 0 ;
43356 PyObject * obj1 = 0 ;
43357 char *kwnames[] = {
43358 (char *) "self",(char *) "other", NULL
43359 };
43360
43361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43363 if (SWIG_arg_fail(1)) SWIG_fail;
43364 {
43365 arg2 = &temp2;
43366 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43367 }
43368 {
43369 PyThreadState* __tstate = wxPyBeginAllowThreads();
43370 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43371
43372 wxPyEndAllowThreads(__tstate);
43373 if (PyErr_Occurred()) SWIG_fail;
43374 }
43375 {
43376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43377 }
43378 return resultobj;
43379 fail:
43380 return NULL;
43381 }
43382
43383
43384 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43385 PyObject *resultobj = NULL;
43386 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43387 int arg2 = (int) 1 ;
43388 int arg3 = (int) 1 ;
43389 PyObject * obj0 = 0 ;
43390 PyObject * obj1 = 0 ;
43391 PyObject * obj2 = 0 ;
43392 char *kwnames[] = {
43393 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43394 };
43395
43396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43398 if (SWIG_arg_fail(1)) SWIG_fail;
43399 if (obj1) {
43400 {
43401 arg2 = static_cast<int >(SWIG_As_int(obj1));
43402 if (SWIG_arg_fail(2)) SWIG_fail;
43403 }
43404 }
43405 if (obj2) {
43406 {
43407 arg3 = static_cast<int >(SWIG_As_int(obj2));
43408 if (SWIG_arg_fail(3)) SWIG_fail;
43409 }
43410 }
43411 {
43412 PyThreadState* __tstate = wxPyBeginAllowThreads();
43413 wxGBSpan_Set(arg1,arg2,arg3);
43414
43415 wxPyEndAllowThreads(__tstate);
43416 if (PyErr_Occurred()) SWIG_fail;
43417 }
43418 Py_INCREF(Py_None); resultobj = Py_None;
43419 return resultobj;
43420 fail:
43421 return NULL;
43422 }
43423
43424
43425 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43426 PyObject *resultobj = NULL;
43427 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43428 PyObject *result;
43429 PyObject * obj0 = 0 ;
43430 char *kwnames[] = {
43431 (char *) "self", NULL
43432 };
43433
43434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43436 if (SWIG_arg_fail(1)) SWIG_fail;
43437 {
43438 PyThreadState* __tstate = wxPyBeginAllowThreads();
43439 result = (PyObject *)wxGBSpan_Get(arg1);
43440
43441 wxPyEndAllowThreads(__tstate);
43442 if (PyErr_Occurred()) SWIG_fail;
43443 }
43444 resultobj = result;
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43452 PyObject *obj;
43453 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43454 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43455 Py_INCREF(obj);
43456 return Py_BuildValue((char *)"");
43457 }
43458 static int _wrap_DefaultSpan_set(PyObject *) {
43459 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43460 return 1;
43461 }
43462
43463
43464 static PyObject *_wrap_DefaultSpan_get(void) {
43465 PyObject *pyobj = NULL;
43466
43467 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43468 return pyobj;
43469 }
43470
43471
43472 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43473 PyObject *resultobj = NULL;
43474 wxGBSizerItem *result;
43475 char *kwnames[] = {
43476 NULL
43477 };
43478
43479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43480 {
43481 PyThreadState* __tstate = wxPyBeginAllowThreads();
43482 result = (wxGBSizerItem *)new wxGBSizerItem();
43483
43484 wxPyEndAllowThreads(__tstate);
43485 if (PyErr_Occurred()) SWIG_fail;
43486 }
43487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43488 return resultobj;
43489 fail:
43490 return NULL;
43491 }
43492
43493
43494 static PyObject *_wrap_delete_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43495 PyObject *resultobj = NULL;
43496 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43497 PyObject * obj0 = 0 ;
43498 char *kwnames[] = {
43499 (char *) "self", NULL
43500 };
43501
43502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSizerItem",kwnames,&obj0)) goto fail;
43503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43504 if (SWIG_arg_fail(1)) SWIG_fail;
43505 {
43506 PyThreadState* __tstate = wxPyBeginAllowThreads();
43507 delete arg1;
43508
43509 wxPyEndAllowThreads(__tstate);
43510 if (PyErr_Occurred()) SWIG_fail;
43511 }
43512 Py_INCREF(Py_None); resultobj = Py_None;
43513 return resultobj;
43514 fail:
43515 return NULL;
43516 }
43517
43518
43519 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43520 PyObject *resultobj = NULL;
43521 wxWindow *arg1 = (wxWindow *) 0 ;
43522 wxGBPosition *arg2 = 0 ;
43523 wxGBSpan *arg3 = 0 ;
43524 int arg4 ;
43525 int arg5 ;
43526 PyObject *arg6 = (PyObject *) NULL ;
43527 wxGBSizerItem *result;
43528 wxGBPosition temp2 ;
43529 wxGBSpan temp3 ;
43530 PyObject * obj0 = 0 ;
43531 PyObject * obj1 = 0 ;
43532 PyObject * obj2 = 0 ;
43533 PyObject * obj3 = 0 ;
43534 PyObject * obj4 = 0 ;
43535 PyObject * obj5 = 0 ;
43536 char *kwnames[] = {
43537 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43538 };
43539
43540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43542 if (SWIG_arg_fail(1)) SWIG_fail;
43543 {
43544 arg2 = &temp2;
43545 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43546 }
43547 {
43548 arg3 = &temp3;
43549 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43550 }
43551 {
43552 arg4 = static_cast<int >(SWIG_As_int(obj3));
43553 if (SWIG_arg_fail(4)) SWIG_fail;
43554 }
43555 {
43556 arg5 = static_cast<int >(SWIG_As_int(obj4));
43557 if (SWIG_arg_fail(5)) SWIG_fail;
43558 }
43559 if (obj5) {
43560 arg6 = obj5;
43561 }
43562 {
43563 PyThreadState* __tstate = wxPyBeginAllowThreads();
43564 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43565
43566 wxPyEndAllowThreads(__tstate);
43567 if (PyErr_Occurred()) SWIG_fail;
43568 }
43569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43570 return resultobj;
43571 fail:
43572 return NULL;
43573 }
43574
43575
43576 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43577 PyObject *resultobj = NULL;
43578 wxSizer *arg1 = (wxSizer *) 0 ;
43579 wxGBPosition *arg2 = 0 ;
43580 wxGBSpan *arg3 = 0 ;
43581 int arg4 ;
43582 int arg5 ;
43583 PyObject *arg6 = (PyObject *) NULL ;
43584 wxGBSizerItem *result;
43585 wxGBPosition temp2 ;
43586 wxGBSpan temp3 ;
43587 PyObject * obj0 = 0 ;
43588 PyObject * obj1 = 0 ;
43589 PyObject * obj2 = 0 ;
43590 PyObject * obj3 = 0 ;
43591 PyObject * obj4 = 0 ;
43592 PyObject * obj5 = 0 ;
43593 char *kwnames[] = {
43594 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43595 };
43596
43597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43599 if (SWIG_arg_fail(1)) SWIG_fail;
43600 {
43601 arg2 = &temp2;
43602 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43603 }
43604 {
43605 arg3 = &temp3;
43606 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43607 }
43608 {
43609 arg4 = static_cast<int >(SWIG_As_int(obj3));
43610 if (SWIG_arg_fail(4)) SWIG_fail;
43611 }
43612 {
43613 arg5 = static_cast<int >(SWIG_As_int(obj4));
43614 if (SWIG_arg_fail(5)) SWIG_fail;
43615 }
43616 if (obj5) {
43617 arg6 = obj5;
43618 }
43619 {
43620 PyThreadState* __tstate = wxPyBeginAllowThreads();
43621 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43622
43623 wxPyEndAllowThreads(__tstate);
43624 if (PyErr_Occurred()) SWIG_fail;
43625 }
43626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43627 return resultobj;
43628 fail:
43629 return NULL;
43630 }
43631
43632
43633 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43634 PyObject *resultobj = NULL;
43635 int arg1 ;
43636 int arg2 ;
43637 wxGBPosition *arg3 = 0 ;
43638 wxGBSpan *arg4 = 0 ;
43639 int arg5 ;
43640 int arg6 ;
43641 PyObject *arg7 = (PyObject *) NULL ;
43642 wxGBSizerItem *result;
43643 wxGBPosition temp3 ;
43644 wxGBSpan temp4 ;
43645 PyObject * obj0 = 0 ;
43646 PyObject * obj1 = 0 ;
43647 PyObject * obj2 = 0 ;
43648 PyObject * obj3 = 0 ;
43649 PyObject * obj4 = 0 ;
43650 PyObject * obj5 = 0 ;
43651 PyObject * obj6 = 0 ;
43652 char *kwnames[] = {
43653 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43654 };
43655
43656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43657 {
43658 arg1 = static_cast<int >(SWIG_As_int(obj0));
43659 if (SWIG_arg_fail(1)) SWIG_fail;
43660 }
43661 {
43662 arg2 = static_cast<int >(SWIG_As_int(obj1));
43663 if (SWIG_arg_fail(2)) SWIG_fail;
43664 }
43665 {
43666 arg3 = &temp3;
43667 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43668 }
43669 {
43670 arg4 = &temp4;
43671 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43672 }
43673 {
43674 arg5 = static_cast<int >(SWIG_As_int(obj4));
43675 if (SWIG_arg_fail(5)) SWIG_fail;
43676 }
43677 {
43678 arg6 = static_cast<int >(SWIG_As_int(obj5));
43679 if (SWIG_arg_fail(6)) SWIG_fail;
43680 }
43681 if (obj6) {
43682 arg7 = obj6;
43683 }
43684 {
43685 PyThreadState* __tstate = wxPyBeginAllowThreads();
43686 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43687
43688 wxPyEndAllowThreads(__tstate);
43689 if (PyErr_Occurred()) SWIG_fail;
43690 }
43691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43692 return resultobj;
43693 fail:
43694 return NULL;
43695 }
43696
43697
43698 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43699 PyObject *resultobj = NULL;
43700 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43701 wxGBPosition result;
43702 PyObject * obj0 = 0 ;
43703 char *kwnames[] = {
43704 (char *) "self", NULL
43705 };
43706
43707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43709 if (SWIG_arg_fail(1)) SWIG_fail;
43710 {
43711 PyThreadState* __tstate = wxPyBeginAllowThreads();
43712 result = ((wxGBSizerItem const *)arg1)->GetPos();
43713
43714 wxPyEndAllowThreads(__tstate);
43715 if (PyErr_Occurred()) SWIG_fail;
43716 }
43717 {
43718 wxGBPosition * resultptr;
43719 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43721 }
43722 return resultobj;
43723 fail:
43724 return NULL;
43725 }
43726
43727
43728 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43729 PyObject *resultobj = NULL;
43730 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43731 wxGBSpan result;
43732 PyObject * obj0 = 0 ;
43733 char *kwnames[] = {
43734 (char *) "self", NULL
43735 };
43736
43737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43739 if (SWIG_arg_fail(1)) SWIG_fail;
43740 {
43741 PyThreadState* __tstate = wxPyBeginAllowThreads();
43742 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43743
43744 wxPyEndAllowThreads(__tstate);
43745 if (PyErr_Occurred()) SWIG_fail;
43746 }
43747 {
43748 wxGBSpan * resultptr;
43749 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43750 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43751 }
43752 return resultobj;
43753 fail:
43754 return NULL;
43755 }
43756
43757
43758 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43759 PyObject *resultobj = NULL;
43760 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43761 wxGBPosition *arg2 = 0 ;
43762 bool result;
43763 wxGBPosition temp2 ;
43764 PyObject * obj0 = 0 ;
43765 PyObject * obj1 = 0 ;
43766 char *kwnames[] = {
43767 (char *) "self",(char *) "pos", NULL
43768 };
43769
43770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43772 if (SWIG_arg_fail(1)) SWIG_fail;
43773 {
43774 arg2 = &temp2;
43775 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43776 }
43777 {
43778 PyThreadState* __tstate = wxPyBeginAllowThreads();
43779 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43780
43781 wxPyEndAllowThreads(__tstate);
43782 if (PyErr_Occurred()) SWIG_fail;
43783 }
43784 {
43785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43786 }
43787 return resultobj;
43788 fail:
43789 return NULL;
43790 }
43791
43792
43793 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43794 PyObject *resultobj = NULL;
43795 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43796 wxGBSpan *arg2 = 0 ;
43797 bool result;
43798 wxGBSpan temp2 ;
43799 PyObject * obj0 = 0 ;
43800 PyObject * obj1 = 0 ;
43801 char *kwnames[] = {
43802 (char *) "self",(char *) "span", NULL
43803 };
43804
43805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43807 if (SWIG_arg_fail(1)) SWIG_fail;
43808 {
43809 arg2 = &temp2;
43810 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43811 }
43812 {
43813 PyThreadState* __tstate = wxPyBeginAllowThreads();
43814 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43815
43816 wxPyEndAllowThreads(__tstate);
43817 if (PyErr_Occurred()) SWIG_fail;
43818 }
43819 {
43820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43821 }
43822 return resultobj;
43823 fail:
43824 return NULL;
43825 }
43826
43827
43828 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43829 PyObject *resultobj = NULL;
43830 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43831 wxGBSizerItem *arg2 = 0 ;
43832 bool result;
43833 PyObject * obj0 = 0 ;
43834 PyObject * obj1 = 0 ;
43835 char *kwnames[] = {
43836 (char *) "self",(char *) "other", NULL
43837 };
43838
43839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43841 if (SWIG_arg_fail(1)) SWIG_fail;
43842 {
43843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43844 if (SWIG_arg_fail(2)) SWIG_fail;
43845 if (arg2 == NULL) {
43846 SWIG_null_ref("wxGBSizerItem");
43847 }
43848 if (SWIG_arg_fail(2)) SWIG_fail;
43849 }
43850 {
43851 PyThreadState* __tstate = wxPyBeginAllowThreads();
43852 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43853
43854 wxPyEndAllowThreads(__tstate);
43855 if (PyErr_Occurred()) SWIG_fail;
43856 }
43857 {
43858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43859 }
43860 return resultobj;
43861 fail:
43862 return NULL;
43863 }
43864
43865
43866 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43867 PyObject *resultobj = NULL;
43868 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43869 wxGBPosition *arg2 = 0 ;
43870 wxGBSpan *arg3 = 0 ;
43871 bool result;
43872 wxGBPosition temp2 ;
43873 wxGBSpan temp3 ;
43874 PyObject * obj0 = 0 ;
43875 PyObject * obj1 = 0 ;
43876 PyObject * obj2 = 0 ;
43877 char *kwnames[] = {
43878 (char *) "self",(char *) "pos",(char *) "span", NULL
43879 };
43880
43881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43883 if (SWIG_arg_fail(1)) SWIG_fail;
43884 {
43885 arg2 = &temp2;
43886 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43887 }
43888 {
43889 arg3 = &temp3;
43890 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43891 }
43892 {
43893 PyThreadState* __tstate = wxPyBeginAllowThreads();
43894 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43895
43896 wxPyEndAllowThreads(__tstate);
43897 if (PyErr_Occurred()) SWIG_fail;
43898 }
43899 {
43900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43901 }
43902 return resultobj;
43903 fail:
43904 return NULL;
43905 }
43906
43907
43908 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43909 PyObject *resultobj = NULL;
43910 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43911 wxGBPosition result;
43912 PyObject * obj0 = 0 ;
43913 char *kwnames[] = {
43914 (char *) "self", NULL
43915 };
43916
43917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43919 if (SWIG_arg_fail(1)) SWIG_fail;
43920 {
43921 PyThreadState* __tstate = wxPyBeginAllowThreads();
43922 result = wxGBSizerItem_GetEndPos(arg1);
43923
43924 wxPyEndAllowThreads(__tstate);
43925 if (PyErr_Occurred()) SWIG_fail;
43926 }
43927 {
43928 wxGBPosition * resultptr;
43929 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43930 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43931 }
43932 return resultobj;
43933 fail:
43934 return NULL;
43935 }
43936
43937
43938 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43939 PyObject *resultobj = NULL;
43940 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43941 wxGridBagSizer *result;
43942 PyObject * obj0 = 0 ;
43943 char *kwnames[] = {
43944 (char *) "self", NULL
43945 };
43946
43947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43949 if (SWIG_arg_fail(1)) SWIG_fail;
43950 {
43951 PyThreadState* __tstate = wxPyBeginAllowThreads();
43952 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43953
43954 wxPyEndAllowThreads(__tstate);
43955 if (PyErr_Occurred()) SWIG_fail;
43956 }
43957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43958 return resultobj;
43959 fail:
43960 return NULL;
43961 }
43962
43963
43964 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43965 PyObject *resultobj = NULL;
43966 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43967 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43968 PyObject * obj0 = 0 ;
43969 PyObject * obj1 = 0 ;
43970 char *kwnames[] = {
43971 (char *) "self",(char *) "sizer", NULL
43972 };
43973
43974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43976 if (SWIG_arg_fail(1)) SWIG_fail;
43977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43978 if (SWIG_arg_fail(2)) SWIG_fail;
43979 {
43980 PyThreadState* __tstate = wxPyBeginAllowThreads();
43981 (arg1)->SetGBSizer(arg2);
43982
43983 wxPyEndAllowThreads(__tstate);
43984 if (PyErr_Occurred()) SWIG_fail;
43985 }
43986 Py_INCREF(Py_None); resultobj = Py_None;
43987 return resultobj;
43988 fail:
43989 return NULL;
43990 }
43991
43992
43993 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43994 PyObject *obj;
43995 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43996 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43997 Py_INCREF(obj);
43998 return Py_BuildValue((char *)"");
43999 }
44000 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj = NULL;
44002 int arg1 = (int) 0 ;
44003 int arg2 = (int) 0 ;
44004 wxGridBagSizer *result;
44005 PyObject * obj0 = 0 ;
44006 PyObject * obj1 = 0 ;
44007 char *kwnames[] = {
44008 (char *) "vgap",(char *) "hgap", NULL
44009 };
44010
44011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
44012 if (obj0) {
44013 {
44014 arg1 = static_cast<int >(SWIG_As_int(obj0));
44015 if (SWIG_arg_fail(1)) SWIG_fail;
44016 }
44017 }
44018 if (obj1) {
44019 {
44020 arg2 = static_cast<int >(SWIG_As_int(obj1));
44021 if (SWIG_arg_fail(2)) SWIG_fail;
44022 }
44023 }
44024 {
44025 PyThreadState* __tstate = wxPyBeginAllowThreads();
44026 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
44027
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
44032 return resultobj;
44033 fail:
44034 return NULL;
44035 }
44036
44037
44038 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
44039 PyObject *resultobj = NULL;
44040 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44041 PyObject *arg2 = (PyObject *) 0 ;
44042 wxGBPosition *arg3 = 0 ;
44043 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
44044 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
44045 int arg5 = (int) 0 ;
44046 int arg6 = (int) 0 ;
44047 PyObject *arg7 = (PyObject *) NULL ;
44048 wxGBSizerItem *result;
44049 wxGBPosition temp3 ;
44050 wxGBSpan temp4 ;
44051 PyObject * obj0 = 0 ;
44052 PyObject * obj1 = 0 ;
44053 PyObject * obj2 = 0 ;
44054 PyObject * obj3 = 0 ;
44055 PyObject * obj4 = 0 ;
44056 PyObject * obj5 = 0 ;
44057 PyObject * obj6 = 0 ;
44058 char *kwnames[] = {
44059 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
44060 };
44061
44062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 arg2 = obj1;
44066 {
44067 arg3 = &temp3;
44068 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44069 }
44070 if (obj3) {
44071 {
44072 arg4 = &temp4;
44073 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
44074 }
44075 }
44076 if (obj4) {
44077 {
44078 arg5 = static_cast<int >(SWIG_As_int(obj4));
44079 if (SWIG_arg_fail(5)) SWIG_fail;
44080 }
44081 }
44082 if (obj5) {
44083 {
44084 arg6 = static_cast<int >(SWIG_As_int(obj5));
44085 if (SWIG_arg_fail(6)) SWIG_fail;
44086 }
44087 }
44088 if (obj6) {
44089 arg7 = obj6;
44090 }
44091 {
44092 PyThreadState* __tstate = wxPyBeginAllowThreads();
44093 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
44094
44095 wxPyEndAllowThreads(__tstate);
44096 if (PyErr_Occurred()) SWIG_fail;
44097 }
44098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44099 return resultobj;
44100 fail:
44101 return NULL;
44102 }
44103
44104
44105 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
44106 PyObject *resultobj = NULL;
44107 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44108 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44109 wxGBSizerItem *result;
44110 PyObject * obj0 = 0 ;
44111 PyObject * obj1 = 0 ;
44112 char *kwnames[] = {
44113 (char *) "self",(char *) "item", NULL
44114 };
44115
44116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
44117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44118 if (SWIG_arg_fail(1)) SWIG_fail;
44119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
44120 if (SWIG_arg_fail(2)) SWIG_fail;
44121 {
44122 PyThreadState* __tstate = wxPyBeginAllowThreads();
44123 result = (wxGBSizerItem *)(arg1)->Add(arg2);
44124
44125 wxPyEndAllowThreads(__tstate);
44126 if (PyErr_Occurred()) SWIG_fail;
44127 }
44128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44129 return resultobj;
44130 fail:
44131 return NULL;
44132 }
44133
44134
44135 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44136 PyObject *resultobj = NULL;
44137 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44138 int arg2 ;
44139 int arg3 ;
44140 wxSize result;
44141 PyObject * obj0 = 0 ;
44142 PyObject * obj1 = 0 ;
44143 PyObject * obj2 = 0 ;
44144 char *kwnames[] = {
44145 (char *) "self",(char *) "row",(char *) "col", NULL
44146 };
44147
44148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
44149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44150 if (SWIG_arg_fail(1)) SWIG_fail;
44151 {
44152 arg2 = static_cast<int >(SWIG_As_int(obj1));
44153 if (SWIG_arg_fail(2)) SWIG_fail;
44154 }
44155 {
44156 arg3 = static_cast<int >(SWIG_As_int(obj2));
44157 if (SWIG_arg_fail(3)) SWIG_fail;
44158 }
44159 {
44160 PyThreadState* __tstate = wxPyBeginAllowThreads();
44161 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
44162
44163 wxPyEndAllowThreads(__tstate);
44164 if (PyErr_Occurred()) SWIG_fail;
44165 }
44166 {
44167 wxSize * resultptr;
44168 resultptr = new wxSize(static_cast<wxSize & >(result));
44169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44170 }
44171 return resultobj;
44172 fail:
44173 return NULL;
44174 }
44175
44176
44177 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44178 PyObject *resultobj = NULL;
44179 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44180 wxSize result;
44181 PyObject * obj0 = 0 ;
44182 char *kwnames[] = {
44183 (char *) "self", NULL
44184 };
44185
44186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
44187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44188 if (SWIG_arg_fail(1)) SWIG_fail;
44189 {
44190 PyThreadState* __tstate = wxPyBeginAllowThreads();
44191 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
44192
44193 wxPyEndAllowThreads(__tstate);
44194 if (PyErr_Occurred()) SWIG_fail;
44195 }
44196 {
44197 wxSize * resultptr;
44198 resultptr = new wxSize(static_cast<wxSize & >(result));
44199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44200 }
44201 return resultobj;
44202 fail:
44203 return NULL;
44204 }
44205
44206
44207 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44208 PyObject *resultobj = NULL;
44209 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44210 wxSize *arg2 = 0 ;
44211 wxSize temp2 ;
44212 PyObject * obj0 = 0 ;
44213 PyObject * obj1 = 0 ;
44214 char *kwnames[] = {
44215 (char *) "self",(char *) "sz", NULL
44216 };
44217
44218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
44219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44220 if (SWIG_arg_fail(1)) SWIG_fail;
44221 {
44222 arg2 = &temp2;
44223 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44224 }
44225 {
44226 PyThreadState* __tstate = wxPyBeginAllowThreads();
44227 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
44228
44229 wxPyEndAllowThreads(__tstate);
44230 if (PyErr_Occurred()) SWIG_fail;
44231 }
44232 Py_INCREF(Py_None); resultobj = Py_None;
44233 return resultobj;
44234 fail:
44235 return NULL;
44236 }
44237
44238
44239 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44240 PyObject *resultobj = NULL;
44241 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44242 wxWindow *arg2 = (wxWindow *) 0 ;
44243 wxGBPosition result;
44244 PyObject * obj0 = 0 ;
44245 PyObject * obj1 = 0 ;
44246
44247 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44249 if (SWIG_arg_fail(1)) SWIG_fail;
44250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44251 if (SWIG_arg_fail(2)) SWIG_fail;
44252 {
44253 PyThreadState* __tstate = wxPyBeginAllowThreads();
44254 result = (arg1)->GetItemPosition(arg2);
44255
44256 wxPyEndAllowThreads(__tstate);
44257 if (PyErr_Occurred()) SWIG_fail;
44258 }
44259 {
44260 wxGBPosition * resultptr;
44261 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44263 }
44264 return resultobj;
44265 fail:
44266 return NULL;
44267 }
44268
44269
44270 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44271 PyObject *resultobj = NULL;
44272 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44273 wxSizer *arg2 = (wxSizer *) 0 ;
44274 wxGBPosition result;
44275 PyObject * obj0 = 0 ;
44276 PyObject * obj1 = 0 ;
44277
44278 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44280 if (SWIG_arg_fail(1)) SWIG_fail;
44281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44282 if (SWIG_arg_fail(2)) SWIG_fail;
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 result = (arg1)->GetItemPosition(arg2);
44286
44287 wxPyEndAllowThreads(__tstate);
44288 if (PyErr_Occurred()) SWIG_fail;
44289 }
44290 {
44291 wxGBPosition * resultptr;
44292 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44294 }
44295 return resultobj;
44296 fail:
44297 return NULL;
44298 }
44299
44300
44301 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44302 PyObject *resultobj = NULL;
44303 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44304 size_t arg2 ;
44305 wxGBPosition result;
44306 PyObject * obj0 = 0 ;
44307 PyObject * obj1 = 0 ;
44308
44309 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44311 if (SWIG_arg_fail(1)) SWIG_fail;
44312 {
44313 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44314 if (SWIG_arg_fail(2)) SWIG_fail;
44315 }
44316 {
44317 PyThreadState* __tstate = wxPyBeginAllowThreads();
44318 result = (arg1)->GetItemPosition(arg2);
44319
44320 wxPyEndAllowThreads(__tstate);
44321 if (PyErr_Occurred()) SWIG_fail;
44322 }
44323 {
44324 wxGBPosition * resultptr;
44325 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44327 }
44328 return resultobj;
44329 fail:
44330 return NULL;
44331 }
44332
44333
44334 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44335 int argc;
44336 PyObject *argv[3];
44337 int ii;
44338
44339 argc = PyObject_Length(args);
44340 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44341 argv[ii] = PyTuple_GetItem(args,ii);
44342 }
44343 if (argc == 2) {
44344 int _v;
44345 {
44346 void *ptr;
44347 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44348 _v = 0;
44349 PyErr_Clear();
44350 } else {
44351 _v = 1;
44352 }
44353 }
44354 if (_v) {
44355 {
44356 void *ptr;
44357 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44358 _v = 0;
44359 PyErr_Clear();
44360 } else {
44361 _v = 1;
44362 }
44363 }
44364 if (_v) {
44365 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44366 }
44367 }
44368 }
44369 if (argc == 2) {
44370 int _v;
44371 {
44372 void *ptr;
44373 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44374 _v = 0;
44375 PyErr_Clear();
44376 } else {
44377 _v = 1;
44378 }
44379 }
44380 if (_v) {
44381 {
44382 void *ptr;
44383 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44384 _v = 0;
44385 PyErr_Clear();
44386 } else {
44387 _v = 1;
44388 }
44389 }
44390 if (_v) {
44391 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44392 }
44393 }
44394 }
44395 if (argc == 2) {
44396 int _v;
44397 {
44398 void *ptr;
44399 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44400 _v = 0;
44401 PyErr_Clear();
44402 } else {
44403 _v = 1;
44404 }
44405 }
44406 if (_v) {
44407 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44408 if (_v) {
44409 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44410 }
44411 }
44412 }
44413
44414 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44415 return NULL;
44416 }
44417
44418
44419 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44420 PyObject *resultobj = NULL;
44421 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44422 wxWindow *arg2 = (wxWindow *) 0 ;
44423 wxGBPosition *arg3 = 0 ;
44424 bool result;
44425 wxGBPosition temp3 ;
44426 PyObject * obj0 = 0 ;
44427 PyObject * obj1 = 0 ;
44428 PyObject * obj2 = 0 ;
44429
44430 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44432 if (SWIG_arg_fail(1)) SWIG_fail;
44433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44434 if (SWIG_arg_fail(2)) SWIG_fail;
44435 {
44436 arg3 = &temp3;
44437 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44438 }
44439 {
44440 PyThreadState* __tstate = wxPyBeginAllowThreads();
44441 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44442
44443 wxPyEndAllowThreads(__tstate);
44444 if (PyErr_Occurred()) SWIG_fail;
44445 }
44446 {
44447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44448 }
44449 return resultobj;
44450 fail:
44451 return NULL;
44452 }
44453
44454
44455 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44456 PyObject *resultobj = NULL;
44457 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44458 wxSizer *arg2 = (wxSizer *) 0 ;
44459 wxGBPosition *arg3 = 0 ;
44460 bool result;
44461 wxGBPosition temp3 ;
44462 PyObject * obj0 = 0 ;
44463 PyObject * obj1 = 0 ;
44464 PyObject * obj2 = 0 ;
44465
44466 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44468 if (SWIG_arg_fail(1)) SWIG_fail;
44469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44470 if (SWIG_arg_fail(2)) SWIG_fail;
44471 {
44472 arg3 = &temp3;
44473 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44474 }
44475 {
44476 PyThreadState* __tstate = wxPyBeginAllowThreads();
44477 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44478
44479 wxPyEndAllowThreads(__tstate);
44480 if (PyErr_Occurred()) SWIG_fail;
44481 }
44482 {
44483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44484 }
44485 return resultobj;
44486 fail:
44487 return NULL;
44488 }
44489
44490
44491 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44492 PyObject *resultobj = NULL;
44493 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44494 size_t arg2 ;
44495 wxGBPosition *arg3 = 0 ;
44496 bool result;
44497 wxGBPosition temp3 ;
44498 PyObject * obj0 = 0 ;
44499 PyObject * obj1 = 0 ;
44500 PyObject * obj2 = 0 ;
44501
44502 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44504 if (SWIG_arg_fail(1)) SWIG_fail;
44505 {
44506 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44507 if (SWIG_arg_fail(2)) SWIG_fail;
44508 }
44509 {
44510 arg3 = &temp3;
44511 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44512 }
44513 {
44514 PyThreadState* __tstate = wxPyBeginAllowThreads();
44515 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44516
44517 wxPyEndAllowThreads(__tstate);
44518 if (PyErr_Occurred()) SWIG_fail;
44519 }
44520 {
44521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44522 }
44523 return resultobj;
44524 fail:
44525 return NULL;
44526 }
44527
44528
44529 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44530 int argc;
44531 PyObject *argv[4];
44532 int ii;
44533
44534 argc = PyObject_Length(args);
44535 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44536 argv[ii] = PyTuple_GetItem(args,ii);
44537 }
44538 if (argc == 3) {
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 {
44551 void *ptr;
44552 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44553 _v = 0;
44554 PyErr_Clear();
44555 } else {
44556 _v = 1;
44557 }
44558 }
44559 if (_v) {
44560 {
44561 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44562 }
44563 if (_v) {
44564 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44565 }
44566 }
44567 }
44568 }
44569 if (argc == 3) {
44570 int _v;
44571 {
44572 void *ptr;
44573 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44574 _v = 0;
44575 PyErr_Clear();
44576 } else {
44577 _v = 1;
44578 }
44579 }
44580 if (_v) {
44581 {
44582 void *ptr;
44583 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44584 _v = 0;
44585 PyErr_Clear();
44586 } else {
44587 _v = 1;
44588 }
44589 }
44590 if (_v) {
44591 {
44592 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44593 }
44594 if (_v) {
44595 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44596 }
44597 }
44598 }
44599 }
44600 if (argc == 3) {
44601 int _v;
44602 {
44603 void *ptr;
44604 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44605 _v = 0;
44606 PyErr_Clear();
44607 } else {
44608 _v = 1;
44609 }
44610 }
44611 if (_v) {
44612 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44613 if (_v) {
44614 {
44615 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44616 }
44617 if (_v) {
44618 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44619 }
44620 }
44621 }
44622 }
44623
44624 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44625 return NULL;
44626 }
44627
44628
44629 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44630 PyObject *resultobj = NULL;
44631 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44632 wxWindow *arg2 = (wxWindow *) 0 ;
44633 wxGBSpan result;
44634 PyObject * obj0 = 0 ;
44635 PyObject * obj1 = 0 ;
44636
44637 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44639 if (SWIG_arg_fail(1)) SWIG_fail;
44640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44641 if (SWIG_arg_fail(2)) SWIG_fail;
44642 {
44643 PyThreadState* __tstate = wxPyBeginAllowThreads();
44644 result = (arg1)->GetItemSpan(arg2);
44645
44646 wxPyEndAllowThreads(__tstate);
44647 if (PyErr_Occurred()) SWIG_fail;
44648 }
44649 {
44650 wxGBSpan * resultptr;
44651 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44653 }
44654 return resultobj;
44655 fail:
44656 return NULL;
44657 }
44658
44659
44660 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44661 PyObject *resultobj = NULL;
44662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44663 wxSizer *arg2 = (wxSizer *) 0 ;
44664 wxGBSpan result;
44665 PyObject * obj0 = 0 ;
44666 PyObject * obj1 = 0 ;
44667
44668 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44670 if (SWIG_arg_fail(1)) SWIG_fail;
44671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44672 if (SWIG_arg_fail(2)) SWIG_fail;
44673 {
44674 PyThreadState* __tstate = wxPyBeginAllowThreads();
44675 result = (arg1)->GetItemSpan(arg2);
44676
44677 wxPyEndAllowThreads(__tstate);
44678 if (PyErr_Occurred()) SWIG_fail;
44679 }
44680 {
44681 wxGBSpan * resultptr;
44682 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44683 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44684 }
44685 return resultobj;
44686 fail:
44687 return NULL;
44688 }
44689
44690
44691 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44692 PyObject *resultobj = NULL;
44693 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44694 size_t arg2 ;
44695 wxGBSpan result;
44696 PyObject * obj0 = 0 ;
44697 PyObject * obj1 = 0 ;
44698
44699 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44701 if (SWIG_arg_fail(1)) SWIG_fail;
44702 {
44703 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44704 if (SWIG_arg_fail(2)) SWIG_fail;
44705 }
44706 {
44707 PyThreadState* __tstate = wxPyBeginAllowThreads();
44708 result = (arg1)->GetItemSpan(arg2);
44709
44710 wxPyEndAllowThreads(__tstate);
44711 if (PyErr_Occurred()) SWIG_fail;
44712 }
44713 {
44714 wxGBSpan * resultptr;
44715 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44716 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44717 }
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44725 int argc;
44726 PyObject *argv[3];
44727 int ii;
44728
44729 argc = PyObject_Length(args);
44730 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44731 argv[ii] = PyTuple_GetItem(args,ii);
44732 }
44733 if (argc == 2) {
44734 int _v;
44735 {
44736 void *ptr;
44737 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44738 _v = 0;
44739 PyErr_Clear();
44740 } else {
44741 _v = 1;
44742 }
44743 }
44744 if (_v) {
44745 {
44746 void *ptr;
44747 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44748 _v = 0;
44749 PyErr_Clear();
44750 } else {
44751 _v = 1;
44752 }
44753 }
44754 if (_v) {
44755 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44756 }
44757 }
44758 }
44759 if (argc == 2) {
44760 int _v;
44761 {
44762 void *ptr;
44763 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44764 _v = 0;
44765 PyErr_Clear();
44766 } else {
44767 _v = 1;
44768 }
44769 }
44770 if (_v) {
44771 {
44772 void *ptr;
44773 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44774 _v = 0;
44775 PyErr_Clear();
44776 } else {
44777 _v = 1;
44778 }
44779 }
44780 if (_v) {
44781 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44782 }
44783 }
44784 }
44785 if (argc == 2) {
44786 int _v;
44787 {
44788 void *ptr;
44789 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44790 _v = 0;
44791 PyErr_Clear();
44792 } else {
44793 _v = 1;
44794 }
44795 }
44796 if (_v) {
44797 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44798 if (_v) {
44799 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44800 }
44801 }
44802 }
44803
44804 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44805 return NULL;
44806 }
44807
44808
44809 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44810 PyObject *resultobj = NULL;
44811 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44812 wxWindow *arg2 = (wxWindow *) 0 ;
44813 wxGBSpan *arg3 = 0 ;
44814 bool result;
44815 wxGBSpan temp3 ;
44816 PyObject * obj0 = 0 ;
44817 PyObject * obj1 = 0 ;
44818 PyObject * obj2 = 0 ;
44819
44820 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44822 if (SWIG_arg_fail(1)) SWIG_fail;
44823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44824 if (SWIG_arg_fail(2)) SWIG_fail;
44825 {
44826 arg3 = &temp3;
44827 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44828 }
44829 {
44830 PyThreadState* __tstate = wxPyBeginAllowThreads();
44831 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44832
44833 wxPyEndAllowThreads(__tstate);
44834 if (PyErr_Occurred()) SWIG_fail;
44835 }
44836 {
44837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44838 }
44839 return resultobj;
44840 fail:
44841 return NULL;
44842 }
44843
44844
44845 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44846 PyObject *resultobj = NULL;
44847 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44848 wxSizer *arg2 = (wxSizer *) 0 ;
44849 wxGBSpan *arg3 = 0 ;
44850 bool result;
44851 wxGBSpan temp3 ;
44852 PyObject * obj0 = 0 ;
44853 PyObject * obj1 = 0 ;
44854 PyObject * obj2 = 0 ;
44855
44856 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44858 if (SWIG_arg_fail(1)) SWIG_fail;
44859 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44860 if (SWIG_arg_fail(2)) SWIG_fail;
44861 {
44862 arg3 = &temp3;
44863 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44864 }
44865 {
44866 PyThreadState* __tstate = wxPyBeginAllowThreads();
44867 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44868
44869 wxPyEndAllowThreads(__tstate);
44870 if (PyErr_Occurred()) SWIG_fail;
44871 }
44872 {
44873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44874 }
44875 return resultobj;
44876 fail:
44877 return NULL;
44878 }
44879
44880
44881 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44882 PyObject *resultobj = NULL;
44883 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44884 size_t arg2 ;
44885 wxGBSpan *arg3 = 0 ;
44886 bool result;
44887 wxGBSpan temp3 ;
44888 PyObject * obj0 = 0 ;
44889 PyObject * obj1 = 0 ;
44890 PyObject * obj2 = 0 ;
44891
44892 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44894 if (SWIG_arg_fail(1)) SWIG_fail;
44895 {
44896 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44897 if (SWIG_arg_fail(2)) SWIG_fail;
44898 }
44899 {
44900 arg3 = &temp3;
44901 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44902 }
44903 {
44904 PyThreadState* __tstate = wxPyBeginAllowThreads();
44905 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44906
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 {
44911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44912 }
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44920 int argc;
44921 PyObject *argv[4];
44922 int ii;
44923
44924 argc = PyObject_Length(args);
44925 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44926 argv[ii] = PyTuple_GetItem(args,ii);
44927 }
44928 if (argc == 3) {
44929 int _v;
44930 {
44931 void *ptr;
44932 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44933 _v = 0;
44934 PyErr_Clear();
44935 } else {
44936 _v = 1;
44937 }
44938 }
44939 if (_v) {
44940 {
44941 void *ptr;
44942 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44943 _v = 0;
44944 PyErr_Clear();
44945 } else {
44946 _v = 1;
44947 }
44948 }
44949 if (_v) {
44950 {
44951 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44952 }
44953 if (_v) {
44954 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44955 }
44956 }
44957 }
44958 }
44959 if (argc == 3) {
44960 int _v;
44961 {
44962 void *ptr;
44963 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44964 _v = 0;
44965 PyErr_Clear();
44966 } else {
44967 _v = 1;
44968 }
44969 }
44970 if (_v) {
44971 {
44972 void *ptr;
44973 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44974 _v = 0;
44975 PyErr_Clear();
44976 } else {
44977 _v = 1;
44978 }
44979 }
44980 if (_v) {
44981 {
44982 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44983 }
44984 if (_v) {
44985 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44986 }
44987 }
44988 }
44989 }
44990 if (argc == 3) {
44991 int _v;
44992 {
44993 void *ptr;
44994 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44995 _v = 0;
44996 PyErr_Clear();
44997 } else {
44998 _v = 1;
44999 }
45000 }
45001 if (_v) {
45002 _v = SWIG_Check_unsigned_SS_long(argv[1]);
45003 if (_v) {
45004 {
45005 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
45006 }
45007 if (_v) {
45008 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
45009 }
45010 }
45011 }
45012 }
45013
45014 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
45015 return NULL;
45016 }
45017
45018
45019 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
45020 PyObject *resultobj = NULL;
45021 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45022 wxWindow *arg2 = (wxWindow *) 0 ;
45023 wxGBSizerItem *result;
45024 PyObject * obj0 = 0 ;
45025 PyObject * obj1 = 0 ;
45026
45027 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
45028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45029 if (SWIG_arg_fail(1)) SWIG_fail;
45030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45031 if (SWIG_arg_fail(2)) SWIG_fail;
45032 {
45033 PyThreadState* __tstate = wxPyBeginAllowThreads();
45034 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
45035
45036 wxPyEndAllowThreads(__tstate);
45037 if (PyErr_Occurred()) SWIG_fail;
45038 }
45039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45040 return resultobj;
45041 fail:
45042 return NULL;
45043 }
45044
45045
45046 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
45047 PyObject *resultobj = NULL;
45048 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45049 wxSizer *arg2 = (wxSizer *) 0 ;
45050 wxGBSizerItem *result;
45051 PyObject * obj0 = 0 ;
45052 PyObject * obj1 = 0 ;
45053
45054 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
45055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45056 if (SWIG_arg_fail(1)) SWIG_fail;
45057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
45058 if (SWIG_arg_fail(2)) SWIG_fail;
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
45062
45063 wxPyEndAllowThreads(__tstate);
45064 if (PyErr_Occurred()) SWIG_fail;
45065 }
45066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45067 return resultobj;
45068 fail:
45069 return NULL;
45070 }
45071
45072
45073 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
45074 int argc;
45075 PyObject *argv[3];
45076 int ii;
45077
45078 argc = PyObject_Length(args);
45079 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
45080 argv[ii] = PyTuple_GetItem(args,ii);
45081 }
45082 if (argc == 2) {
45083 int _v;
45084 {
45085 void *ptr;
45086 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
45087 _v = 0;
45088 PyErr_Clear();
45089 } else {
45090 _v = 1;
45091 }
45092 }
45093 if (_v) {
45094 {
45095 void *ptr;
45096 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
45097 _v = 0;
45098 PyErr_Clear();
45099 } else {
45100 _v = 1;
45101 }
45102 }
45103 if (_v) {
45104 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
45105 }
45106 }
45107 }
45108 if (argc == 2) {
45109 int _v;
45110 {
45111 void *ptr;
45112 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
45113 _v = 0;
45114 PyErr_Clear();
45115 } else {
45116 _v = 1;
45117 }
45118 }
45119 if (_v) {
45120 {
45121 void *ptr;
45122 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
45123 _v = 0;
45124 PyErr_Clear();
45125 } else {
45126 _v = 1;
45127 }
45128 }
45129 if (_v) {
45130 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
45131 }
45132 }
45133 }
45134
45135 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
45136 return NULL;
45137 }
45138
45139
45140 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
45141 PyObject *resultobj = NULL;
45142 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45143 wxGBPosition *arg2 = 0 ;
45144 wxGBSizerItem *result;
45145 wxGBPosition temp2 ;
45146 PyObject * obj0 = 0 ;
45147 PyObject * obj1 = 0 ;
45148 char *kwnames[] = {
45149 (char *) "self",(char *) "pos", NULL
45150 };
45151
45152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
45153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45154 if (SWIG_arg_fail(1)) SWIG_fail;
45155 {
45156 arg2 = &temp2;
45157 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45158 }
45159 {
45160 PyThreadState* __tstate = wxPyBeginAllowThreads();
45161 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
45162
45163 wxPyEndAllowThreads(__tstate);
45164 if (PyErr_Occurred()) SWIG_fail;
45165 }
45166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45167 return resultobj;
45168 fail:
45169 return NULL;
45170 }
45171
45172
45173 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
45174 PyObject *resultobj = NULL;
45175 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45176 wxPoint *arg2 = 0 ;
45177 wxGBSizerItem *result;
45178 wxPoint temp2 ;
45179 PyObject * obj0 = 0 ;
45180 PyObject * obj1 = 0 ;
45181 char *kwnames[] = {
45182 (char *) "self",(char *) "pt", NULL
45183 };
45184
45185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
45186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45187 if (SWIG_arg_fail(1)) SWIG_fail;
45188 {
45189 arg2 = &temp2;
45190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45191 }
45192 {
45193 PyThreadState* __tstate = wxPyBeginAllowThreads();
45194 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
45195
45196 wxPyEndAllowThreads(__tstate);
45197 if (PyErr_Occurred()) SWIG_fail;
45198 }
45199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45200 return resultobj;
45201 fail:
45202 return NULL;
45203 }
45204
45205
45206 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
45207 PyObject *resultobj = NULL;
45208 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45209 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
45210 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
45211 bool result;
45212 PyObject * obj0 = 0 ;
45213 PyObject * obj1 = 0 ;
45214 PyObject * obj2 = 0 ;
45215 char *kwnames[] = {
45216 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
45217 };
45218
45219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
45220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45221 if (SWIG_arg_fail(1)) SWIG_fail;
45222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45223 if (SWIG_arg_fail(2)) SWIG_fail;
45224 if (obj2) {
45225 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45226 if (SWIG_arg_fail(3)) SWIG_fail;
45227 }
45228 {
45229 PyThreadState* __tstate = wxPyBeginAllowThreads();
45230 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
45231
45232 wxPyEndAllowThreads(__tstate);
45233 if (PyErr_Occurred()) SWIG_fail;
45234 }
45235 {
45236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45237 }
45238 return resultobj;
45239 fail:
45240 return NULL;
45241 }
45242
45243
45244 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
45245 PyObject *resultobj = NULL;
45246 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45247 wxGBPosition *arg2 = 0 ;
45248 wxGBSpan *arg3 = 0 ;
45249 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45250 bool result;
45251 wxGBPosition temp2 ;
45252 wxGBSpan temp3 ;
45253 PyObject * obj0 = 0 ;
45254 PyObject * obj1 = 0 ;
45255 PyObject * obj2 = 0 ;
45256 PyObject * obj3 = 0 ;
45257 char *kwnames[] = {
45258 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45259 };
45260
45261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45263 if (SWIG_arg_fail(1)) SWIG_fail;
45264 {
45265 arg2 = &temp2;
45266 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45267 }
45268 {
45269 arg3 = &temp3;
45270 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45271 }
45272 if (obj3) {
45273 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45274 if (SWIG_arg_fail(4)) SWIG_fail;
45275 }
45276 {
45277 PyThreadState* __tstate = wxPyBeginAllowThreads();
45278 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45279
45280 wxPyEndAllowThreads(__tstate);
45281 if (PyErr_Occurred()) SWIG_fail;
45282 }
45283 {
45284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45285 }
45286 return resultobj;
45287 fail:
45288 return NULL;
45289 }
45290
45291
45292 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45293 PyObject *obj;
45294 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45295 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45296 Py_INCREF(obj);
45297 return Py_BuildValue((char *)"");
45298 }
45299 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45300 PyObject *resultobj = NULL;
45301 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45302 wxRelationship arg2 ;
45303 wxWindow *arg3 = (wxWindow *) 0 ;
45304 wxEdge arg4 ;
45305 int arg5 = (int) 0 ;
45306 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45307 PyObject * obj0 = 0 ;
45308 PyObject * obj1 = 0 ;
45309 PyObject * obj2 = 0 ;
45310 PyObject * obj3 = 0 ;
45311 PyObject * obj4 = 0 ;
45312 PyObject * obj5 = 0 ;
45313 char *kwnames[] = {
45314 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45315 };
45316
45317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45319 if (SWIG_arg_fail(1)) SWIG_fail;
45320 {
45321 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45322 if (SWIG_arg_fail(2)) SWIG_fail;
45323 }
45324 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45325 if (SWIG_arg_fail(3)) SWIG_fail;
45326 {
45327 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45328 if (SWIG_arg_fail(4)) SWIG_fail;
45329 }
45330 if (obj4) {
45331 {
45332 arg5 = static_cast<int >(SWIG_As_int(obj4));
45333 if (SWIG_arg_fail(5)) SWIG_fail;
45334 }
45335 }
45336 if (obj5) {
45337 {
45338 arg6 = static_cast<int >(SWIG_As_int(obj5));
45339 if (SWIG_arg_fail(6)) SWIG_fail;
45340 }
45341 }
45342 {
45343 PyThreadState* __tstate = wxPyBeginAllowThreads();
45344 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45345
45346 wxPyEndAllowThreads(__tstate);
45347 if (PyErr_Occurred()) SWIG_fail;
45348 }
45349 Py_INCREF(Py_None); resultobj = Py_None;
45350 return resultobj;
45351 fail:
45352 return NULL;
45353 }
45354
45355
45356 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45357 PyObject *resultobj = NULL;
45358 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45359 wxWindow *arg2 = (wxWindow *) 0 ;
45360 int arg3 = (int) 0 ;
45361 PyObject * obj0 = 0 ;
45362 PyObject * obj1 = 0 ;
45363 PyObject * obj2 = 0 ;
45364 char *kwnames[] = {
45365 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45366 };
45367
45368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45370 if (SWIG_arg_fail(1)) SWIG_fail;
45371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45372 if (SWIG_arg_fail(2)) SWIG_fail;
45373 if (obj2) {
45374 {
45375 arg3 = static_cast<int >(SWIG_As_int(obj2));
45376 if (SWIG_arg_fail(3)) SWIG_fail;
45377 }
45378 }
45379 {
45380 PyThreadState* __tstate = wxPyBeginAllowThreads();
45381 (arg1)->LeftOf(arg2,arg3);
45382
45383 wxPyEndAllowThreads(__tstate);
45384 if (PyErr_Occurred()) SWIG_fail;
45385 }
45386 Py_INCREF(Py_None); resultobj = Py_None;
45387 return resultobj;
45388 fail:
45389 return NULL;
45390 }
45391
45392
45393 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45394 PyObject *resultobj = NULL;
45395 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45396 wxWindow *arg2 = (wxWindow *) 0 ;
45397 int arg3 = (int) 0 ;
45398 PyObject * obj0 = 0 ;
45399 PyObject * obj1 = 0 ;
45400 PyObject * obj2 = 0 ;
45401 char *kwnames[] = {
45402 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45403 };
45404
45405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45409 if (SWIG_arg_fail(2)) SWIG_fail;
45410 if (obj2) {
45411 {
45412 arg3 = static_cast<int >(SWIG_As_int(obj2));
45413 if (SWIG_arg_fail(3)) SWIG_fail;
45414 }
45415 }
45416 {
45417 PyThreadState* __tstate = wxPyBeginAllowThreads();
45418 (arg1)->RightOf(arg2,arg3);
45419
45420 wxPyEndAllowThreads(__tstate);
45421 if (PyErr_Occurred()) SWIG_fail;
45422 }
45423 Py_INCREF(Py_None); resultobj = Py_None;
45424 return resultobj;
45425 fail:
45426 return NULL;
45427 }
45428
45429
45430 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45431 PyObject *resultobj = NULL;
45432 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45433 wxWindow *arg2 = (wxWindow *) 0 ;
45434 int arg3 = (int) 0 ;
45435 PyObject * obj0 = 0 ;
45436 PyObject * obj1 = 0 ;
45437 PyObject * obj2 = 0 ;
45438 char *kwnames[] = {
45439 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45440 };
45441
45442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45444 if (SWIG_arg_fail(1)) SWIG_fail;
45445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45446 if (SWIG_arg_fail(2)) SWIG_fail;
45447 if (obj2) {
45448 {
45449 arg3 = static_cast<int >(SWIG_As_int(obj2));
45450 if (SWIG_arg_fail(3)) SWIG_fail;
45451 }
45452 }
45453 {
45454 PyThreadState* __tstate = wxPyBeginAllowThreads();
45455 (arg1)->Above(arg2,arg3);
45456
45457 wxPyEndAllowThreads(__tstate);
45458 if (PyErr_Occurred()) SWIG_fail;
45459 }
45460 Py_INCREF(Py_None); resultobj = Py_None;
45461 return resultobj;
45462 fail:
45463 return NULL;
45464 }
45465
45466
45467 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45468 PyObject *resultobj = NULL;
45469 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45470 wxWindow *arg2 = (wxWindow *) 0 ;
45471 int arg3 = (int) 0 ;
45472 PyObject * obj0 = 0 ;
45473 PyObject * obj1 = 0 ;
45474 PyObject * obj2 = 0 ;
45475 char *kwnames[] = {
45476 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45477 };
45478
45479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45481 if (SWIG_arg_fail(1)) SWIG_fail;
45482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45483 if (SWIG_arg_fail(2)) SWIG_fail;
45484 if (obj2) {
45485 {
45486 arg3 = static_cast<int >(SWIG_As_int(obj2));
45487 if (SWIG_arg_fail(3)) SWIG_fail;
45488 }
45489 }
45490 {
45491 PyThreadState* __tstate = wxPyBeginAllowThreads();
45492 (arg1)->Below(arg2,arg3);
45493
45494 wxPyEndAllowThreads(__tstate);
45495 if (PyErr_Occurred()) SWIG_fail;
45496 }
45497 Py_INCREF(Py_None); resultobj = Py_None;
45498 return resultobj;
45499 fail:
45500 return NULL;
45501 }
45502
45503
45504 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45505 PyObject *resultobj = NULL;
45506 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45507 wxWindow *arg2 = (wxWindow *) 0 ;
45508 wxEdge arg3 ;
45509 int arg4 = (int) 0 ;
45510 PyObject * obj0 = 0 ;
45511 PyObject * obj1 = 0 ;
45512 PyObject * obj2 = 0 ;
45513 PyObject * obj3 = 0 ;
45514 char *kwnames[] = {
45515 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45516 };
45517
45518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45520 if (SWIG_arg_fail(1)) SWIG_fail;
45521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45522 if (SWIG_arg_fail(2)) SWIG_fail;
45523 {
45524 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45525 if (SWIG_arg_fail(3)) SWIG_fail;
45526 }
45527 if (obj3) {
45528 {
45529 arg4 = static_cast<int >(SWIG_As_int(obj3));
45530 if (SWIG_arg_fail(4)) SWIG_fail;
45531 }
45532 }
45533 {
45534 PyThreadState* __tstate = wxPyBeginAllowThreads();
45535 (arg1)->SameAs(arg2,arg3,arg4);
45536
45537 wxPyEndAllowThreads(__tstate);
45538 if (PyErr_Occurred()) SWIG_fail;
45539 }
45540 Py_INCREF(Py_None); resultobj = Py_None;
45541 return resultobj;
45542 fail:
45543 return NULL;
45544 }
45545
45546
45547 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45548 PyObject *resultobj = NULL;
45549 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45550 wxWindow *arg2 = (wxWindow *) 0 ;
45551 wxEdge arg3 ;
45552 int arg4 ;
45553 PyObject * obj0 = 0 ;
45554 PyObject * obj1 = 0 ;
45555 PyObject * obj2 = 0 ;
45556 PyObject * obj3 = 0 ;
45557 char *kwnames[] = {
45558 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45559 };
45560
45561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45563 if (SWIG_arg_fail(1)) SWIG_fail;
45564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45565 if (SWIG_arg_fail(2)) SWIG_fail;
45566 {
45567 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45568 if (SWIG_arg_fail(3)) SWIG_fail;
45569 }
45570 {
45571 arg4 = static_cast<int >(SWIG_As_int(obj3));
45572 if (SWIG_arg_fail(4)) SWIG_fail;
45573 }
45574 {
45575 PyThreadState* __tstate = wxPyBeginAllowThreads();
45576 (arg1)->PercentOf(arg2,arg3,arg4);
45577
45578 wxPyEndAllowThreads(__tstate);
45579 if (PyErr_Occurred()) SWIG_fail;
45580 }
45581 Py_INCREF(Py_None); resultobj = Py_None;
45582 return resultobj;
45583 fail:
45584 return NULL;
45585 }
45586
45587
45588 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45589 PyObject *resultobj = NULL;
45590 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45591 int arg2 ;
45592 PyObject * obj0 = 0 ;
45593 PyObject * obj1 = 0 ;
45594 char *kwnames[] = {
45595 (char *) "self",(char *) "val", NULL
45596 };
45597
45598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45600 if (SWIG_arg_fail(1)) SWIG_fail;
45601 {
45602 arg2 = static_cast<int >(SWIG_As_int(obj1));
45603 if (SWIG_arg_fail(2)) SWIG_fail;
45604 }
45605 {
45606 PyThreadState* __tstate = wxPyBeginAllowThreads();
45607 (arg1)->Absolute(arg2);
45608
45609 wxPyEndAllowThreads(__tstate);
45610 if (PyErr_Occurred()) SWIG_fail;
45611 }
45612 Py_INCREF(Py_None); resultobj = Py_None;
45613 return resultobj;
45614 fail:
45615 return NULL;
45616 }
45617
45618
45619 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45620 PyObject *resultobj = NULL;
45621 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45622 PyObject * obj0 = 0 ;
45623 char *kwnames[] = {
45624 (char *) "self", NULL
45625 };
45626
45627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45629 if (SWIG_arg_fail(1)) SWIG_fail;
45630 {
45631 PyThreadState* __tstate = wxPyBeginAllowThreads();
45632 (arg1)->Unconstrained();
45633
45634 wxPyEndAllowThreads(__tstate);
45635 if (PyErr_Occurred()) SWIG_fail;
45636 }
45637 Py_INCREF(Py_None); resultobj = Py_None;
45638 return resultobj;
45639 fail:
45640 return NULL;
45641 }
45642
45643
45644 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45645 PyObject *resultobj = NULL;
45646 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45647 PyObject * obj0 = 0 ;
45648 char *kwnames[] = {
45649 (char *) "self", NULL
45650 };
45651
45652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45654 if (SWIG_arg_fail(1)) SWIG_fail;
45655 {
45656 PyThreadState* __tstate = wxPyBeginAllowThreads();
45657 (arg1)->AsIs();
45658
45659 wxPyEndAllowThreads(__tstate);
45660 if (PyErr_Occurred()) SWIG_fail;
45661 }
45662 Py_INCREF(Py_None); resultobj = Py_None;
45663 return resultobj;
45664 fail:
45665 return NULL;
45666 }
45667
45668
45669 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45670 PyObject *resultobj = NULL;
45671 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45672 wxWindow *result;
45673 PyObject * obj0 = 0 ;
45674 char *kwnames[] = {
45675 (char *) "self", NULL
45676 };
45677
45678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45680 if (SWIG_arg_fail(1)) SWIG_fail;
45681 {
45682 PyThreadState* __tstate = wxPyBeginAllowThreads();
45683 result = (wxWindow *)(arg1)->GetOtherWindow();
45684
45685 wxPyEndAllowThreads(__tstate);
45686 if (PyErr_Occurred()) SWIG_fail;
45687 }
45688 {
45689 resultobj = wxPyMake_wxObject(result, 0);
45690 }
45691 return resultobj;
45692 fail:
45693 return NULL;
45694 }
45695
45696
45697 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45698 PyObject *resultobj = NULL;
45699 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45700 wxEdge result;
45701 PyObject * obj0 = 0 ;
45702 char *kwnames[] = {
45703 (char *) "self", NULL
45704 };
45705
45706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45708 if (SWIG_arg_fail(1)) SWIG_fail;
45709 {
45710 PyThreadState* __tstate = wxPyBeginAllowThreads();
45711 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45712
45713 wxPyEndAllowThreads(__tstate);
45714 if (PyErr_Occurred()) SWIG_fail;
45715 }
45716 resultobj = SWIG_From_int((result));
45717 return resultobj;
45718 fail:
45719 return NULL;
45720 }
45721
45722
45723 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45724 PyObject *resultobj = NULL;
45725 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45726 wxEdge arg2 ;
45727 PyObject * obj0 = 0 ;
45728 PyObject * obj1 = 0 ;
45729 char *kwnames[] = {
45730 (char *) "self",(char *) "which", NULL
45731 };
45732
45733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45735 if (SWIG_arg_fail(1)) SWIG_fail;
45736 {
45737 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45738 if (SWIG_arg_fail(2)) SWIG_fail;
45739 }
45740 {
45741 PyThreadState* __tstate = wxPyBeginAllowThreads();
45742 (arg1)->SetEdge(arg2);
45743
45744 wxPyEndAllowThreads(__tstate);
45745 if (PyErr_Occurred()) SWIG_fail;
45746 }
45747 Py_INCREF(Py_None); resultobj = Py_None;
45748 return resultobj;
45749 fail:
45750 return NULL;
45751 }
45752
45753
45754 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45755 PyObject *resultobj = NULL;
45756 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45757 int arg2 ;
45758 PyObject * obj0 = 0 ;
45759 PyObject * obj1 = 0 ;
45760 char *kwnames[] = {
45761 (char *) "self",(char *) "v", NULL
45762 };
45763
45764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45766 if (SWIG_arg_fail(1)) SWIG_fail;
45767 {
45768 arg2 = static_cast<int >(SWIG_As_int(obj1));
45769 if (SWIG_arg_fail(2)) SWIG_fail;
45770 }
45771 {
45772 PyThreadState* __tstate = wxPyBeginAllowThreads();
45773 (arg1)->SetValue(arg2);
45774
45775 wxPyEndAllowThreads(__tstate);
45776 if (PyErr_Occurred()) SWIG_fail;
45777 }
45778 Py_INCREF(Py_None); resultobj = Py_None;
45779 return resultobj;
45780 fail:
45781 return NULL;
45782 }
45783
45784
45785 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45786 PyObject *resultobj = NULL;
45787 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45788 int result;
45789 PyObject * obj0 = 0 ;
45790 char *kwnames[] = {
45791 (char *) "self", NULL
45792 };
45793
45794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45796 if (SWIG_arg_fail(1)) SWIG_fail;
45797 {
45798 PyThreadState* __tstate = wxPyBeginAllowThreads();
45799 result = (int)(arg1)->GetMargin();
45800
45801 wxPyEndAllowThreads(__tstate);
45802 if (PyErr_Occurred()) SWIG_fail;
45803 }
45804 {
45805 resultobj = SWIG_From_int(static_cast<int >(result));
45806 }
45807 return resultobj;
45808 fail:
45809 return NULL;
45810 }
45811
45812
45813 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45814 PyObject *resultobj = NULL;
45815 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45816 int arg2 ;
45817 PyObject * obj0 = 0 ;
45818 PyObject * obj1 = 0 ;
45819 char *kwnames[] = {
45820 (char *) "self",(char *) "m", NULL
45821 };
45822
45823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45825 if (SWIG_arg_fail(1)) SWIG_fail;
45826 {
45827 arg2 = static_cast<int >(SWIG_As_int(obj1));
45828 if (SWIG_arg_fail(2)) SWIG_fail;
45829 }
45830 {
45831 PyThreadState* __tstate = wxPyBeginAllowThreads();
45832 (arg1)->SetMargin(arg2);
45833
45834 wxPyEndAllowThreads(__tstate);
45835 if (PyErr_Occurred()) SWIG_fail;
45836 }
45837 Py_INCREF(Py_None); resultobj = Py_None;
45838 return resultobj;
45839 fail:
45840 return NULL;
45841 }
45842
45843
45844 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45845 PyObject *resultobj = NULL;
45846 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45847 int result;
45848 PyObject * obj0 = 0 ;
45849 char *kwnames[] = {
45850 (char *) "self", NULL
45851 };
45852
45853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45855 if (SWIG_arg_fail(1)) SWIG_fail;
45856 {
45857 PyThreadState* __tstate = wxPyBeginAllowThreads();
45858 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45859
45860 wxPyEndAllowThreads(__tstate);
45861 if (PyErr_Occurred()) SWIG_fail;
45862 }
45863 {
45864 resultobj = SWIG_From_int(static_cast<int >(result));
45865 }
45866 return resultobj;
45867 fail:
45868 return NULL;
45869 }
45870
45871
45872 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45873 PyObject *resultobj = NULL;
45874 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45875 int result;
45876 PyObject * obj0 = 0 ;
45877 char *kwnames[] = {
45878 (char *) "self", NULL
45879 };
45880
45881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45883 if (SWIG_arg_fail(1)) SWIG_fail;
45884 {
45885 PyThreadState* __tstate = wxPyBeginAllowThreads();
45886 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45887
45888 wxPyEndAllowThreads(__tstate);
45889 if (PyErr_Occurred()) SWIG_fail;
45890 }
45891 {
45892 resultobj = SWIG_From_int(static_cast<int >(result));
45893 }
45894 return resultobj;
45895 fail:
45896 return NULL;
45897 }
45898
45899
45900 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45901 PyObject *resultobj = NULL;
45902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45903 int result;
45904 PyObject * obj0 = 0 ;
45905 char *kwnames[] = {
45906 (char *) "self", NULL
45907 };
45908
45909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45911 if (SWIG_arg_fail(1)) SWIG_fail;
45912 {
45913 PyThreadState* __tstate = wxPyBeginAllowThreads();
45914 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45915
45916 wxPyEndAllowThreads(__tstate);
45917 if (PyErr_Occurred()) SWIG_fail;
45918 }
45919 {
45920 resultobj = SWIG_From_int(static_cast<int >(result));
45921 }
45922 return resultobj;
45923 fail:
45924 return NULL;
45925 }
45926
45927
45928 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45929 PyObject *resultobj = NULL;
45930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45931 bool result;
45932 PyObject * obj0 = 0 ;
45933 char *kwnames[] = {
45934 (char *) "self", NULL
45935 };
45936
45937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45939 if (SWIG_arg_fail(1)) SWIG_fail;
45940 {
45941 PyThreadState* __tstate = wxPyBeginAllowThreads();
45942 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45943
45944 wxPyEndAllowThreads(__tstate);
45945 if (PyErr_Occurred()) SWIG_fail;
45946 }
45947 {
45948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45949 }
45950 return resultobj;
45951 fail:
45952 return NULL;
45953 }
45954
45955
45956 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45957 PyObject *resultobj = NULL;
45958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45959 bool arg2 ;
45960 PyObject * obj0 = 0 ;
45961 PyObject * obj1 = 0 ;
45962 char *kwnames[] = {
45963 (char *) "self",(char *) "d", NULL
45964 };
45965
45966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45968 if (SWIG_arg_fail(1)) SWIG_fail;
45969 {
45970 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45971 if (SWIG_arg_fail(2)) SWIG_fail;
45972 }
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 (arg1)->SetDone(arg2);
45976
45977 wxPyEndAllowThreads(__tstate);
45978 if (PyErr_Occurred()) SWIG_fail;
45979 }
45980 Py_INCREF(Py_None); resultobj = Py_None;
45981 return resultobj;
45982 fail:
45983 return NULL;
45984 }
45985
45986
45987 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45988 PyObject *resultobj = NULL;
45989 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45990 wxRelationship result;
45991 PyObject * obj0 = 0 ;
45992 char *kwnames[] = {
45993 (char *) "self", NULL
45994 };
45995
45996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45998 if (SWIG_arg_fail(1)) SWIG_fail;
45999 {
46000 PyThreadState* __tstate = wxPyBeginAllowThreads();
46001 result = (wxRelationship)(arg1)->GetRelationship();
46002
46003 wxPyEndAllowThreads(__tstate);
46004 if (PyErr_Occurred()) SWIG_fail;
46005 }
46006 resultobj = SWIG_From_int((result));
46007 return resultobj;
46008 fail:
46009 return NULL;
46010 }
46011
46012
46013 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
46014 PyObject *resultobj = NULL;
46015 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46016 wxRelationship arg2 ;
46017 PyObject * obj0 = 0 ;
46018 PyObject * obj1 = 0 ;
46019 char *kwnames[] = {
46020 (char *) "self",(char *) "r", NULL
46021 };
46022
46023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
46024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46025 if (SWIG_arg_fail(1)) SWIG_fail;
46026 {
46027 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
46028 if (SWIG_arg_fail(2)) SWIG_fail;
46029 }
46030 {
46031 PyThreadState* __tstate = wxPyBeginAllowThreads();
46032 (arg1)->SetRelationship(arg2);
46033
46034 wxPyEndAllowThreads(__tstate);
46035 if (PyErr_Occurred()) SWIG_fail;
46036 }
46037 Py_INCREF(Py_None); resultobj = Py_None;
46038 return resultobj;
46039 fail:
46040 return NULL;
46041 }
46042
46043
46044 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
46045 PyObject *resultobj = NULL;
46046 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46047 wxWindow *arg2 = (wxWindow *) 0 ;
46048 bool result;
46049 PyObject * obj0 = 0 ;
46050 PyObject * obj1 = 0 ;
46051 char *kwnames[] = {
46052 (char *) "self",(char *) "otherW", NULL
46053 };
46054
46055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
46056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46057 if (SWIG_arg_fail(1)) SWIG_fail;
46058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46059 if (SWIG_arg_fail(2)) SWIG_fail;
46060 {
46061 PyThreadState* __tstate = wxPyBeginAllowThreads();
46062 result = (bool)(arg1)->ResetIfWin(arg2);
46063
46064 wxPyEndAllowThreads(__tstate);
46065 if (PyErr_Occurred()) SWIG_fail;
46066 }
46067 {
46068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46069 }
46070 return resultobj;
46071 fail:
46072 return NULL;
46073 }
46074
46075
46076 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
46077 PyObject *resultobj = NULL;
46078 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46079 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
46080 wxWindow *arg3 = (wxWindow *) 0 ;
46081 bool result;
46082 PyObject * obj0 = 0 ;
46083 PyObject * obj1 = 0 ;
46084 PyObject * obj2 = 0 ;
46085 char *kwnames[] = {
46086 (char *) "self",(char *) "constraints",(char *) "win", NULL
46087 };
46088
46089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
46090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46091 if (SWIG_arg_fail(1)) SWIG_fail;
46092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46093 if (SWIG_arg_fail(2)) SWIG_fail;
46094 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46095 if (SWIG_arg_fail(3)) SWIG_fail;
46096 {
46097 PyThreadState* __tstate = wxPyBeginAllowThreads();
46098 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
46099
46100 wxPyEndAllowThreads(__tstate);
46101 if (PyErr_Occurred()) SWIG_fail;
46102 }
46103 {
46104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46105 }
46106 return resultobj;
46107 fail:
46108 return NULL;
46109 }
46110
46111
46112 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
46113 PyObject *resultobj = NULL;
46114 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46115 wxEdge arg2 ;
46116 wxWindow *arg3 = (wxWindow *) 0 ;
46117 wxWindow *arg4 = (wxWindow *) 0 ;
46118 int result;
46119 PyObject * obj0 = 0 ;
46120 PyObject * obj1 = 0 ;
46121 PyObject * obj2 = 0 ;
46122 PyObject * obj3 = 0 ;
46123 char *kwnames[] = {
46124 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
46125 };
46126
46127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
46128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46129 if (SWIG_arg_fail(1)) SWIG_fail;
46130 {
46131 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
46132 if (SWIG_arg_fail(2)) SWIG_fail;
46133 }
46134 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46135 if (SWIG_arg_fail(3)) SWIG_fail;
46136 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46137 if (SWIG_arg_fail(4)) SWIG_fail;
46138 {
46139 PyThreadState* __tstate = wxPyBeginAllowThreads();
46140 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
46141
46142 wxPyEndAllowThreads(__tstate);
46143 if (PyErr_Occurred()) SWIG_fail;
46144 }
46145 {
46146 resultobj = SWIG_From_int(static_cast<int >(result));
46147 }
46148 return resultobj;
46149 fail:
46150 return NULL;
46151 }
46152
46153
46154 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
46155 PyObject *obj;
46156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46157 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
46158 Py_INCREF(obj);
46159 return Py_BuildValue((char *)"");
46160 }
46161 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
46162 PyObject *resultobj = NULL;
46163 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46164 wxIndividualLayoutConstraint *result;
46165 PyObject * obj0 = 0 ;
46166 char *kwnames[] = {
46167 (char *) "self", NULL
46168 };
46169
46170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
46171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46172 if (SWIG_arg_fail(1)) SWIG_fail;
46173 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
46174
46175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46176 return resultobj;
46177 fail:
46178 return NULL;
46179 }
46180
46181
46182 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
46183 PyObject *resultobj = NULL;
46184 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46185 wxIndividualLayoutConstraint *result;
46186 PyObject * obj0 = 0 ;
46187 char *kwnames[] = {
46188 (char *) "self", NULL
46189 };
46190
46191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
46192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46193 if (SWIG_arg_fail(1)) SWIG_fail;
46194 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
46195
46196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46197 return resultobj;
46198 fail:
46199 return NULL;
46200 }
46201
46202
46203 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
46204 PyObject *resultobj = NULL;
46205 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46206 wxIndividualLayoutConstraint *result;
46207 PyObject * obj0 = 0 ;
46208 char *kwnames[] = {
46209 (char *) "self", NULL
46210 };
46211
46212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
46213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46214 if (SWIG_arg_fail(1)) SWIG_fail;
46215 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
46216
46217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46218 return resultobj;
46219 fail:
46220 return NULL;
46221 }
46222
46223
46224 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
46225 PyObject *resultobj = NULL;
46226 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46227 wxIndividualLayoutConstraint *result;
46228 PyObject * obj0 = 0 ;
46229 char *kwnames[] = {
46230 (char *) "self", NULL
46231 };
46232
46233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
46234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46235 if (SWIG_arg_fail(1)) SWIG_fail;
46236 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
46237
46238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46239 return resultobj;
46240 fail:
46241 return NULL;
46242 }
46243
46244
46245 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
46246 PyObject *resultobj = NULL;
46247 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46248 wxIndividualLayoutConstraint *result;
46249 PyObject * obj0 = 0 ;
46250 char *kwnames[] = {
46251 (char *) "self", NULL
46252 };
46253
46254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46256 if (SWIG_arg_fail(1)) SWIG_fail;
46257 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46258
46259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46260 return resultobj;
46261 fail:
46262 return NULL;
46263 }
46264
46265
46266 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46267 PyObject *resultobj = NULL;
46268 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46269 wxIndividualLayoutConstraint *result;
46270 PyObject * obj0 = 0 ;
46271 char *kwnames[] = {
46272 (char *) "self", NULL
46273 };
46274
46275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46277 if (SWIG_arg_fail(1)) SWIG_fail;
46278 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46279
46280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46281 return resultobj;
46282 fail:
46283 return NULL;
46284 }
46285
46286
46287 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
46288 PyObject *resultobj = NULL;
46289 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46290 wxIndividualLayoutConstraint *result;
46291 PyObject * obj0 = 0 ;
46292 char *kwnames[] = {
46293 (char *) "self", NULL
46294 };
46295
46296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
46297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46298 if (SWIG_arg_fail(1)) SWIG_fail;
46299 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
46300
46301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46302 return resultobj;
46303 fail:
46304 return NULL;
46305 }
46306
46307
46308 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
46309 PyObject *resultobj = NULL;
46310 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46311 wxIndividualLayoutConstraint *result;
46312 PyObject * obj0 = 0 ;
46313 char *kwnames[] = {
46314 (char *) "self", NULL
46315 };
46316
46317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
46318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46319 if (SWIG_arg_fail(1)) SWIG_fail;
46320 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
46321
46322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46323 return resultobj;
46324 fail:
46325 return NULL;
46326 }
46327
46328
46329 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46330 PyObject *resultobj = NULL;
46331 wxLayoutConstraints *result;
46332 char *kwnames[] = {
46333 NULL
46334 };
46335
46336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46337 {
46338 PyThreadState* __tstate = wxPyBeginAllowThreads();
46339 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46340
46341 wxPyEndAllowThreads(__tstate);
46342 if (PyErr_Occurred()) SWIG_fail;
46343 }
46344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46345 return resultobj;
46346 fail:
46347 return NULL;
46348 }
46349
46350
46351 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46352 PyObject *resultobj = NULL;
46353 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46354 wxWindow *arg2 = (wxWindow *) 0 ;
46355 int *arg3 = (int *) 0 ;
46356 bool result;
46357 int temp3 ;
46358 int res3 = 0 ;
46359 PyObject * obj0 = 0 ;
46360 PyObject * obj1 = 0 ;
46361 char *kwnames[] = {
46362 (char *) "self",(char *) "win", NULL
46363 };
46364
46365 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46368 if (SWIG_arg_fail(1)) SWIG_fail;
46369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46370 if (SWIG_arg_fail(2)) SWIG_fail;
46371 {
46372 PyThreadState* __tstate = wxPyBeginAllowThreads();
46373 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46374
46375 wxPyEndAllowThreads(__tstate);
46376 if (PyErr_Occurred()) SWIG_fail;
46377 }
46378 {
46379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46380 }
46381 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46382 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46383 return resultobj;
46384 fail:
46385 return NULL;
46386 }
46387
46388
46389 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46390 PyObject *resultobj = NULL;
46391 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46392 bool result;
46393 PyObject * obj0 = 0 ;
46394 char *kwnames[] = {
46395 (char *) "self", NULL
46396 };
46397
46398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46400 if (SWIG_arg_fail(1)) SWIG_fail;
46401 {
46402 PyThreadState* __tstate = wxPyBeginAllowThreads();
46403 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46404
46405 wxPyEndAllowThreads(__tstate);
46406 if (PyErr_Occurred()) SWIG_fail;
46407 }
46408 {
46409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46410 }
46411 return resultobj;
46412 fail:
46413 return NULL;
46414 }
46415
46416
46417 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46418 PyObject *obj;
46419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46420 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46421 Py_INCREF(obj);
46422 return Py_BuildValue((char *)"");
46423 }
46424 static PyMethodDef SwigMethods[] = {
46425 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46426 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46427 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46430 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46451 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46464 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46479 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46534 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46562 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46581 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46583 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46591 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46592 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46604 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46616 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46620 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46626 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46636 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46646 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46649 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46656 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46664 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46672 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46756 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46758 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46760 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46762 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46764 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46766 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46768 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46770 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46772 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46774 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46776 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46778 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46780 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46794 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46812 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46815 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46818 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46830 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46835 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46841 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46847 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46910 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46917 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"KeyEvent_GetModifiers", (PyCFunction) _wrap_KeyEvent_GetModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46954 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46964 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46970 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46972 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46974 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46977 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46981 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46984 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46987 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46989 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46994 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
47002 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
47006 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
47009 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
47011 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
47015 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"UpdateUIEvent_GetShown", (PyCFunction) _wrap_UpdateUIEvent_GetShown, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction) _wrap_UpdateUIEvent_GetSetShown, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
47035 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
47037 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
47040 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
47042 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
47046 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
47050 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
47061 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
47064 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
47067 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
47071 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
47078 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
47083 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
47088 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
47092 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
47137 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
47157 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
47160 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
47167 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
47171 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
47181 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47287 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47351 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47388 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47390 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47392 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47402 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47405 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47407 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47410 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47413 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47440 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47459 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47465 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47466 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47468 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47469 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47470 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47475 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47480 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47494 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47502 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47514 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47516 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47517 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47518 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47519 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47520 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47521 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47522 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47523 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47524 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47525 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47526 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47527 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47528 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47529 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47530 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47531 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47532 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47533 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47534 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47535 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47536 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47537 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47538 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47539 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47540 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47541 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47542 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47543 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47544 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47545 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47546 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47547 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47548 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47549 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47550 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47551 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47552 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47553 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47554 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47555 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47556 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47557 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47558 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47559 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47560 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47561 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47562 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47563 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47564 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47565 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47566 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47567 { (char *)"delete_SizerItem", (PyCFunction) _wrap_delete_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47568 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47569 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47570 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47571 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47572 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47573 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47574 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47575 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47576 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47577 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47578 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47579 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47580 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47581 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47582 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47583 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47584 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47585 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47586 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47587 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47588 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47589 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47590 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47591 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47592 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47593 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47594 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47595 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47596 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47597 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47598 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47599 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47600 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47601 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47602 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47603 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47604 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47605 { (char *)"delete_Sizer", (PyCFunction) _wrap_delete_Sizer, METH_VARARGS | METH_KEYWORDS, NULL},
47606 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47607 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47608 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47609 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47610 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47611 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47612 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47613 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47614 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47615 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47616 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47617 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47618 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47619 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47620 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47621 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47622 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47623 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47624 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47625 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47626 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47627 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47628 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47629 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47630 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47631 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47632 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47633 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47634 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47635 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47636 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47637 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47638 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47639 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47640 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47641 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47642 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47643 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47644 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47645 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47646 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47647 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47648 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47649 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47650 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47651 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47652 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47653 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47654 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47655 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47656 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47657 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47658 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47659 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47660 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47661 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47662 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47663 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47664 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47665 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47666 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47667 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47668 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47669 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47670 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47671 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47672 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47673 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47674 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47675 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47676 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47677 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47678 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47679 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47680 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47681 { (char *)"delete_GBPosition", (PyCFunction) _wrap_delete_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47682 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47683 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47684 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47685 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47686 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47687 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47688 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47689 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47690 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47691 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47692 { (char *)"delete_GBSpan", (PyCFunction) _wrap_delete_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47693 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47694 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47695 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47696 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47697 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47698 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47699 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47700 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47701 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47702 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47703 { (char *)"delete_GBSizerItem", (PyCFunction) _wrap_delete_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47704 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47705 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47706 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47707 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47708 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47709 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47710 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47711 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47712 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47713 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47714 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47715 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47716 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47717 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47718 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47719 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47720 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47721 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47722 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47723 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47724 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47725 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47726 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47727 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47728 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47729 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47730 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47731 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47732 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47733 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47734 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47735 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47736 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47737 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47738 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47739 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47740 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47741 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47742 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47743 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47744 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47745 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47746 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47747 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47748 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47749 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47750 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47751 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47752 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47753 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47754 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47755 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47756 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47757 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47758 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47759 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47760 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47761 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47762 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47763 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47764 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47765 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47766 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47767 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47768 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47769 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47770 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47771 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47772 { NULL, NULL, 0, NULL }
47773 };
47774
47775
47776 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47777
47778 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47779 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47780 }
47781 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47782 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47783 }
47784 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47785 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47786 }
47787 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47788 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47789 }
47790 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47791 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47792 }
47793 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47794 return (void *)((wxSizer *) ((wxGridSizer *) x));
47795 }
47796 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47797 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47798 }
47799 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47800 return (void *)((wxSizer *) ((wxPySizer *) x));
47801 }
47802 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47803 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47804 }
47805 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47806 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47807 }
47808 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47809 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47810 }
47811 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47812 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47813 }
47814 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47815 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47816 }
47817 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47818 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47819 }
47820 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47821 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47822 }
47823 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47824 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47825 }
47826 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47827 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47828 }
47829 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47830 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47831 }
47832 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47833 return (void *)((wxEvent *) ((wxPyEvent *) x));
47834 }
47835 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47836 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47837 }
47838 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47839 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47840 }
47841 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47842 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47843 }
47844 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47845 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47846 }
47847 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47848 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47849 }
47850 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47851 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47852 }
47853 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47854 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47855 }
47856 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47857 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47858 }
47859 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47860 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47861 }
47862 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47863 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47864 }
47865 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47866 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47867 }
47868 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47869 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47870 }
47871 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47872 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47873 }
47874 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47875 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47876 }
47877 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47878 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47879 }
47880 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47881 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47882 }
47883 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47884 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47885 }
47886 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47887 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47888 }
47889 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47890 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47891 }
47892 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47893 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47894 }
47895 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47896 return (void *)((wxEvent *) ((wxShowEvent *) x));
47897 }
47898 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47899 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47900 }
47901 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47902 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47903 }
47904 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47905 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47906 }
47907 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47908 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47909 }
47910 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47911 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47912 }
47913 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47914 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47915 }
47916 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47917 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47918 }
47919 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47920 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47921 }
47922 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47923 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47924 }
47925 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47926 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47927 }
47928 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47929 return (void *)((wxControl *) ((wxControlWithItems *) x));
47930 }
47931 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47932 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47933 }
47934 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47935 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47936 }
47937 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47938 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47939 }
47940 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47941 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47942 }
47943 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47944 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47945 }
47946 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47947 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47948 }
47949 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47950 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47951 }
47952 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47953 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47954 }
47955 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47956 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47957 }
47958 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47959 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47960 }
47961 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47962 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47963 }
47964 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47965 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47966 }
47967 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47968 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47969 }
47970 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47971 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47972 }
47973 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47974 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47975 }
47976 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47977 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47978 }
47979 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47980 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47981 }
47982 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47983 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47984 }
47985 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47986 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47987 }
47988 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47989 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47990 }
47991 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47992 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47993 }
47994 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47995 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47996 }
47997 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47998 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47999 }
48000 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
48001 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
48002 }
48003 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
48004 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
48005 }
48006 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
48007 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
48008 }
48009 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
48010 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
48011 }
48012 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
48013 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
48014 }
48015 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
48016 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
48017 }
48018 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
48019 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
48020 }
48021 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
48022 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
48023 }
48024 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
48025 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
48026 }
48027 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
48028 return (void *)((wxObject *) ((wxSizerItem *) x));
48029 }
48030 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
48031 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
48032 }
48033 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
48034 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
48035 }
48036 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
48037 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
48038 }
48039 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
48040 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
48041 }
48042 static void *_p_wxSizerTo_p_wxObject(void *x) {
48043 return (void *)((wxObject *) ((wxSizer *) x));
48044 }
48045 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
48046 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
48047 }
48048 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
48049 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
48050 }
48051 static void *_p_wxEventTo_p_wxObject(void *x) {
48052 return (void *)((wxObject *) ((wxEvent *) x));
48053 }
48054 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
48055 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
48056 }
48057 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
48058 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
48059 }
48060 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
48061 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
48062 }
48063 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
48064 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
48065 }
48066 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
48067 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
48068 }
48069 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
48070 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
48071 }
48072 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
48073 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
48074 }
48075 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
48076 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
48077 }
48078 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
48079 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
48080 }
48081 static void *_p_wxControlTo_p_wxObject(void *x) {
48082 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
48083 }
48084 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
48085 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
48086 }
48087 static void *_p_wxFSFileTo_p_wxObject(void *x) {
48088 return (void *)((wxObject *) ((wxFSFile *) x));
48089 }
48090 static void *_p_wxPySizerTo_p_wxObject(void *x) {
48091 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
48092 }
48093 static void *_p_wxPyEventTo_p_wxObject(void *x) {
48094 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
48095 }
48096 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
48097 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
48098 }
48099 static void *_p_wxShowEventTo_p_wxObject(void *x) {
48100 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
48101 }
48102 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
48103 return (void *)((wxObject *) ((wxMenuItem *) x));
48104 }
48105 static void *_p_wxDateEventTo_p_wxObject(void *x) {
48106 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
48107 }
48108 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
48109 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
48110 }
48111 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
48112 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
48113 }
48114 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
48115 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
48116 }
48117 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
48118 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
48119 }
48120 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
48121 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
48122 }
48123 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
48124 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
48125 }
48126 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
48127 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
48128 }
48129 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
48130 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
48131 }
48132 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
48133 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
48134 }
48135 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
48136 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
48137 }
48138 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
48139 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
48140 }
48141 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
48142 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
48143 }
48144 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
48145 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
48146 }
48147 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
48148 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
48149 }
48150 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
48151 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
48152 }
48153 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
48154 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
48155 }
48156 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
48157 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
48158 }
48159 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
48160 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
48161 }
48162 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
48163 return (void *)((wxObject *) ((wxImageHandler *) x));
48164 }
48165 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
48166 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
48167 }
48168 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
48169 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
48170 }
48171 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
48172 return (void *)((wxObject *) ((wxEvtHandler *) x));
48173 }
48174 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
48175 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
48176 }
48177 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
48178 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
48179 }
48180 static void *_p_wxImageTo_p_wxObject(void *x) {
48181 return (void *)((wxObject *) ((wxImage *) x));
48182 }
48183 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
48184 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
48185 }
48186 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
48187 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48188 }
48189 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
48190 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
48191 }
48192 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
48193 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
48194 }
48195 static void *_p_wxWindowTo_p_wxObject(void *x) {
48196 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
48197 }
48198 static void *_p_wxMenuTo_p_wxObject(void *x) {
48199 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
48200 }
48201 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
48202 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
48203 }
48204 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
48205 return (void *)((wxObject *) ((wxFileSystem *) x));
48206 }
48207 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
48208 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
48209 }
48210 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
48211 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
48212 }
48213 static void *_p_wxPyAppTo_p_wxObject(void *x) {
48214 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
48215 }
48216 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
48217 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
48218 }
48219 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
48220 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
48221 }
48222 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
48223 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
48224 }
48225 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
48226 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
48227 }
48228 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
48229 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
48230 }
48231 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
48232 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
48233 }
48234 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
48235 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
48236 }
48237 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
48238 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
48239 }
48240 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
48241 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
48242 }
48243 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
48244 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
48245 }
48246 static void *_p_wxValidatorTo_p_wxObject(void *x) {
48247 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
48248 }
48249 static void *_p_wxControlTo_p_wxWindow(void *x) {
48250 return (void *)((wxWindow *) ((wxControl *) x));
48251 }
48252 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
48253 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
48254 }
48255 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48256 return (void *)((wxWindow *) ((wxMenuBar *) x));
48257 }
48258 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48259 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48260 }
48261 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48262 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48263 }
48264 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48265 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48266 }
48267 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48268 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48269 }
48270 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48271 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48272 }
48273 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48274 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48275 }
48276 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48277 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48278 }
48279 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48280 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48281 }
48282 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48283 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48284 }
48285 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48286 return (void *)((wxValidator *) ((wxPyValidator *) x));
48287 }
48288 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48289 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48290 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48291 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48292 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48293 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48294 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48295 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48296 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48297 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48298 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48299 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48300 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48301 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48302 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48303 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48304 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48305 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48306 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48307 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48308 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48309 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48310 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48311 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48312 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48313 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48314 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48315 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48316 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48317 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48318 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48319 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48320 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48321 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48322 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48323 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48324 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48325 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48326 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48327 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48328 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48329 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48330 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48331 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48332 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48333 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48334 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48335 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48336 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48337 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48338 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48339 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48340 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48341 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48342 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48343 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48344 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48345 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48346 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48347 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48348 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48349 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48350 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48351 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48352 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48353 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48354 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48355 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48356 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48357 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48358 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48359 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48360 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48361 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48362 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48363 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48364 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48365 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48366 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48367 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48368 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48369 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48370 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48371 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48372 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48373 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48374 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48375 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48376 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48377 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48378 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48379 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48380 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48381 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48382 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48383 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48384 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48385 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48386 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48387 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48388 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48389 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48390 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48391 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48392 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48393 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48394 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48395 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48396 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48397 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48398 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48399 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48400 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48401 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48402 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48403 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48404 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48405 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48406 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48407 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48408 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48409 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48410 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48411 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48412 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48413 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48414 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48415 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48416 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48417 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48418 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48419 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48420
48421 static swig_type_info *swig_type_initial[] = {
48422 &_swigt__p_buffer,
48423 &_swigt__p_char,
48424 &_swigt__p_form_ops_t,
48425 &_swigt__p_int,
48426 &_swigt__p_long,
48427 &_swigt__p_unsigned_char,
48428 &_swigt__p_unsigned_int,
48429 &_swigt__p_unsigned_long,
48430 &_swigt__p_wxANIHandler,
48431 &_swigt__p_wxAcceleratorEntry,
48432 &_swigt__p_wxAcceleratorTable,
48433 &_swigt__p_wxActivateEvent,
48434 &_swigt__p_wxAppTraits,
48435 &_swigt__p_wxArrayString,
48436 &_swigt__p_wxBMPHandler,
48437 &_swigt__p_wxBitmap,
48438 &_swigt__p_wxBoxSizer,
48439 &_swigt__p_wxButton,
48440 &_swigt__p_wxCURHandler,
48441 &_swigt__p_wxCaret,
48442 &_swigt__p_wxChildFocusEvent,
48443 &_swigt__p_wxCloseEvent,
48444 &_swigt__p_wxColour,
48445 &_swigt__p_wxCommandEvent,
48446 &_swigt__p_wxContextMenuEvent,
48447 &_swigt__p_wxControl,
48448 &_swigt__p_wxControlWithItems,
48449 &_swigt__p_wxCursor,
48450 &_swigt__p_wxDC,
48451 &_swigt__p_wxDateEvent,
48452 &_swigt__p_wxDateTime,
48453 &_swigt__p_wxDisplayChangedEvent,
48454 &_swigt__p_wxDropFilesEvent,
48455 &_swigt__p_wxDuplexMode,
48456 &_swigt__p_wxEraseEvent,
48457 &_swigt__p_wxEvent,
48458 &_swigt__p_wxEventLoop,
48459 &_swigt__p_wxEventLoopActivator,
48460 &_swigt__p_wxEvtHandler,
48461 &_swigt__p_wxFSFile,
48462 &_swigt__p_wxFileSystem,
48463 &_swigt__p_wxFileSystemHandler,
48464 &_swigt__p_wxFlexGridSizer,
48465 &_swigt__p_wxFocusEvent,
48466 &_swigt__p_wxFont,
48467 &_swigt__p_wxFrame,
48468 &_swigt__p_wxGBPosition,
48469 &_swigt__p_wxGBSizerItem,
48470 &_swigt__p_wxGBSpan,
48471 &_swigt__p_wxGIFHandler,
48472 &_swigt__p_wxGridBagSizer,
48473 &_swigt__p_wxGridSizer,
48474 &_swigt__p_wxICOHandler,
48475 &_swigt__p_wxIconizeEvent,
48476 &_swigt__p_wxIdleEvent,
48477 &_swigt__p_wxImage,
48478 &_swigt__p_wxImageHandler,
48479 &_swigt__p_wxImageHistogram,
48480 &_swigt__p_wxImage_HSVValue,
48481 &_swigt__p_wxImage_RGBValue,
48482 &_swigt__p_wxIndividualLayoutConstraint,
48483 &_swigt__p_wxInitDialogEvent,
48484 &_swigt__p_wxInputStream,
48485 &_swigt__p_wxInternetFSHandler,
48486 &_swigt__p_wxItemContainer,
48487 &_swigt__p_wxJPEGHandler,
48488 &_swigt__p_wxKeyEvent,
48489 &_swigt__p_wxLayoutConstraints,
48490 &_swigt__p_wxMaximizeEvent,
48491 &_swigt__p_wxMemoryFSHandler,
48492 &_swigt__p_wxMenu,
48493 &_swigt__p_wxMenuBar,
48494 &_swigt__p_wxMenuBarBase,
48495 &_swigt__p_wxMenuEvent,
48496 &_swigt__p_wxMenuItem,
48497 &_swigt__p_wxMouseCaptureChangedEvent,
48498 &_swigt__p_wxMouseEvent,
48499 &_swigt__p_wxMoveEvent,
48500 &_swigt__p_wxNavigationKeyEvent,
48501 &_swigt__p_wxNcPaintEvent,
48502 &_swigt__p_wxNotifyEvent,
48503 &_swigt__p_wxObject,
48504 &_swigt__p_wxOutputStream,
48505 &_swigt__p_wxPCXHandler,
48506 &_swigt__p_wxPNGHandler,
48507 &_swigt__p_wxPNMHandler,
48508 &_swigt__p_wxPaintEvent,
48509 &_swigt__p_wxPaletteChangedEvent,
48510 &_swigt__p_wxPaperSize,
48511 &_swigt__p_wxPoint,
48512 &_swigt__p_wxPoint2D,
48513 &_swigt__p_wxPropagateOnce,
48514 &_swigt__p_wxPropagationDisabler,
48515 &_swigt__p_wxPyApp,
48516 &_swigt__p_wxPyCommandEvent,
48517 &_swigt__p_wxPyDropTarget,
48518 &_swigt__p_wxPyEvent,
48519 &_swigt__p_wxPyFileSystemHandler,
48520 &_swigt__p_wxPyImageHandler,
48521 &_swigt__p_wxPyInputStream,
48522 &_swigt__p_wxPySizer,
48523 &_swigt__p_wxPyValidator,
48524 &_swigt__p_wxQuantize,
48525 &_swigt__p_wxQueryNewPaletteEvent,
48526 &_swigt__p_wxRealPoint,
48527 &_swigt__p_wxRect,
48528 &_swigt__p_wxRegion,
48529 &_swigt__p_wxScrollEvent,
48530 &_swigt__p_wxScrollWinEvent,
48531 &_swigt__p_wxSetCursorEvent,
48532 &_swigt__p_wxShowEvent,
48533 &_swigt__p_wxSize,
48534 &_swigt__p_wxSizeEvent,
48535 &_swigt__p_wxSizer,
48536 &_swigt__p_wxSizerItem,
48537 &_swigt__p_wxStaticBox,
48538 &_swigt__p_wxStaticBoxSizer,
48539 &_swigt__p_wxStdDialogButtonSizer,
48540 &_swigt__p_wxSysColourChangedEvent,
48541 &_swigt__p_wxTIFFHandler,
48542 &_swigt__p_wxToolTip,
48543 &_swigt__p_wxUpdateUIEvent,
48544 &_swigt__p_wxValidator,
48545 &_swigt__p_wxVisualAttributes,
48546 &_swigt__p_wxWindow,
48547 &_swigt__p_wxWindowCreateEvent,
48548 &_swigt__p_wxWindowDestroyEvent,
48549 &_swigt__p_wxXPMHandler,
48550 &_swigt__p_wxZipFSHandler,
48551 &_swigt__ptrdiff_t,
48552 &_swigt__std__ptrdiff_t,
48553 &_swigt__unsigned_int,
48554 };
48555
48556 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48557 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48558 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48559 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48560 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48561 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48562 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48563 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48564 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48565 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48566 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48567 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48568 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48569 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48570 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}};
48571 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48572 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}};
48573 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48574 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}};
48575 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48576 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48577 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48578 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48579 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}};
48580 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48581 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}};
48582 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48583 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48584 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48585 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48586 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48587 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48588 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48589 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48590 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48591 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}};
48592 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48593 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48594 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}};
48595 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48596 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48597 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}};
48598 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}};
48599 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48600 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48601 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48602 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48603 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48604 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48605 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48606 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48607 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}};
48608 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}};
48609 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48610 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48611 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48612 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}};
48613 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48614 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48615 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48616 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48617 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48618 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48619 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48620 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}};
48621 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48622 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48623 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48624 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48625 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48626 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48627 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48628 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48629 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48630 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48631 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48632 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48633 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48634 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48635 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48636 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48637 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}};
48638 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48639 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48640 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48641 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48642 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48643 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48644 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48645 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48646 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48647 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48648 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48649 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48650 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48651 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48652 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48653 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48654 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48655 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48656 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48657 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48658 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48659 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48660 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48661 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48662 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48663 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48664 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48665 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48666 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48667 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48668 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48669 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}};
48670 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}};
48671 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48672 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48673 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48674 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48675 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48676 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48677 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48678 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}};
48679 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48680 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}};
48681 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48682 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48683 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48684 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48685 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48686 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48687 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48688
48689 static swig_cast_info *swig_cast_initial[] = {
48690 _swigc__p_buffer,
48691 _swigc__p_char,
48692 _swigc__p_form_ops_t,
48693 _swigc__p_int,
48694 _swigc__p_long,
48695 _swigc__p_unsigned_char,
48696 _swigc__p_unsigned_int,
48697 _swigc__p_unsigned_long,
48698 _swigc__p_wxANIHandler,
48699 _swigc__p_wxAcceleratorEntry,
48700 _swigc__p_wxAcceleratorTable,
48701 _swigc__p_wxActivateEvent,
48702 _swigc__p_wxAppTraits,
48703 _swigc__p_wxArrayString,
48704 _swigc__p_wxBMPHandler,
48705 _swigc__p_wxBitmap,
48706 _swigc__p_wxBoxSizer,
48707 _swigc__p_wxButton,
48708 _swigc__p_wxCURHandler,
48709 _swigc__p_wxCaret,
48710 _swigc__p_wxChildFocusEvent,
48711 _swigc__p_wxCloseEvent,
48712 _swigc__p_wxColour,
48713 _swigc__p_wxCommandEvent,
48714 _swigc__p_wxContextMenuEvent,
48715 _swigc__p_wxControl,
48716 _swigc__p_wxControlWithItems,
48717 _swigc__p_wxCursor,
48718 _swigc__p_wxDC,
48719 _swigc__p_wxDateEvent,
48720 _swigc__p_wxDateTime,
48721 _swigc__p_wxDisplayChangedEvent,
48722 _swigc__p_wxDropFilesEvent,
48723 _swigc__p_wxDuplexMode,
48724 _swigc__p_wxEraseEvent,
48725 _swigc__p_wxEvent,
48726 _swigc__p_wxEventLoop,
48727 _swigc__p_wxEventLoopActivator,
48728 _swigc__p_wxEvtHandler,
48729 _swigc__p_wxFSFile,
48730 _swigc__p_wxFileSystem,
48731 _swigc__p_wxFileSystemHandler,
48732 _swigc__p_wxFlexGridSizer,
48733 _swigc__p_wxFocusEvent,
48734 _swigc__p_wxFont,
48735 _swigc__p_wxFrame,
48736 _swigc__p_wxGBPosition,
48737 _swigc__p_wxGBSizerItem,
48738 _swigc__p_wxGBSpan,
48739 _swigc__p_wxGIFHandler,
48740 _swigc__p_wxGridBagSizer,
48741 _swigc__p_wxGridSizer,
48742 _swigc__p_wxICOHandler,
48743 _swigc__p_wxIconizeEvent,
48744 _swigc__p_wxIdleEvent,
48745 _swigc__p_wxImage,
48746 _swigc__p_wxImageHandler,
48747 _swigc__p_wxImageHistogram,
48748 _swigc__p_wxImage_HSVValue,
48749 _swigc__p_wxImage_RGBValue,
48750 _swigc__p_wxIndividualLayoutConstraint,
48751 _swigc__p_wxInitDialogEvent,
48752 _swigc__p_wxInputStream,
48753 _swigc__p_wxInternetFSHandler,
48754 _swigc__p_wxItemContainer,
48755 _swigc__p_wxJPEGHandler,
48756 _swigc__p_wxKeyEvent,
48757 _swigc__p_wxLayoutConstraints,
48758 _swigc__p_wxMaximizeEvent,
48759 _swigc__p_wxMemoryFSHandler,
48760 _swigc__p_wxMenu,
48761 _swigc__p_wxMenuBar,
48762 _swigc__p_wxMenuBarBase,
48763 _swigc__p_wxMenuEvent,
48764 _swigc__p_wxMenuItem,
48765 _swigc__p_wxMouseCaptureChangedEvent,
48766 _swigc__p_wxMouseEvent,
48767 _swigc__p_wxMoveEvent,
48768 _swigc__p_wxNavigationKeyEvent,
48769 _swigc__p_wxNcPaintEvent,
48770 _swigc__p_wxNotifyEvent,
48771 _swigc__p_wxObject,
48772 _swigc__p_wxOutputStream,
48773 _swigc__p_wxPCXHandler,
48774 _swigc__p_wxPNGHandler,
48775 _swigc__p_wxPNMHandler,
48776 _swigc__p_wxPaintEvent,
48777 _swigc__p_wxPaletteChangedEvent,
48778 _swigc__p_wxPaperSize,
48779 _swigc__p_wxPoint,
48780 _swigc__p_wxPoint2D,
48781 _swigc__p_wxPropagateOnce,
48782 _swigc__p_wxPropagationDisabler,
48783 _swigc__p_wxPyApp,
48784 _swigc__p_wxPyCommandEvent,
48785 _swigc__p_wxPyDropTarget,
48786 _swigc__p_wxPyEvent,
48787 _swigc__p_wxPyFileSystemHandler,
48788 _swigc__p_wxPyImageHandler,
48789 _swigc__p_wxPyInputStream,
48790 _swigc__p_wxPySizer,
48791 _swigc__p_wxPyValidator,
48792 _swigc__p_wxQuantize,
48793 _swigc__p_wxQueryNewPaletteEvent,
48794 _swigc__p_wxRealPoint,
48795 _swigc__p_wxRect,
48796 _swigc__p_wxRegion,
48797 _swigc__p_wxScrollEvent,
48798 _swigc__p_wxScrollWinEvent,
48799 _swigc__p_wxSetCursorEvent,
48800 _swigc__p_wxShowEvent,
48801 _swigc__p_wxSize,
48802 _swigc__p_wxSizeEvent,
48803 _swigc__p_wxSizer,
48804 _swigc__p_wxSizerItem,
48805 _swigc__p_wxStaticBox,
48806 _swigc__p_wxStaticBoxSizer,
48807 _swigc__p_wxStdDialogButtonSizer,
48808 _swigc__p_wxSysColourChangedEvent,
48809 _swigc__p_wxTIFFHandler,
48810 _swigc__p_wxToolTip,
48811 _swigc__p_wxUpdateUIEvent,
48812 _swigc__p_wxValidator,
48813 _swigc__p_wxVisualAttributes,
48814 _swigc__p_wxWindow,
48815 _swigc__p_wxWindowCreateEvent,
48816 _swigc__p_wxWindowDestroyEvent,
48817 _swigc__p_wxXPMHandler,
48818 _swigc__p_wxZipFSHandler,
48819 _swigc__ptrdiff_t,
48820 _swigc__std__ptrdiff_t,
48821 _swigc__unsigned_int,
48822 };
48823
48824
48825 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48826
48827 static swig_const_info swig_const_table[] = {
48828 {0, 0, 0, 0.0, 0, 0}};
48829
48830 #ifdef __cplusplus
48831 }
48832 #endif
48833 /*************************************************************************
48834 * Type initialization:
48835 * This problem is tough by the requirement that no dynamic
48836 * memory is used. Also, since swig_type_info structures store pointers to
48837 * swig_cast_info structures and swig_cast_info structures store pointers back
48838 * to swig_type_info structures, we need some lookup code at initialization.
48839 * The idea is that swig generates all the structures that are needed.
48840 * The runtime then collects these partially filled structures.
48841 * The SWIG_InitializeModule function takes these initial arrays out of
48842 * swig_module, and does all the lookup, filling in the swig_module.types
48843 * array with the correct data and linking the correct swig_cast_info
48844 * structures together.
48845
48846 * The generated swig_type_info structures are assigned staticly to an initial
48847 * array. We just loop though that array, and handle each type individually.
48848 * First we lookup if this type has been already loaded, and if so, use the
48849 * loaded structure instead of the generated one. Then we have to fill in the
48850 * cast linked list. The cast data is initially stored in something like a
48851 * two-dimensional array. Each row corresponds to a type (there are the same
48852 * number of rows as there are in the swig_type_initial array). Each entry in
48853 * a column is one of the swig_cast_info structures for that type.
48854 * The cast_initial array is actually an array of arrays, because each row has
48855 * a variable number of columns. So to actually build the cast linked list,
48856 * we find the array of casts associated with the type, and loop through it
48857 * adding the casts to the list. The one last trick we need to do is making
48858 * sure the type pointer in the swig_cast_info struct is correct.
48859
48860 * First off, we lookup the cast->type name to see if it is already loaded.
48861 * There are three cases to handle:
48862 * 1) If the cast->type has already been loaded AND the type we are adding
48863 * casting info to has not been loaded (it is in this module), THEN we
48864 * replace the cast->type pointer with the type pointer that has already
48865 * been loaded.
48866 * 2) If BOTH types (the one we are adding casting info to, and the
48867 * cast->type) are loaded, THEN the cast info has already been loaded by
48868 * the previous module so we just ignore it.
48869 * 3) Finally, if cast->type has not already been loaded, then we add that
48870 * swig_cast_info to the linked list (because the cast->type) pointer will
48871 * be correct.
48872 **/
48873
48874 #ifdef __cplusplus
48875 extern "C" {
48876 #if 0
48877 } /* c-mode */
48878 #endif
48879 #endif
48880
48881 #if 0
48882 #define SWIGRUNTIME_DEBUG
48883 #endif
48884
48885 SWIGRUNTIME void
48886 SWIG_InitializeModule(void *clientdata) {
48887 size_t i;
48888 swig_module_info *module_head;
48889 static int init_run = 0;
48890
48891 clientdata = clientdata;
48892
48893 if (init_run) return;
48894 init_run = 1;
48895
48896 /* Initialize the swig_module */
48897 swig_module.type_initial = swig_type_initial;
48898 swig_module.cast_initial = swig_cast_initial;
48899
48900 /* Try and load any already created modules */
48901 module_head = SWIG_GetModule(clientdata);
48902 if (module_head) {
48903 swig_module.next = module_head->next;
48904 module_head->next = &swig_module;
48905 } else {
48906 /* This is the first module loaded */
48907 swig_module.next = &swig_module;
48908 SWIG_SetModule(clientdata, &swig_module);
48909 }
48910
48911 /* Now work on filling in swig_module.types */
48912 #ifdef SWIGRUNTIME_DEBUG
48913 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48914 #endif
48915 for (i = 0; i < swig_module.size; ++i) {
48916 swig_type_info *type = 0;
48917 swig_type_info *ret;
48918 swig_cast_info *cast;
48919
48920 #ifdef SWIGRUNTIME_DEBUG
48921 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48922 #endif
48923
48924 /* if there is another module already loaded */
48925 if (swig_module.next != &swig_module) {
48926 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48927 }
48928 if (type) {
48929 /* Overwrite clientdata field */
48930 #ifdef SWIGRUNTIME_DEBUG
48931 printf("SWIG_InitializeModule: found type %s\n", type->name);
48932 #endif
48933 if (swig_module.type_initial[i]->clientdata) {
48934 type->clientdata = swig_module.type_initial[i]->clientdata;
48935 #ifdef SWIGRUNTIME_DEBUG
48936 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48937 #endif
48938 }
48939 } else {
48940 type = swig_module.type_initial[i];
48941 }
48942
48943 /* Insert casting types */
48944 cast = swig_module.cast_initial[i];
48945 while (cast->type) {
48946 /* Don't need to add information already in the list */
48947 ret = 0;
48948 #ifdef SWIGRUNTIME_DEBUG
48949 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48950 #endif
48951 if (swig_module.next != &swig_module) {
48952 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48953 #ifdef SWIGRUNTIME_DEBUG
48954 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48955 #endif
48956 }
48957 if (ret) {
48958 if (type == swig_module.type_initial[i]) {
48959 #ifdef SWIGRUNTIME_DEBUG
48960 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48961 #endif
48962 cast->type = ret;
48963 ret = 0;
48964 } else {
48965 /* Check for casting already in the list */
48966 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48967 #ifdef SWIGRUNTIME_DEBUG
48968 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48969 #endif
48970 if (!ocast) ret = 0;
48971 }
48972 }
48973
48974 if (!ret) {
48975 #ifdef SWIGRUNTIME_DEBUG
48976 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48977 #endif
48978 if (type->cast) {
48979 type->cast->prev = cast;
48980 cast->next = type->cast;
48981 }
48982 type->cast = cast;
48983 }
48984 cast++;
48985 }
48986 /* Set entry in modules->types array equal to the type */
48987 swig_module.types[i] = type;
48988 }
48989 swig_module.types[i] = 0;
48990
48991 #ifdef SWIGRUNTIME_DEBUG
48992 printf("**** SWIG_InitializeModule: Cast List ******\n");
48993 for (i = 0; i < swig_module.size; ++i) {
48994 int j = 0;
48995 swig_cast_info *cast = swig_module.cast_initial[i];
48996 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48997 while (cast->type) {
48998 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48999 cast++;
49000 ++j;
49001 }
49002 printf("---- Total casts: %d\n",j);
49003 }
49004 printf("**** SWIG_InitializeModule: Cast List ******\n");
49005 #endif
49006 }
49007
49008 /* This function will propagate the clientdata field of type to
49009 * any new swig_type_info structures that have been added into the list
49010 * of equivalent types. It is like calling
49011 * SWIG_TypeClientData(type, clientdata) a second time.
49012 */
49013 SWIGRUNTIME void
49014 SWIG_PropagateClientData(void) {
49015 size_t i;
49016 swig_cast_info *equiv;
49017 static int init_run = 0;
49018
49019 if (init_run) return;
49020 init_run = 1;
49021
49022 for (i = 0; i < swig_module.size; i++) {
49023 if (swig_module.types[i]->clientdata) {
49024 equiv = swig_module.types[i]->cast;
49025 while (equiv) {
49026 if (!equiv->converter) {
49027 if (equiv->type && !equiv->type->clientdata)
49028 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
49029 }
49030 equiv = equiv->next;
49031 }
49032 }
49033 }
49034 }
49035
49036 #ifdef __cplusplus
49037 #if 0
49038 {
49039 /* c-mode */
49040 #endif
49041 }
49042 #endif
49043
49044
49045
49046 #ifdef __cplusplus
49047 extern "C" {
49048 #endif
49049
49050 /* Python-specific SWIG API */
49051 #define SWIG_newvarlink() SWIG_Python_newvarlink()
49052 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
49053 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
49054
49055 /* -----------------------------------------------------------------------------
49056 * global variable support code.
49057 * ----------------------------------------------------------------------------- */
49058
49059 typedef struct swig_globalvar {
49060 char *name; /* Name of global variable */
49061 PyObject *(*get_attr)(void); /* Return the current value */
49062 int (*set_attr)(PyObject *); /* Set the value */
49063 struct swig_globalvar *next;
49064 } swig_globalvar;
49065
49066 typedef struct swig_varlinkobject {
49067 PyObject_HEAD
49068 swig_globalvar *vars;
49069 } swig_varlinkobject;
49070
49071 SWIGINTERN PyObject *
49072 swig_varlink_repr(swig_varlinkobject *v) {
49073 v = v;
49074 return PyString_FromString("<Swig global variables>");
49075 }
49076
49077 SWIGINTERN int
49078 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
49079 swig_globalvar *var;
49080 flags = flags;
49081 fprintf(fp,"Swig global variables { ");
49082 for (var = v->vars; var; var=var->next) {
49083 fprintf(fp,"%s", var->name);
49084 if (var->next) fprintf(fp,", ");
49085 }
49086 fprintf(fp," }\n");
49087 return 0;
49088 }
49089
49090 SWIGINTERN PyObject *
49091 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
49092 swig_globalvar *var = v->vars;
49093 while (var) {
49094 if (strcmp(var->name,n) == 0) {
49095 return (*var->get_attr)();
49096 }
49097 var = var->next;
49098 }
49099 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
49100 return NULL;
49101 }
49102
49103 SWIGINTERN int
49104 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
49105 swig_globalvar *var = v->vars;
49106 while (var) {
49107 if (strcmp(var->name,n) == 0) {
49108 return (*var->set_attr)(p);
49109 }
49110 var = var->next;
49111 }
49112 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
49113 return 1;
49114 }
49115
49116 SWIGINTERN PyTypeObject*
49117 swig_varlink_type(void) {
49118 static char varlink__doc__[] = "Swig var link object";
49119 static PyTypeObject varlink_type
49120 #if !defined(__cplusplus)
49121 ;
49122 static int type_init = 0;
49123 if (!type_init) {
49124 PyTypeObject tmp
49125 #endif
49126 = {
49127 PyObject_HEAD_INIT(&PyType_Type)
49128 0, /* Number of items in variable part (ob_size) */
49129 (char *)"swigvarlink", /* Type name (tp_name) */
49130 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
49131 0, /* Itemsize (tp_itemsize) */
49132 0, /* Deallocator (tp_dealloc) */
49133 (printfunc) swig_varlink_print, /* Print (tp_print) */
49134 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
49135 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
49136 0, /* tp_compare */
49137 (reprfunc) swig_varlink_repr, /* tp_repr */
49138 0, /* tp_as_number */
49139 0, /* tp_as_sequence */
49140 0, /* tp_as_mapping */
49141 0, /* tp_hash */
49142 0, /* tp_call */
49143 0, /* tp_str */
49144 0, /* tp_getattro */
49145 0, /* tp_setattro */
49146 0, /* tp_as_buffer */
49147 0, /* tp_flags */
49148 varlink__doc__, /* tp_doc */
49149 #if PY_VERSION_HEX >= 0x02000000
49150 0, /* tp_traverse */
49151 0, /* tp_clear */
49152 #endif
49153 #if PY_VERSION_HEX >= 0x02010000
49154 0, /* tp_richcompare */
49155 0, /* tp_weaklistoffset */
49156 #endif
49157 #if PY_VERSION_HEX >= 0x02020000
49158 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
49159 #endif
49160 #if PY_VERSION_HEX >= 0x02030000
49161 0, /* tp_del */
49162 #endif
49163 #ifdef COUNT_ALLOCS
49164 0,0,0,0 /* tp_alloc -> tp_next */
49165 #endif
49166 };
49167 #if !defined(__cplusplus)
49168 varlink_type = tmp;
49169 type_init = 1;
49170 }
49171 #endif
49172 return &varlink_type;
49173 }
49174
49175 /* Create a variable linking object for use later */
49176 SWIGINTERN PyObject *
49177 SWIG_Python_newvarlink(void) {
49178 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
49179 if (result) {
49180 result->vars = 0;
49181 }
49182 return ((PyObject*) result);
49183 }
49184
49185 SWIGINTERN void
49186 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
49187 swig_varlinkobject *v = (swig_varlinkobject *) p;
49188 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
49189 if (gv) {
49190 size_t size = strlen(name)+1;
49191 gv->name = (char *)malloc(size);
49192 if (gv->name) {
49193 strncpy(gv->name,name,size);
49194 gv->get_attr = get_attr;
49195 gv->set_attr = set_attr;
49196 gv->next = v->vars;
49197 }
49198 }
49199 v->vars = gv;
49200 }
49201
49202 /* -----------------------------------------------------------------------------
49203 * constants/methods manipulation
49204 * ----------------------------------------------------------------------------- */
49205
49206 /* Install Constants */
49207 SWIGINTERN void
49208 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
49209 PyObject *obj = 0;
49210 size_t i;
49211 for (i = 0; constants[i].type; ++i) {
49212 switch(constants[i].type) {
49213 case SWIG_PY_INT:
49214 obj = PyInt_FromLong(constants[i].lvalue);
49215 break;
49216 case SWIG_PY_FLOAT:
49217 obj = PyFloat_FromDouble(constants[i].dvalue);
49218 break;
49219 case SWIG_PY_STRING:
49220 if (constants[i].pvalue) {
49221 obj = PyString_FromString((char *) constants[i].pvalue);
49222 } else {
49223 Py_INCREF(Py_None);
49224 obj = Py_None;
49225 }
49226 break;
49227 case SWIG_PY_POINTER:
49228 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
49229 break;
49230 case SWIG_PY_BINARY:
49231 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
49232 break;
49233 default:
49234 obj = 0;
49235 break;
49236 }
49237 if (obj) {
49238 PyDict_SetItemString(d,constants[i].name,obj);
49239 Py_DECREF(obj);
49240 }
49241 }
49242 }
49243
49244 /* -----------------------------------------------------------------------------*/
49245 /* Fix SwigMethods to carry the callback ptrs when needed */
49246 /* -----------------------------------------------------------------------------*/
49247
49248 SWIGINTERN void
49249 SWIG_Python_FixMethods(PyMethodDef *methods,
49250 swig_const_info *const_table,
49251 swig_type_info **types,
49252 swig_type_info **types_initial) {
49253 size_t i;
49254 for (i = 0; methods[i].ml_name; ++i) {
49255 char *c = methods[i].ml_doc;
49256 if (c && (c = strstr(c, "swig_ptr: "))) {
49257 int j;
49258 swig_const_info *ci = 0;
49259 char *name = c + 10;
49260 for (j = 0; const_table[j].type; ++j) {
49261 if (strncmp(const_table[j].name, name,
49262 strlen(const_table[j].name)) == 0) {
49263 ci = &(const_table[j]);
49264 break;
49265 }
49266 }
49267 if (ci) {
49268 size_t shift = (ci->ptype) - types;
49269 swig_type_info *ty = types_initial[shift];
49270 size_t ldoc = (c - methods[i].ml_doc);
49271 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49272 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49273 if (ndoc) {
49274 char *buff = ndoc;
49275 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49276 if (ptr) {
49277 strncpy(buff, methods[i].ml_doc, ldoc);
49278 buff += ldoc;
49279 strncpy(buff, "swig_ptr: ", 10);
49280 buff += 10;
49281 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49282 methods[i].ml_doc = ndoc;
49283 }
49284 }
49285 }
49286 }
49287 }
49288 }
49289
49290 /* -----------------------------------------------------------------------------*
49291 * Initialize type list
49292 * -----------------------------------------------------------------------------*/
49293
49294 #ifdef __cplusplus
49295 }
49296 #endif
49297
49298 /* -----------------------------------------------------------------------------*
49299 * Partial Init method
49300 * -----------------------------------------------------------------------------*/
49301
49302 #ifdef __cplusplus
49303 extern "C"
49304 #endif
49305 SWIGEXPORT void SWIG_init(void) {
49306 static PyObject *SWIG_globals = 0;
49307 PyObject *m, *d;
49308 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49309
49310 /* Fix SwigMethods to carry the callback ptrs when needed */
49311 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49312
49313 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49314 d = PyModule_GetDict(m);
49315
49316 SWIG_InitializeModule(0);
49317 SWIG_InstallConstants(d,swig_const_table);
49318
49319
49320 #ifndef wxPyUSE_EXPORT
49321 // Make our API structure a CObject so other modules can import it
49322 // from this module.
49323 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49324 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49325 Py_XDECREF(cobj);
49326 #endif
49327
49328 {
49329 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49429 }
49430 {
49431 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49432 }
49433 {
49434 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49600 }
49601 {
49602 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49603 }
49604 {
49605 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49606 }
49607 {
49608 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49618 }
49619 {
49620 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49621 }
49622 {
49623 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49627 }
49628 {
49629 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49630 }
49631 {
49632 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49633 }
49634 {
49635 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49636 }
49637 {
49638 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49693 }
49694 {
49695 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49696 }
49697 {
49698 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49699 }
49700 {
49701 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49702 }
49703 {
49704 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49705 }
49706 {
49707 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49708 }
49709 {
49710 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49717 }
49718 {
49719 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49720 }
49721 {
49722 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49723 }
49724 {
49725 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49726 }
49727 {
49728 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49729 }
49730 {
49731 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49732 }
49733 {
49734 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49735 }
49736 {
49737 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49738 }
49739 {
49740 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49741 }
49742 {
49743 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49744 }
49745 {
49746 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49747 }
49748 {
49749 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49750 }
49751 {
49752 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49762 }
49763 {
49764 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49765 }
49766 {
49767 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49768 }
49769 {
49770 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49771 }
49772 {
49773 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49774 }
49775 {
49776 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49825 }
49826 {
49827 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49831 }
49832 {
49833 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49834 }
49835 {
49836 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49837 }
49838 {
49839 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49840 }
49841 {
49842 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49849 }
49850 {
49851 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49852 }
49853 {
49854 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49855 }
49856 {
49857 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49870 }
49871 {
49872 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49873 }
49874 {
49875 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49876 }
49877 {
49878 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49879 }
49880 {
49881 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49882 }
49883 {
49884 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49888 }
49889 {
49890 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49894 }
49895 {
49896 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49897 }
49898 {
49899 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49900 }
49901 {
49902 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49903 }
49904 {
49905 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49906 }
49907 {
49908 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49909 }
49910 {
49911 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49912 }
49913 {
49914 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49915 }
49916 {
49917 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49918 }
49919 {
49920 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49921 }
49922 {
49923 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49924 }
49925 {
49926 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49927 }
49928 {
49929 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49930 }
49931 {
49932 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49933 }
49934 {
49935 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49936 }
49937 {
49938 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49939 }
49940 {
49941 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49942 }
49943 {
49944 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49945 }
49946 {
49947 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49948 }
49949 {
49950 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49951 }
49952 {
49953 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49954 }
49955 {
49956 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49957 }
49958 {
49959 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49960 }
49961 {
49962 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49963 }
49964 {
49965 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49966 }
49967 {
49968 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49969 }
49970 {
49971 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49972 }
49973 {
49974 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49975 }
49976 {
49977 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49978 }
49979 {
49980 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49981 }
49982 {
49983 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49984 }
49985 {
49986 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49987 }
49988 {
49989 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49990 }
49991 {
49992 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49993 }
49994 {
49995 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49996 }
49997 {
49998 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49999 }
50000 {
50001 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
50002 }
50003 {
50004 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
50005 }
50006 {
50007 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
50008 }
50009 {
50010 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
50011 }
50012 {
50013 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
50014 }
50015 {
50016 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
50017 }
50018 {
50019 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
50020 }
50021 {
50022 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
50023 }
50024 {
50025 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
50026 }
50027 {
50028 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
50029 }
50030 {
50031 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
50032 }
50033 {
50034 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
50035 }
50036 {
50037 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
50038 }
50039 {
50040 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
50041 }
50042 {
50043 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
50044 }
50045 {
50046 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
50047 }
50048 {
50049 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
50050 }
50051 {
50052 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
50053 }
50054 {
50055 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
50056 }
50057 {
50058 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
50059 }
50060 {
50061 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
50062 }
50063 {
50064 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
50065 }
50066 {
50067 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
50068 }
50069 {
50070 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
50071 }
50072 {
50073 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
50074 }
50075 {
50076 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
50077 }
50078 {
50079 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
50080 }
50081 {
50082 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
50083 }
50084 {
50085 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
50086 }
50087 {
50088 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
50089 }
50090 {
50091 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
50092 }
50093 {
50094 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
50095 }
50096 {
50097 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
50098 }
50099 {
50100 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
50101 }
50102 {
50103 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
50104 }
50105 {
50106 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
50107 }
50108 {
50109 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
50110 }
50111 {
50112 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
50113 }
50114 {
50115 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
50116 }
50117 {
50118 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
50119 }
50120 {
50121 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
50122 }
50123 {
50124 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
50125 }
50126 {
50127 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
50128 }
50129 {
50130 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
50131 }
50132 {
50133 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
50134 }
50135 {
50136 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
50137 }
50138 {
50139 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
50140 }
50141 {
50142 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
50143 }
50144 {
50145 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
50146 }
50147 {
50148 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
50149 }
50150 {
50151 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
50152 }
50153 {
50154 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
50155 }
50156 {
50157 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
50158 }
50159 {
50160 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
50161 }
50162 {
50163 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
50164 }
50165 {
50166 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
50167 }
50168 {
50169 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
50170 }
50171 {
50172 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
50173 }
50174 {
50175 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
50176 }
50177 {
50178 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
50179 }
50180 {
50181 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
50182 }
50183 {
50184 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
50185 }
50186 {
50187 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
50188 }
50189 {
50190 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
50191 }
50192 {
50193 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
50194 }
50195 {
50196 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
50197 }
50198 {
50199 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
50200 }
50201 {
50202 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
50203 }
50204 {
50205 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
50206 }
50207 {
50208 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
50209 }
50210 {
50211 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
50212 }
50213 {
50214 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
50215 }
50216 {
50217 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
50218 }
50219 {
50220 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
50221 }
50222 {
50223 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
50224 }
50225 {
50226 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
50227 }
50228 {
50229 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
50230 }
50231 {
50232 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
50233 }
50234 {
50235 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
50236 }
50237 {
50238 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
50239 }
50240 {
50241 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
50242 }
50243 {
50244 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
50245 }
50246 {
50247 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
50248 }
50249 {
50250 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
50251 }
50252 {
50253 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
50254 }
50255 {
50256 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50257 }
50258 {
50259 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50260 }
50261 {
50262 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50263 }
50264 {
50265 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50266 }
50267 {
50268 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50269 }
50270 {
50271 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50272 }
50273 {
50274 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50275 }
50276 {
50277 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50278 }
50279 {
50280 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50281 }
50282 {
50283 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50284 }
50285 {
50286 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50287 }
50288 {
50289 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50290 }
50291 {
50292 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50293 }
50294 {
50295 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50296 }
50297 {
50298 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50299 }
50300 {
50301 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50302 }
50303 {
50304 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50305 }
50306 {
50307 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50308 }
50309 {
50310 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50311 }
50312 {
50313 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50314 }
50315 {
50316 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50317 }
50318 {
50319 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50320 }
50321 {
50322 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50323 }
50324 {
50325 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50326 }
50327 {
50328 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50329 }
50330 {
50331 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50332 }
50333 {
50334 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50335 }
50336 {
50337 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50338 }
50339 {
50340 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50341 }
50342 {
50343 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50344 }
50345 {
50346 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50347 }
50348 {
50349 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50350 }
50351 {
50352 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50353 }
50354 {
50355 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50356 }
50357 {
50358 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50359 }
50360 {
50361 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50362 }
50363 {
50364 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50365 }
50366 {
50367 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50368 }
50369 {
50370 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50371 }
50372 {
50373 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50374 }
50375 {
50376 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50377 }
50378 {
50379 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50380 }
50381 {
50382 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50383 }
50384 {
50385 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50386 }
50387 {
50388 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50389 }
50390 {
50391 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50392 }
50393 {
50394 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50395 }
50396 {
50397 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50398 }
50399 {
50400 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50401 }
50402 {
50403 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50404 }
50405 {
50406 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50407 }
50408 {
50409 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50410 }
50411 {
50412 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50413 }
50414 {
50415 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50416 }
50417 {
50418 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50419 }
50420 {
50421 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50422 }
50423 {
50424 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50425 }
50426 {
50427 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50428 }
50429 {
50430 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50431 }
50432 {
50433 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50434 }
50435 {
50436 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50437 }
50438 {
50439 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50440 }
50441 {
50442 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50443 }
50444 {
50445 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50446 }
50447 {
50448 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50449 }
50450 {
50451 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50452 }
50453 {
50454 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50455 }
50456 {
50457 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50458 }
50459 {
50460 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50461 }
50462 {
50463 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50464 }
50465 {
50466 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50467 }
50468 {
50469 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50470 }
50471 {
50472 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50473 }
50474 {
50475 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50476 }
50477 {
50478 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50479 }
50480 {
50481 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50482 }
50483 {
50484 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50485 }
50486 {
50487 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50488 }
50489 {
50490 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50491 }
50492 {
50493 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50494 }
50495 {
50496 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50497 }
50498 {
50499 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50500 }
50501 {
50502 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50503 }
50504 {
50505 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50506 }
50507 {
50508 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50509 }
50510 {
50511 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50512 }
50513 {
50514 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50515 }
50516 {
50517 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50518 }
50519 {
50520 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50521 }
50522 {
50523 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50524 }
50525 {
50526 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50527 }
50528 {
50529 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50530 }
50531 {
50532 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50533 }
50534 {
50535 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50536 }
50537 {
50538 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50539 }
50540 {
50541 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50542 }
50543 {
50544 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50545 }
50546 {
50547 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50548 }
50549 {
50550 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50551 }
50552 {
50553 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50554 }
50555 {
50556 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50557 }
50558 {
50559 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50560 }
50561 {
50562 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50563 }
50564 {
50565 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50566 }
50567 {
50568 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50569 }
50570 {
50571 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50572 }
50573 {
50574 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50575 }
50576 {
50577 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50578 }
50579 {
50580 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50581 }
50582 {
50583 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50584 }
50585 {
50586 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50587 }
50588 {
50589 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50590 }
50591 {
50592 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50593 }
50594 {
50595 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50596 }
50597 {
50598 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50599 }
50600 {
50601 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50602 }
50603 {
50604 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50605 }
50606 {
50607 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50608 }
50609 {
50610 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50611 }
50612 {
50613 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50614 }
50615 {
50616 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50617 }
50618 {
50619 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50620 }
50621 {
50622 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50623 }
50624 {
50625 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50626 }
50627 {
50628 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50629 }
50630 {
50631 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50632 }
50633 {
50634 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50635 }
50636 {
50637 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50638 }
50639 {
50640 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50641 }
50642 {
50643 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50644 }
50645 {
50646 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50647 }
50648 {
50649 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50650 }
50651 {
50652 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50653 }
50654 {
50655 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50656 }
50657 {
50658 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50659 }
50660 {
50661 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50662 }
50663 {
50664 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50665 }
50666 {
50667 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50668 }
50669 {
50670 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50671 }
50672 {
50673 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50674 }
50675 {
50676 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50677 }
50678 {
50679 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50680 }
50681 {
50682 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50683 }
50684 {
50685 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50686 }
50687 {
50688 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50689 }
50690 {
50691 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50692 }
50693 {
50694 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50695 }
50696 {
50697 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50698 }
50699 {
50700 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50701 }
50702 {
50703 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50704 }
50705 {
50706 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50707 }
50708 {
50709 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50710 }
50711 {
50712 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50713 }
50714 {
50715 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50716 }
50717 {
50718 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50719 }
50720 {
50721 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50722 }
50723 {
50724 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50725 }
50726 {
50727 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50728 }
50729 {
50730 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50731 }
50732 {
50733 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50734 }
50735 {
50736 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50737 }
50738 {
50739 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50740 }
50741 {
50742 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50743 }
50744 {
50745 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50746 }
50747 {
50748 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50749 }
50750 {
50751 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50752 }
50753 {
50754 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50755 }
50756 {
50757 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50758 }
50759 {
50760 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50761 }
50762 {
50763 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50764 }
50765 {
50766 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50767 }
50768 {
50769 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50770 }
50771 {
50772 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50773 }
50774 {
50775 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50776 }
50777 {
50778 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50779 }
50780 {
50781 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50782 }
50783 {
50784 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50785 }
50786 {
50787 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50788 }
50789 {
50790 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50791 }
50792 {
50793 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50794 }
50795 {
50796 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50797 }
50798 {
50799 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50800 }
50801 {
50802 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50803 }
50804 {
50805 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50806 }
50807 {
50808 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50809 }
50810 {
50811 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50812 }
50813 {
50814 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50815 }
50816 {
50817 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50818 }
50819 {
50820 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50821 }
50822 {
50823 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50824 }
50825 {
50826 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50827 }
50828 {
50829 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50830 }
50831 {
50832 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50833 }
50834 {
50835 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50836 }
50837 {
50838 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50839 }
50840 {
50841 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50842 }
50843 {
50844 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50845 }
50846 {
50847 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50848 }
50849 {
50850 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50851 }
50852 {
50853 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50854 }
50855 {
50856 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50857 }
50858 {
50859 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50860 }
50861 {
50862 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50863 }
50864 {
50865 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50866 }
50867 {
50868 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50869 }
50870 {
50871 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50872 }
50873 {
50874 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50875 }
50876 {
50877 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50878 }
50879 {
50880 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50881 }
50882 {
50883 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50884 }
50885 {
50886 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50887 }
50888 {
50889 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50890 }
50891 {
50892 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50893 }
50894 {
50895 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50896 }
50897 {
50898 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50899 }
50900 {
50901 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50902 }
50903 {
50904 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50905 }
50906 {
50907 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50908 }
50909 {
50910 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50911 }
50912 {
50913 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50914 }
50915 {
50916 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50917 }
50918 {
50919 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50920 }
50921 {
50922 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50923 }
50924 {
50925 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50926 }
50927 {
50928 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50929 }
50930 {
50931 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50932 }
50933 {
50934 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50935 }
50936 {
50937 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50938 }
50939 {
50940 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50941 }
50942 {
50943 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50944 }
50945 {
50946 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50947 }
50948 {
50949 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50950 }
50951 {
50952 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50953 }
50954 {
50955 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50956 }
50957 {
50958 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50959 }
50960 {
50961 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50962 }
50963 {
50964 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50965 }
50966 {
50967 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50968 }
50969 {
50970 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50971 }
50972 {
50973 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50974 }
50975 {
50976 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50977 }
50978 {
50979 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50980 }
50981 {
50982 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50983 }
50984 {
50985 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50986 }
50987 {
50988 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50989 }
50990 {
50991 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50992 }
50993 {
50994 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50995 }
50996 {
50997 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50998 }
50999 {
51000 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
51001 }
51002 {
51003 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
51004 }
51005 {
51006 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
51007 }
51008 {
51009 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
51010 }
51011 {
51012 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
51013 }
51014 {
51015 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
51016 }
51017 {
51018 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
51019 }
51020 {
51021 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
51022 }
51023 {
51024 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
51025 }
51026 {
51027 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
51028 }
51029 {
51030 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
51031 }
51032 {
51033 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
51034 }
51035 {
51036 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
51037 }
51038 {
51039 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
51040 }
51041 {
51042 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
51043 }
51044 {
51045 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
51046 }
51047 {
51048 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
51049 }
51050 {
51051 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
51052 }
51053 {
51054 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
51055 }
51056 {
51057 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
51058 }
51059 {
51060 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
51061 }
51062 {
51063 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
51064 }
51065 {
51066 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
51067 }
51068 {
51069 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
51070 }
51071 {
51072 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
51073 }
51074 {
51075 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
51076 }
51077 {
51078 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
51079 }
51080 {
51081 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
51082 }
51083 {
51084 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
51085 }
51086 {
51087 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
51088 }
51089 {
51090 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
51091 }
51092 {
51093 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
51094 }
51095 {
51096 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
51097 }
51098 {
51099 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
51100 }
51101 {
51102 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
51103 }
51104 {
51105 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
51106 }
51107 {
51108 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
51109 }
51110 {
51111 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
51112 }
51113 {
51114 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
51115 }
51116 {
51117 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
51118 }
51119 {
51120 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
51121 }
51122 {
51123 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
51124 }
51125 {
51126 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
51127 }
51128 {
51129 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
51130 }
51131 {
51132 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
51133 }
51134 {
51135 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
51136 }
51137 {
51138 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
51139 }
51140 {
51141 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
51142 }
51143 {
51144 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
51145 }
51146 {
51147 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
51148 }
51149 {
51150 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
51151 }
51152 {
51153 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
51154 }
51155 {
51156 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
51157 }
51158 {
51159 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
51160 }
51161 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
51162 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
51163 {
51164 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
51165 }
51166 {
51167 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
51168 }
51169 {
51170 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
51171 }
51172 {
51173 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
51174 }
51175 {
51176 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
51177 }
51178 {
51179 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
51180 }
51181 {
51182 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
51183 }
51184 {
51185 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
51186 }
51187 {
51188 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
51189 }
51190 {
51191 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
51192 }
51193 {
51194 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
51195 }
51196 {
51197 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
51198 }
51199 {
51200 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
51201 }
51202 {
51203 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
51204 }
51205 {
51206 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
51207 }
51208 {
51209 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
51210 }
51211 {
51212 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
51213 }
51214 {
51215 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
51216 }
51217 {
51218 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
51219 }
51220 {
51221 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
51222 }
51223 {
51224 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
51225 }
51226 {
51227 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
51228 }
51229 {
51230 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
51231 }
51232 {
51233 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
51234 }
51235 {
51236 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
51237 }
51238 {
51239 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
51240 }
51241 {
51242 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
51243 }
51244 {
51245 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
51246 }
51247 {
51248 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
51249 }
51250 {
51251 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
51252 }
51253 {
51254 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
51255 }
51256 {
51257 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51258 }
51259 {
51260 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51261 }
51262 {
51263 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51264 }
51265 {
51266 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51267 }
51268 {
51269 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51270 }
51271 {
51272 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51273 }
51274 {
51275 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51276 }
51277 {
51278 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51279 }
51280 {
51281 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51282 }
51283 {
51284 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51285 }
51286 {
51287 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51288 }
51289 {
51290 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51291 }
51292 {
51293 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51294 }
51295 {
51296 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51297 }
51298 {
51299 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51300 }
51301 {
51302 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51303 }
51304 {
51305 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51306 }
51307 {
51308 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51309 }
51310 {
51311 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51312 }
51313 {
51314 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51315 }
51316 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51317 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51318 {
51319 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51320 }
51321 {
51322 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51323 }
51324 {
51325 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51326 }
51327
51328 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51329
51330
51331 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51332
51333 {
51334 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51335 }
51336 {
51337 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51338 }
51339 {
51340 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51341 }
51342 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51343 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51344 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51345 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51346 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51347 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51348 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51349 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51350 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51351 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51352 {
51353 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51354 }
51355 {
51356 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51357 }
51358 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51359 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51360 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51361 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51362 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51363 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51364 {
51365 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51366 }
51367 {
51368 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51369 }
51370 {
51371 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51372 }
51373 {
51374 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51375 }
51376 {
51377 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51378 }
51379 {
51380 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51381 }
51382 {
51383 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51384 }
51385 {
51386 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51387 }
51388 {
51389 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51390 }
51391 {
51392 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51393 }
51394 {
51395 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51396 }
51397 {
51398 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51399 }
51400 {
51401 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51402 }
51403 {
51404 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51405 }
51406 {
51407 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51408 }
51409 {
51410 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51411 }
51412 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51413 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51414 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51415 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51416 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51417 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51418 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51419 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51420 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51421 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51422 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51423 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51424 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51425 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51426 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51427 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51428 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51429 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51430 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51431 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51432 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51433 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51434 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51435 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51436 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51437 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51438 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51439 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51440 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51441 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51442 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51443 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51444 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51445 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51446 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51447 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51448 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51449 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51450 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51451 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51452 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51453 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51454 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51455 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51456 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51457 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51458 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51459 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51460 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51461 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51462 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51463 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51464 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51465 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51466 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51467 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51468 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51469 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51470 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51471 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51472 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51473 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51474 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51475 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51476 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51477 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51478 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51479 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51480 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51481 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51482 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51483 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51484 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51485 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51486 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51487 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51488 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51489 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51490 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51491 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51492 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51493 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51494 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51495 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51496 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51497 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51498 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51499 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51500 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51501 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51502 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51503 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51504 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51505 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51506 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51507 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51508 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51509 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51510 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51511 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51512 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51513 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51514 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51515 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51516 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51517 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51518 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51519 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51520 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51521 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51522 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51523 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51524 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51525 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51526 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51527 {
51528 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51529 }
51530 {
51531 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51532 }
51533 {
51534 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51535 }
51536 {
51537 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51538 }
51539 {
51540 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51541 }
51542 {
51543 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51544 }
51545 {
51546 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51547 }
51548 {
51549 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51550 }
51551 {
51552 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51553 }
51554 {
51555 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51556 }
51557 {
51558 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51559 }
51560 {
51561 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51562 }
51563 {
51564 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51565 }
51566 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51567 {
51568 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51569 }
51570 {
51571 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51572 }
51573 {
51574 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51575 }
51576 {
51577 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51578 }
51579 {
51580 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51581 }
51582 {
51583 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51584 }
51585 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51586 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51587 {
51588 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51589 }
51590 {
51591 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51592 }
51593 {
51594 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51595 }
51596 {
51597 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51598 }
51599 {
51600 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51601 }
51602 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51603 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51604 {
51605 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51606 }
51607 {
51608 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51609 }
51610 {
51611 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51612 }
51613 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51614 {
51615 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51616 }
51617 {
51618 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51619 }
51620 {
51621 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51622 }
51623 {
51624 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51625 }
51626 {
51627 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51628 }
51629 {
51630 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51631 }
51632 {
51633 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51634 }
51635 {
51636 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51637 }
51638 {
51639 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51640 }
51641 {
51642 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51643 }
51644 {
51645 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51646 }
51647 {
51648 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51649 }
51650 {
51651 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51652 }
51653 {
51654 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51655 }
51656 {
51657 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51658 }
51659 {
51660 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51661 }
51662 {
51663 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51664 }
51665 {
51666 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51667 }
51668 {
51669 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51670 }
51671
51672 // Initialize threading, some globals and such
51673 __wxPyPreStart(d);
51674
51675
51676 // Although these are defined in __version__ they need to be here too so
51677 // that an assert can be done to ensure that the wxPython and the wxWindows
51678 // versions match.
51679 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51680 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51681 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51682
51683 }
51684
wxWidgets (Impactor)